ALGUNS CONCEITOS DA LINGUAGEM BORLAND DELPHI
» PALAVRAS CHAVE
Palavras-chave ou palavras reservadas são aquelas usadas pela sintaxe da linguagem com significado especifico e, portanto, não podem ser usadas com outra finalidade. As palavras-chave aparecem em negrito no Code Editor.
Em nosso módulo de código forma, encontramos as seguintes palavra-chave, exibidas em negrito:
 |
unit : esta palavra-chave define o nome da unidade de código. Este nome será inserido na cláusula uses de outras unidades que precisem fazer referencia a esta unidade. |
|
interface : define o inicio de um trecho de código que termina antes da palavra-chave implementation. |
Neste trecho se insere o código que poderá ser acessado por outras unidades. E aqui que se declaram as constantes, as variáveis. Os tipos de dados, funções e procedimentos a serem utilizados por outras unidades de c6digo.
|
uses: esta palavra especifica as unidades de código que serão acessadas por esta unidade. |
|
type : com esta palavra-chave o Delphi define o inicio do trecho de código em que são definidos os tipos de variáveis e de classes criados pelo programa. O aluno pode observar que o Delphi já utilizou esta parte para declarar a classe TFormaPrincipal. |
|
private : define os elementos de uma classe que não poderão ser acessados de fora da classe; |
|
public : define os elementos de uma classe que poderão ser acessados de fora da classe. |
|
var : define o inicio do trecho de código em que são declaradas as variáveis e objetos. |
|
implementation : define o inicio do trecho de código em que são implementadas as funções e procedimentos declaradas no trecho iniciado pela palavra chave interface. |
|
end : palavra-chave usada para encerrar um bloco de código. São blocos de código: |
• um bloco de comandos iniciado pela palavra chave begin, caso em que end deve ser seguida de um ponto-e-virgula (;).
• a definição de uma unit; neste caso a palavra end deve ser seguida de um ponto (.) e este será o final do arquivo.
|
Exceção : antes da cláusula else em instruções condicionais if-then-else compostas, não se insere ponto (.) ou ponto-e-virgula (;), utilizando-se apenas a palavra end |
» VARIAVEIS
Nossos dados são armazenados na memória do computador. Para que nós não tenhamos que nos referir a estes dados de forma direta, através de um endereço numérico difícil de memorizar, o compilador nos permite utilizar variáveis com esta finalidade. Escolhendo nomes sugestivos (mnemônicos) para nossas variáveis facilitamos bastante a compreensão de nosso código.
Para que o Delphi possa usar nossas variáveis, devemos primeiro declara-las, isto é, informar o nome e o tipo desejados. Por exemplo : o comando a seguir declara idade como sendo uma variável do tipo inteiro (integer): idade : integer;
As variáveis inteiras podem assumir valores entre -32768 e +32767. Elas ocupam 2 bytes na memória. Assim sendo, a declaração acima faz com que o Delphi reserve 2 bytes para a nossa variável idade. Note que a declaração do tipo de uma variável, em princípio não lhe atribui valores. Um erro comum em programação é tentarmos ler valores de variáveis não inicializadas, ou as quais ainda não se atribuiu valores.
Damos a seguir uma lista dos tipos de variáveis mais comuns do Object Pascal com suas faixas de valores e o espaço ocupado em memória:
|
BOOLEAN: Tipo lógico que pode assumir somente os valores TRUE ou FALSE e ocupa 1 byte de memória. |
|
BYTE: Tipo numérico inteiro, pode assumir valores numa faixa de 0 a 255, ocupa 1 byte. |
|
CHAR: Tipo alfa-numérico, pode armazenar um caractere ASCII, ocupa 1 byte. |
|
COMP:Tipo numérico real, pode assumir valores na faixa de -9.2.1018 a 9.2.10+18, ocupa 8 bytes, pode ter entre 19 e 20 algarismos significativos. |
|
EXTENDED: Tipo numérico real, pode assumir valores na faixa de 3,4.10-4932 a +1,1.10+4932, ocupa 10 bytes de memória e tem entre 19 e 20 algarismos significativos. |
|
INTEGER: Tipo numérico inteiro, pode assumir valores numa faixa de -32768 a +32767, ocupa 2 byte de memória. |
|
LONGINT: Tipo numérico inteiro, pode assumir valores numa faixa de -2147483648 a +2147483647, ocupa 4 bytes de memória. |
|
REAL: Tipo numérico real, pode assumir valores na faixa de -2,9.10-39 a +1,7.10+38, ocupa 6 bytes de memória e tem entre 11 e 12 algarismos significativos. |
|
SHORTINT: Tipo numérico inteiro, pode assumir valores numa faixa de -128 a +127, ocupa 1 byte de memória. |
|
SINGLE: Tipo numérico real, pode assumir valores numa faixa de –1,5,10-45 a +3,4.10+38, ocupa 4 bytes de memória, e tem de 7 a 8 algarismos significativos. |
|
WORD: Tipo numérico inteiro, pode assumir valores numa faixa de 0 a 65535, ocupa 2bytes de memória. |
|
STRING: Tipo alfanumérico, possuindo como conteúdo uma cadeia de caracteres. O número de bytes ocupados na memória varia de 2 a 256, dependendo da quantidade máxima de caracteres definidos para a string. O primeiro byte contem a quantidade relativa de caracteres da cadeia. |
Os nomes de variáveis devem começar com uma letra ou o caractere sublinhado (_) seguido por uma seqüência de letras, digitos ou caractere sublinhado (_) e não podem conter espaço em branco nem quaisquer tipos de acentos. Os nomes de variáveis podem ter qualquer tamanho mas somente os 63 primeiros caracteres serão considerados.
Exemplos : Para definir uma variável Nome do tipo string e uma variável Salario do tipo double, podemos inserir as seguintes linhas de código na cláusula var da unidade de código correspondente.
Nome : string;
Salario : double;
Pode-se declarar mais de uma variável do mesmo tipo na mesma linha, separando-as por virgula. nome, função, endereço : string;
» ARRAYS (VETORES)
Arrays são conjuntos de variáveis com o mesmo nome e diferenciadas entre si por um indice. Eles são úteis para manipularmos grandes quantidades de dados de um mesmo tipo pois evitam a declaração de diversas variáveis.
Considere o caso de um programa de Folha de Pagamento que precise armazenar os seguintes dados referentes a 100 funcionários: nome, função, salário, etc… Seriamos obrigados a declarar 100 variáveis nome, 100 variáveis função, etc… O array nos permite declarar uma única variável com um índice para apontar para as diferentes ocorrências.
Declara-se um array da seguinte forma:
» nome_da_variavel : array[i1 .i2] of tipo_de_variavel onde i1 e i2 representam os valores mínimo e máximo, respectivamente, do índice.
O Object Pascal permite que i1 e i2 possuam qualquer valor desde que i1 seja menor ou igual a i2. Assim, poderíamos declarar um array de 100 variáveis inteira idade de varias formas diferentes:
» idade : array [1..100] of integer; ou
idade : array [-100..-1] of integer; ou
idade : array [0. .99] of integer, etc…
Pode-se definir arrays multidimensionais (com vários indices) como, por exemplo:
» espaco3d: array[1 .10,-5. .20,0. .30] of double; que pode armazenar 10x26x31 =8060 variáveis do tipo double.
Um dos casos mais comuns é a matriz com m linhas e n colunas: matriz : array[1 ..m,1 ..n] of qqer_tipo. Os elementos dos arrays podem ser quaisquer tipos de variáveis ou objetos.
» RECORDS (REGISTROS)
O Object Pascal permite definir tipos compostos de variáveis denominados registros. Define-se da seguinte forma:
nome_do_tipo: Record
variavel1 : primeiro-tipo;
variavel2 : segundo~tipo;
end;
variaveln : n-ézimo-tipo;
» variável1 ,variavel2.. variáveis são chamadas de campos do registro.
Declaramos uma variável deste tipo da mesma forma que procedemos para declarar variáveis de qualquer tipo pré-definido
variável : nome_do_tipo;
Usamos a notação de ponto para acessar um campo de uma variável composta:
nome_da_variável.nome_do_campo;
Exemplo:
funcionario = Record
nome : string;
funcao : string;
salario : double:
end;
Assim, no exemplo citado anteriormente, ao invés de declararmos um array nome de 100 elementos, um array função de 100 elementos, um array salário de 100 elementos, podemos declarar uma única variável chamada empregado, por exemplo, como sendo um array de 100 elementos do tipo funcionário.
empregado: array[1 .100] of funcionario;
Para obter os dados do décimo funcionário, basta fazer:
empregado[10].nome; empregado[10].função; empregado[10].salario;
» CLASSES E OBJETOS
Definição de classe:
nome_da_classe_derivada = class(nome_da_classe-base) private
{propriedades, campos e métodos privados} public
{propriedades, campos e métodos Públicos} end;
A definição de uma classe é bastante similar a de um registro. As classes, diferentemente dos registros podem conter funções ou procedimentos, chamados métodos, além de variáveis.
Quando uma classe é derivada de outra (chamada classe base, classe pai ou classe mãe), ela herda os campos, propriedades e métodos da classe base.
O Delphi possui uma classe chamada TObject da qual todas as demais classes se derivam, ou seja, todas as classes são derivadas de Tobject ou de classes derivadas de TObject. Quando você deriva uma classe de TObject , não é preciso declarar explicitamente a classe base pois o Delphi assume TObject como default.
Um objeto é uma instância de uma classe, isto é, depois de definirmos uma classe podemos declarar e utilizar objetos desta classe, da mesma forma que podemos declarar e usar uma variável composta (um registro, por exemplo) depois que o tivermos definido. De forma análoga, também; nos referimos aos elementos de um objeto utilizando a notação de ponto: nome-do-objeto.nome_do_elemento;
» COMPONENTES, CONTROLES E PROPRIEDADES
O Delphi já possui muitas classes predefinidas para utilização no ambiente Windows. Algumas das classes do Delphi, chamadas genericamente de componentes podem ser acessadas através da paleta de componentes.
Outra classe bastante utilizada é a classe Tform que define um formulário, mas que não está disponível na paleta de componentes. As propriedades são um tipo especial de campo em um objeto, cujo valor pode, em alguns casos, ser alterado usando-se o Object Inspector, como fizemos, por exemplo, com a propriedade Caption. Outras propriedades só podem ser alteradas por programa (run-time). O sistema de Help do Delphi fornece, para cada classe, uma listagem completa de suas propriedades e seus métodos.
» FUNÇÕES
Uma função se define em Pascal de forma semelhante a definição matemática. Ela recebe valores como parâmetros e retorna um outro valor como resultado. A definição de função obedece a seguinte sintaxe:
» function nome_da_funcao(parametro_I : tipoI ,,,,,parametro_n:tipo_n) : tipo de retorno
var
{declaração de variaveis locais à função}
begin
(corpo da funcão}
end;
O trecho de código a seguir define a função PRODXY, que retorna como resultado o produto de dois números reais X e Y:
» function PRODXY(x,y:Real):Real
begin
PRODXY := x * y
end;
Observe que o sinal de atribuição em Object Pascal é “:=” e, não o sinal de igual simplesmente.
Em Object Pascal podem-se usar os seguintes operadores aritméticos:
|
+ : Soma; |
|
– : Subtração; |
|
* : Multiplicação; |
|
/ : Divisão; |
|
div : Divisão inteira |
|
mod : Resto da divisão inteira. |
O Object Pascal tem várias funções predefinidas, parte das quais listamos a seguir:
|
Abs(x) Retoma o valor absoluto de x. |
|
ArcTan(x) Retorna o valor do arco tangente de x (em radianos). |
|
Cos(x) Retorna o cosseno de x (x em radianos). |
|
Dec(x) Decrementa (subtrai 1) uma variável inteira x. |
|
Exp(x) Retorna o valor de e elevado a x, onde e é a base dos logaritmos neperianos. |
|
Frac(x) Retorna a parte fracionária do real x. |
|
lnc(x) Incrementa (soma 1) uma variável inteira x. |
|
lnt(x) Retorna a parte inteira do real x. |
|
Ln(x) Retorna o logaritmo neperiano de x. |
|
ODD(x) Retorna True se x for impar. |
|
Sqr(x) Retorna o quadrado de x. |
|
Sqrt(x) Retorna a raiz quadrada de x. |
» PROCEDIMENTOS
Um procedimento é semelhante a uma função, mas não retoma um valor. A chamada a um procedimento não pode ser colocada do lado direito de um comando de atribuição.
A definição de um procedimento obedece a seguinte sintaxe:
» procedure nome_do_procedimento(parametro_1 :tipo_1 ,,,,parametro_n : tipo_n)
var
(declaração de variáveis locais ao procedimento}
begin
{corpo do procedimento}
end;
» PASSAGEM DE PARAMETROS
Podemos passar parâmetros para uma função ou um procedimento por valor e por referência. Quando se passa um parâmetro por valor estamos realmente passando um valor ou a cópia de um valor armazenado numa variável. Quando a passagem se faz por referencia, estamos passando o endereço da variável na memória e não o seu valor. Quando se altera, dentro da função, o valor de uma variável passada por por referência esta alteração surte efeito em todo o programa (fora da função).
Para passarmos um parâmetro por referência devemos precede-lo da palavra reservada var.
» METODOS E EVENTOS
Um método é um tipo especial de procedimento ou função, definido dentro de uma classe. Por ser definido dentro da classe, ele pode acessar diretamente os campos dela sem a necessidade de passar este campos como parâmetros. Para executar um método de uma determinada classe basta usar a mesma notação de ponto usada para acessar um campo.
Um evento é muito semelhante a um método pois ambos são definidos internamente a uma classe. A diferença é que os eventos são executados em resposta a alguma ação do usuário ou em resposta a uma mensagem enviada pelo Windows. Cite-se como exemplo o evento OnClick de um formulário, um procedimento que é executado toda vez que o usuário dá um clique com o mouse sobre o formulário. Isto permite que o nosso programa execute alguma ação quando o usuário clica com o mouse sobre o controle.
» ESTRUTURAS DE CONTROLE EM OBJECT PASCAL
Nos limitaremos a apresentar uma breve descrição da sintaxe dessas estruturas; os próximos exemplos utilizam-nas e serviço de exemplos de aplicação.
• ESTRUTURA CONDICIONAL { If-Then-Else }
Sintaxe:
if (condição) then
begin
{Bloco de comandos executados se a função for verdadeira}
end
else
begin
{Bloco de comandos executados se a função for falsa}
end;
Caso você não queira executar qualquer comando se a condição for falsa, suprima toda a cláusula else:
if (condição) then
begin
{Bloco de comandos executados se a função for verdadeira}
end;
» Note que o end que precede a clausula else não é seguido de “;”.
» Note que as cláusulas begin e end 56 são necessárias para blocos com mais de uma linha.
• ESTRUTURA CONDICIONAL { case-of }
Sintaxe:
case expressao of
constante_1_1,… constante_1_n : bloco_de_comando_1
constante_2_1 ,.. constante_2_n : bloco_de_comando_2
constante_n_1 ,… constante_n_n: bloco_de_comando_n:
else
bloco_de_comando;
end;
O comando “case” é um substituto mais elegante e mais legível para “if-then-else” múltiplos. A expressão (ou seletor) deverá ser de tipo com o tamanho máximo de 2 bytes (Byte, Char, ,Word ou Integer).
Segue-se um exemplo:
case Ch of
‘A’..’Z’, ‘a’..’z’: WriteLn(‘letra’);
‘0’..’9’: WriteLn(‘Digito’);
‘+’,’-‘,’*’,’/’: WriteLn(‘Operador’);
else
WriteLn(‘Caracter Especial’);
end;
• ESTRUTURA DE REPETIÇÃO {for – to} {for-downto}
Sintaxe:
for contador:= valor_inicial to valor_final do
begin
(bIoco~de_cornandos}
end;
onde;
contador é uma variável inteira;
valor_inicial é o valor inicial do contador, que dever ser um número inteiro;
valor_final é o valor final (para o qual o laço se encerra) a ser assumido pelo contador, deve ser inteiro;
Se desejar que o contador assuma valores decrescentes deve-se usar a seguinte sintaxe:
for contador:=valor_inicial downto valor_final do
begin
{bloco~de_cornandos}
end;
Note que as cláusulas begin e end só são necessárias para blocos com mais de uma linha.
• ESTRUTURA DE REPETIÇÃO {while-do}
Sintaxe:
while expressao_booleana do
begin
bloco_de_cornando
end;
» Note que o bloco_de_comando é executado enquanto a expressao_booleana for verdadeira.
» Note que como a expressão_booleana é avaliada antes da execução do bloco_de_comando, se a expressao_booleana for falsa o bloco_de_comando não será executado nenhuma vez.
» Note que as cláusulas begin e end só são necessárias para blocos com mais de uma linha.
• ESTRUTURA DE REPETIÇÃO {repeat-until}
Sintaxe:
repeat
bloco_de_comando until expressao_booleana;
» Note que o bloco de comando é executado em seqüência, enquanto a expressao_booleana for verdadeira.
» Note que o bloco de comando é executado pelo menos uma vez, já que a expressao_booleana é avaliada depois dele.
» Note que bloco_de_comando pode exigir as cláusula begin e end se contiver mais de uma linha.
• ESTRUTURA {with}
Sintaxe:
with identificador_de_registro(objeto) do
bloco_de_cornando
» Note que with é uma forma abreviada de referenciar os campos de um registro ou os campos e métodos de um objeto. Dentro do bloco_de_comando (com with) uma variável ou método fica completamente identificada usando-se apenas seu identificador de campo.
» Note que bloco_de_comando pode exigir as cláusula begin e end se contiver mais de uma linha.
• ESTRUTURA { try-except-end }
Sintaxe:
try
sequencia_de_cornandos
except
bloco_a_ser_executado_no_caso_de_erros
end;
Esta estrutura nos permite tratar de forma conveniente os erros ocorridos no programa. Sem ela, ocorrendo um erro, o Delphi dispara o seu mecanisrno de tratamento de exceções, normalmente emitindo uma mensagem de erro em inglês e não nos dando chance de recuperação. Com esta estrutura podemos detectar o erro, fornecer uma mensagem inteligível e permitir o retorno à rotina onde ocorreu o erro e permitir, por exemplo, a possibilidade de digitação.
» OPERAÇÕES COM REGISTROS E CAMPOS (Componentes TFieId)
O Delphi encapsula cada campo de uma tabela com um componente TField próprio (do tipo desejado), forarn usados TStringFields, TSmallntFieId, TCurrencyField. Devemos usar o Fields Editor (Editor de Campos) para manipular os componentes Tfields, durante o projeto. Este editor nos permite determinar quais campos queremos mostrar no formulário.
Para abrirmos o Editor de Campos, basta dar um duplo clique sobre o componente TTable. Aparece o Fields Editor. Clique no botão direito do mouse e selecione Add Fields… para aparecerem os nomes dos campos disponíveis; Selecione o campo que você quer que apareça no formulário, dando um clique sobre ele e clique OK; proceda da mesma forma para os outros campos desejados (Add, seleção, OK…): caso desejado mude a ordem de disposição dos campos bastando, para isso clicar e arrastar o campo para a posição desejada. (isto depois que todos os campos desejados estiverem selecionados). No nosso caso selecione todos os campos. Observando o Object Inspector você notará que o Delphi incluiu vários objetos da classe Tfield. Feche o Fields Editor pelo menu de sistema.
O aluno deve fazer urna análise de várias propriedades em especial as possibilidades de formatação. Estando sobre una determinada propriedade, deve-se teclar F1 para obter o Help correspondente.
As seguintes propriedades se destinam a formatação de campos:
|
DisplayFormat : para especificar o formato de visualização do dado; |
|
EditMask: fornece uma máscara de edição. |
|
Display width e Alignment especificam número de caracteres e alinhamento. |
Pode-se usar o evento OnGetText para formatar valores de campo durante a programação. Esse evento ocorre sempre que o Delphi vai mostrar o conteúdo do campo.
Para validar (por programa) a entrada de dados utilize o evento OnValidate que é acionado sempre que o valor de um campo é modificado.
» PROCURANDO DADOS:
Devemos usar o método FindKey para procurar por um determinado valor de um campo numa tabela. O campo precisa estar indexado para usarmos este método. Por exernplo:
• Tablen.Findkey([Maria]) para um campo Nome que indexe a tabela Tablen. Para índices compostos de mais de um campo use:
• Tablen.FindKey([valorl’, ‘valor2′, ‘valor3’])
Além do FindKey, as versões 2, 3 e 4 do Delphi possibilitam o uso de Locate e Lookup….????????????
» OUTRAS FORMAS DE ACESSAR CAMPOS
Você pode usar o método FieldByName para acessar o valor de um campo. Você passa o nome do campo como parâmetro.
Por exemplo:
• Editn.Text := Tablen.FieldByName(‘Norne’) atribui a caixa de edição Editn o valor do campo ‘Nome da tabela Tablen. (Nota: Nome não precisa ser campo índice).
Se o campo não for do tipo string, utilize a função de conversão AsString;
• EditnText := Tablen . FieldByName(‘codigo’).AsString;
Você também pode usar a propriedade Fields que utiliza como parâmetro o número de ordem do campo na tabela.
Por exemplo, para atribuir a caixa de edição Editn o valor do campo Nome, que é o terceiro campo na tabela Tablen você faz
• Editn.Text := Tablen.Fields[2]; { 0 primeiro campo tem o índice 0} ou Editn.Text := Tablen.Fields[n].AsString; para um campo que não seja do tipo string.
Nota: Neste método corre-se o risco de bugs se a estrutura da tabela for modificada já que neste caso a ordem e a posição dos campos pode mudar.
» FILTRAGEM DE REGISTROS:
Os métodos abaixo (aplicáveis apenas a campos indexados para tabelas do tipo Dbase e Paradox) permitem filtrar registros de uma tabela
|
SetRangeStart : estabelece o limite inicial do filtro; |
|
SetRangeEnd : estabelece o limite final do filtro; |
|
ApplyRange : aplica o filtro a tabela; |
|
CancelRange : cancela o filtro aplicado a tabela Como alternativa pode-se usar; |
|
SetRange([Valorlnicial],[Valorfinal]): estabelece os valores inicial e final do filtro e aplica a tabela. |
Exemplo:
Tablen.SetRangeStart;
Tablen.FieldByNarne(‘Codigo’) := 20;
TablenSetRangeEnd;
Tablen.FieldByNarne(‘Codigo’) := 60;
Tablen.ApplyRange;
O exemplo permite filtrar todos os registros com código > 20 e menor que 60;
Você pode usar os métodos EditRangeStart e EditRangeEnd para mudar valores atribuídos anteriormente.
Você pode usar índices múltiplos para filtrar seus registros. O exemplo a seguir vai filtrar todos os registros com código > 20 e nome igual a Maria.
Tablen SetRangeStart;
Tablen.FieldByNarne(‘Codigo’) := 20;
Tablen Field ByName(‘Norne) := ‘Maria’;
Tablen.SetRangeEnd;
Tablen ApplyRange;
» A PROPRIEDADE KEYEXCLUSIVE DE TTABLE
A propriedade KeyExclusive é falsa por default, isto é, o filtro irá procurar valores maiores ou iguais ao do limite inicial e menores ou iguais ao do limite final.
Se você quiser (no exemplo com os limites 20 e 60 para o código) que o valor 20 não faça parte do filtro, (ou seja Código > 20), faça, por exemplo
TablenSetRangeStart;
Tablen.FieldByNarne(‘Codigo’) := 20;
Tablen.KeyExclusive := True;
Tablen.SetRangeEnd;
Tablen ..FieldByNarne(‘Codigo’) := 60;
Tablen ApplyRange;
» HABILITANDO E DESABILITANDO A VISUALIZAÇÃO DE DADOS
Antes de iniciar um filtro pode ser importante você desabilitar os componentes de visualização inseridos no formulário, já que o filtro afeta todo o conjunto de dados (dataset). Esta providência é importante para se ganhar tempo, evitando que os componentes de Visualização fique mostrando dados provisórios e fique com flickering. Use estes controles com cuidado pois o usuário espera que os controles de visualização mostrem a realidade continuamente, assim, tendo desabilitado os controles, trate de habilita-los logo que possível.
Faça:
Tablen.DisableControls – antes de aplicar o filtro e Tablen.EnableControls após a aplicação do filtro.
Deve-se usar um bloco try … finally e comandar Enable dentro da clausula finally, senão, se ocorrer uma exceção os componentes de visualização não serão retornados.
» NAVEGANDO PELO DATASET:
|
First : move o ponteiro para o primeiro registro |
|
Last : move o ponteiro para o último registro |
|
Next : move o ponteiro para o próximo registro |
|
Prior : move o ponteiro para o registro anterior |
|
MoveBy: move para a frente (se parâmetro positivo) ou para trás (se parâmetro negativo) um número especificado de registros, por exemplo : MoveBy(2), avança dois registros. |
|
Next : eqüivale a MoveBy(l) e Prior eqüivale a MoveBy(-l) |
» PROPRIEDADES BOF e EOF
• BOF = True indica que o ponteiro está no primeiro registro da tabela e ocorre nos seguintes casos:
|
Quando você abre a tabela; |
|
Quando você executa o método First; |
|
Quando você executa o método Prior e ocorre uma falha |
• EOF = True indica que o ponteiro está no último registro da tabela e ocorre nos seguintes casos:
|
Quando você abre um dataset vazio. |
|
Quando você chama o método Last; |
|
Quando você chama o método Last e ocorre falha no índice. |
Exemplo:
while not Tablen.EOF do
begin
{ Faça algum processamento no registro} Tablen.Next;
end;
» MODIFICANDO REGISTROS:
Utilize Edit para possibilitar a modificação de dados no registro, em seguida utilize Post para gravar os novos dados no registro:
Tablen.Edit;
{Comando de edição}
Tablen.Post;
Utilize Insert para inserir um registro após o registro corrente; Utilize Append para inserir um registro no final do arquivo;
Obs: Ao comandar Post, se houver um índice, o registro será inserido na posição dada pelo índice. Utilize Delete para deletar um registro;
Utilize Cancel para cancelar alterações feitas (antes de comandar Post);
Utilize Refresh para apagar os bufers locais e buscar os dados originais na tabela (arquivo). Este cornando pode aparentar resultados inesperados por exemplo : se um usuário está vendo um registro e um segundo usuário (em compartilhamento) deleta o registro, parecerá que o registro desapareceu quando o aplicativo usar Refresh.
Utilize a propriedade CanModify (de TTable) para permitir ou proibir modificações no dataset. Se = True Os dados podem ser alterados.
» MARCANDO UM REGISTRO
Para marcar um registro e permitir que, após várias operações se volte a ele, utilize:
|
GetBookMark : marca o registro associando a ele uma propriedade do tipo Tbookrnark; |
|
GoToBookMark: leva o ponteiro até o registro marcado; |
|
FreeBookMark : desmarca o registro. |
Fonte: http://gpazini.sites.uol.com.br/ConcDelphi.htm
