Este artigo apresenta em detalhes os nomes e o uso de várias palavras-chave comumente usadas no Delphi para sua referência no processo de programação. Os detalhes são os seguintes:
absoluto:
//Permite criar uma nova variável, e o endereço inicial da variável é o mesmo de outra variável.var Str: string[32]; e Str Same.//Como a 0ª posição da string armazena o comprimento da string, o valor de StrLen é o comprimento da string.beginStr := 'abc';Edit1.Text := IntToStr(StrLen);end;
resumo:
//Permite criar métodos abstratos, incluindo classes com métodos abstratos chamados classes abstratas. //A palavra-chave abstrata deve ser usada junto com as palavras-chave Virtual ou Dinâmica, porque os métodos abstratos devem ser substituídos. //Classes abstratas não podem instanciar, métodos abstratos não podem. contém corpos de método. tipo TDemo = procedimento protegido privado X; construtor público Criar destruidor;
e:
//1. Expressar AND lógico se (a>0) e (b>0) então //2. Expressar operação de bit vara,b,c: Integer;beginc := (a e b);end;//Use And Ao expressar lógica, as expressões em torno de And devem ser colocadas entre parênteses para evitar conflitos de condições.//Por exemplo: if a>0 e b>0 then//O compilador pode entendê-lo como: if a>( 0 and b) >0 então//ou:se (a>0) e (b>0) então//Mas quando realmente compilar, o compilador irá gerar um conflito e reportar um erro.//E o primeiro pode incluir a forma de a>b>c, que está em Delphi Não suportado.//Portanto, você deve usar parênteses ao usar o operador And para distinguir as condições esquerda e direita.//Ao expressar operações de bits, você também deve adicionar parênteses para delimitar And e os parâmetros esquerdo e direito.
variedade:
//Array é usado para representar arrays, e qualquer objeto pode ser declarado como um array. Os arrays são divididos em dois tipos: array estático e dinâmico. , porque o número de elementos não é conhecido no momento da declaração, então o tamanho do array deve ser definido posteriormente usando o método SetLength varArr2: array of Integer;//Quando o array é usado como parâmetro, o tamanho do array não pode ser passado. Você só pode passar o nome do array e, em seguida, usar o método Length para obter o número de elementos na função do array X(A: array de Integer): Integer;vari: Integer;beginResult := 0;for i := 0 para Comprimento(A)-1 doResult := Resultado + A[i];end;
como:
//As é usado para converter um objeto em outro procedimento de objeto BtnClick(Sender:TObject);begin (Sender as TButton).Caption := 'Clicked';end;//Para a conversão da interface de preenchimento do objeto, As deve ser usado (HTTPRIO como IExp).GetConnection;//Como não pode ser usado para conversão de tipo de dados, o seguinte código está errado: vari: Integer;s: string;begins := (i as string);end;//A maneira correta de escrever é: s := string(i);
asm:
//A palavra-chave Asm é usada para inserir código assembly. Ao usar código assembly, você deve usar a estrutura asm...end; em vez de begin...end;function IntToHex(Value: Integer; Digits: Integer): string; asm CMP EDX, 32 JBE @A1 xor EDX, EDX @A1: PUSH ESI MOV ESI, ESP SUB ESP, 32 PUSH ECX MOV ECX, 16 CALL CvtInt MOV EDX, ESI POP EAX CALL System.@LStrFromPCharLen ADD ESP, 32 POP ESIend;
montador:
//A palavra-chave Assembler é usada para suportar montagem inicial, como 80386, etc. //A diferença entre ela e Asm: Asm permite montagem Win32, enquanto Assembler permite apenas montagem 80x86 e não permite a instrução Invoke da função IntToHex. (AValor: Int64): string;
automatizado:
//O especificador de acesso automatizado é usado para descrever um membro digitado automaticamente, o que pode tornar a versão do programa compatível com versões anteriores. //Os membros e suas instâncias na unidade ComObj não podem usar o especificador de acesso automatizado.type TDemo = class automatizado Str:WideString ; //Na próxima versão do programa, Str é modificado e se torna typeTDemo = classautomatedStr: AnsiString;end//A nova versão da variável Str pode aceitar a versão antiga dos dados do tipo WideString, E automaticamente convertido em AnsiString.//No desenvolvimento real, se não houver necessidade especial, o separador de acesso automatizado geralmente não é usado.
começar:
//A palavra-chave start é usada para indicar o início de um programa ou estrutura e deve ser finalizada com o procedimento de palavra-chave end Você também precisa usar a palavra-chave start para marcar o ponto inicial da estrutura para i:=1. 100 dobeginsum := soma + i; se soma > 1000 então Break;fim;
caso:
//A instrução Case é usada para completar a seleção condicional. O objeto selecionado da instrução Case deve ser um tipo ordenado, incluindo tipo inteiro, tipo de enumeração, tipo de caractere, etc. //A instrução Case deve ser finalizada por fim, se não houver correspondência. item de seleção, caso contrário, pode ser adicionado para fazer uma escolha geral function GetDays(AYear,AMonth: Integer): Integer;begin case AMonth of 1,3,5,7,8,10,12: Result := 31; 4,6,9,11: Resultado:= 30; início if IsLeapYear(AYear) then Resultado:=29 else Resultado:=28;
cdecl:
//Cdecl é um tipo de acordo de chamada de função, que estipula as regras que devem ser seguidas ao chamar funções de uma DLL escrita em C ou C++. //Pode converter tipos de dados em C ou C++ para Delphi.//Por exemplo Código. em C++: int X(int i){ return i*2;}//Esta função é compilada em Demo.dll Ao chamar com Delphi, você deve usar: function. 'Demo.dll';aula:
//A palavra-chave Class é usada para declarar ou herdar uma classe, ou a classe e a interface podem ser herdadas ao mesmo tempo. //Além disso, a palavra-chave Class também pode ser usada para declarar métodos comuns de uma classe, para que o. a classe pai pode acessar os métodos da subclasse de dentro da classe.type ClassDemo = class(TObject) private public constructor Create; classes, por exemplo: typeClassA = classprivatepublicprocedure Y;end;typeClassB = class(ClassA)privatepublicclass método de procedimento a ser chamado.
const:
//A palavra-chave Const é usada para declarar constantes. Os dados declarados com const não podem ser alterados no programa. //Também pode ser usado para declarar parâmetros de função. = 'Delphi ';const MyInteger = 100;//Ao declarar uma constante com Const, você não precisa indicar seu tipo de dado O sistema determinará automaticamente o tipo e fará ajustes automáticos.//Você pode usar const para declarar inalterável. parâmetros em uma função function X(const i: Integer): string;//Neste momento, o valor de i não pode ser alterado durante a operação da função.
construtor:
//A palavra-chave construtor é usada para declarar o construtor de uma classe Quando a classe é instanciada, esta função é chamada primeiro. //O construtor é geralmente representado por Create. o class.type ClassDemo = class(TObject) private fValue: Integer; public constructor Create;construtor ClassDemo.Create;beginfValue := 0;end;
contém:
//A palavra-chave Contém indica se um pacote (Pacote) contém um determinado arquivo. //Os arquivos introduzidos com Contém devem ser adicionados ao arquivo do pacote, o que pode evitar a perda de referências aos arquivos principais. contém Db, DBLocal, DBXpress;end.
padrão:
//A palavra-chave padrão é usada para indicar o valor padrão de uma propriedade //Somente as propriedades do tipo ordenado permitem a existência de valores padrão, caso contrário o valor da propriedade deve ser inicializado no construtor type ClassDemo = class private fValue: Integer property Value; : Integer read fValue write fValue default 0;//Também pode apontar a propriedade padrão de uma propriedade de classe strings[Index: Integer]: string read GetString write PutString;
destruidor:
//O destruidor é usado para identificar o destruidor, que é chamado automaticamente quando a classe é lançada. //O destruidor só pode ser substituído e nenhuma sobrecarga é permitida. O destruidor geralmente usa Destroy como o nome da função. class( TComponent) public destructor Destroy;override; end;//Como também existe um método Destroy na classe TComponent, ele precisa ser reescrito//Mas se você quiser sobrecarregar o destruidor, não é permitido. está errado: destruidor Destruir;
dispar:
//A palavra-chave DispId é usada na interface DispInterface para especificar um número de série de adaptação específico. //Na interface DispInterface, o número de série da adaptação deve ser exclusivo. //Se DispId não for especificado, o sistema atribuirá automaticamente a adaptação. o número de série é fornecido para cada método na interface. //Você pode acessar os métodos na interface DispInterface através do número de série da adaptação tipo IStringsDisp = dispinterface. ['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}'] propriedade ControlDefault[Índice: Inteiro]: Olevariant dispid 0; função padrão Contagem: Inteiro dispid 1; Remover(Índice: Inteiro dispid 3; procedimento Clear; 4; função Adicionar (Item: Olevariant): Inteiro dispid 5;desinterface:
//DispInterface é usado para declarar uma interface de adaptador específica. Este adaptador pode aceitar dados de entrada e saída na interface padrão do sistema. //A interface declarada com DispInterface não pode ser herdada e só pode ser referenciada. Chamado e deve ser vinculado dinamicamente. //Você pode usar DispId para atribuir um número de série de adaptação à interface. //DispInterface só pode ser usado na plataforma Windows. Então esta palavra-chave será bloqueada automaticamente pelo sistema //Normalmente, DispInterface não é usado //Para exemplos, consulte DispId.
divisão:
//Div é usado para encontrar o quociente inteiro de dois números. Os dois valores usados na operação Div devem ser inteiros e os resultados da operação também são inteiros. := 20; b := 3; c := a div b;
fazer:
//A palavra-chave Do é usada em instruções For, While, On, With para formar uma estrutura específica //Instrução For: for i := 1 to 100 do sum:=sum+i;//Instrução While: while i < 100 dobegin sum := sum + i; end;//Instrução On (tratamento de exceção):try i := StrToInt(s);exceto na exceção do ShowMessage('Error!');end;//With declaração: com Memo1.Linhas dobegin Limpar;até:
//A palavra-chave DownTo é usada na instrução For para indicar que a variável de loop é decrementada for i := 100 downto 1 doListBox1.Items.Add(IntToStr(i));//Na instrução For, a palavra-chave To é usada. para incrementar a variável de loop, use a palavra-chave DownTo para diminuir.
dinâmico:
//Dynamic é usado para declarar um método dinâmico. //Métodos dinâmicos podem ser substituídos e podem reduzir o tamanho do código tanto quanto possível (diferente de Virtual).procedure X(i: Integer dynamic);
outro:
//else é usado para orientar a direção de execução do programa. Ele pode ser usado em conjunto com as instruções If, Case e On. Quando a condição não for atendida, vá para o else para executar a instrução //If (na instrução If. , nenhum ponto é permitido antes de else No.):if a > b thenc := aelsec:=b;//Instrução Case: case Tag. Of1:Result:=1;2:Result:=2;3:Result:=3;elseResult:=0;end;//Instrução On (tratamento de exceção):tryi := StrToInt(s);Excpeton EZeroDivide do Result: = 1;on EOverflow do Resultado := 2;elseResult := 0;end;
fim:
//End é usado para finalizar um bloco de instruções ou uma unidade. //Pode corresponder a Begin, Case, Class, Interface, Asm, Unit, Package, etc. //Para blocos de instruções (fim local), End deve ser adicionado depois. Ponto-e-vírgula.//Para unidades ou pacotes (fim global), um ponto final deve ser adicionado após o fim.//Nenhum símbolo é permitido após o fim antes da palavra-chave else na instrução If start with Button1 do start if Button1. então Button1.Caption := 'Sugerido' else Button1.Caption := 'Não sugerido'; end;end;//Use End no pacote para finalizar: package DATAX;requiresrtl,clx;contém Db, DBLocal, DBXpress;end.
exceto:
//A palavra-chave except é usada para tratamento de exceções e deve ser usada dentro da instrução try. Se ocorrer uma exceção, a instrução após except é executada try i := StrToInt(s);except ShowMessage('Error!');end;exportar:
//Exportar indica o protocolo de chamada da função, indicando que a função pode ser exportada, e a função exportada pode ser chamada localmente ou remotamente. //Outros programas podem chamar funções no programa na forma de dll. Add( a,b: Integer): Integer; export;//Se este programa for compilado como Demo.exe e outro programa precisar chamar esta função, você pode usar a seguinte instrução function Add(a,b: Integer): Inteiro; stdcall; 'Demo.exe';
exportações:
//exports é usado para gerar objetos. Deve ser usado entre a interface e a implementação. Vários itens podem ser gerados ao mesmo tempo, separados por vírgulas. :=IntToStr(i);end;exporta X(i: Inteiro): sobrecarga de string; stdcall;begin Resultado := StrToInt(s);end;exportaX; (i: Inteiro) nome 'x1',X(s: string) nome 'x2';beginend.
externo:
//A palavra-chave External é usada para referenciar um método ou externo dentro do OBJ.{$L Demo.OBJ}procedure X(i:Integer);external;//Se for referenciado por uma dll ou programa externo, pode ser usado O seguinte código: function A(FileName: string): string; external 'Demo.dll';//Se a função referenciada estiver sobrecarregada, o nome referenciado deverá ser especificado adicionalmente function A(Name: string): string sobrecarga ; stdcall; nome 'Demo.dll' externo 'A1'; //Ao usar a palavra-chave externa, você deve prestar atenção; para o caso, caso contrário ocorrerá um erro.distante:
//Far indica o protocolo de chamada da função, indicando que a função pode ser chamada remotamente. //Outros programas podem chamar funções no programa na forma de dll É compatível com versões anteriores. Far ;//Se este programa for compilado em Demo.exe e outro programa em outro computador precisar chamar esta função, você poderá usar a seguinte instrução: function Add(a,b: Integer): Integer external stdcall; 'Demo.exe';
arquivo:
//A palavra-chave File indica o tipo de operação do arquivo. O arquivo deve ser declarado como File. //Se Of e o tipo de arquivo forem anexados após File, o arquivo pode ser definido para ler e gravar o tipo especificado de dados.type TPerson = record. PName: string[ 32]; PAge: Integer; var PFile: arquivo de TPerson;
finalização:
//A palavra-chave finalization identifica o método a ser chamado quando a unidade é liberada. //Geralmente ela libera objetos na unidade que não podem ser liberados automaticamente. //O caso de finalização mais comumente usado é de. -inicializar objetos OLE. inicialização ActiveX.OleInitialize(nil);finalização ActiveX.OleUninitialize;
finalmente:
//A palavra-chave finalmente indica o último método que deve ser chamado no tratamento de exceção. //Independentemente de ocorrer uma exceção, a instrução após finalmente é sempre executada no final da instrução try Node := Node.GetNext; .Text := Node.Text;finalmente Node := nil;end;
para:
//A palavra-chave For leva à estrutura do loop For, que é usada para executar um número especificado de loops for i := 1 a 100 dosum := sum + i;//Se a variável do loop estiver decrementando, você pode usar o método. Palavra-chave DownTo para i: = 100 downto 1 do Inc(sum);
avançar:
//A palavra-chave Forward é usada para definição direta de métodos. Apenas defina a declaração do método e, em seguida, implemente o método posteriormente no programa. //Isso é benéfico para a legibilidade do código e todas as declarações podem ser reunidas. junte todas as implementações function X(i: Integer): Integer;procedure Y(s: string);...function X;begin Resultado := i * 2;end;procedure Y;beginWriteLn(s);end;//Forward métodos pré-declarados não precisam inserir os parâmetros e retornar valores do método ao implementá-lo, basta usar o nome do método diretamente.
função:
//Função é usada para declarar funções function Para o nome da função, você só precisa indicar os parâmetros e o tipo de retorno. O nome específico da função pode ser vinculado posteriormente.
Vá para:
//A instrução Goto é usada para pular para um número de linha, que pode pular para qualquer posição dentro da camada de estrutura atual //O número da linha deve ser declarado com a palavra-chave label na declaração //Uma vez que a instrução Goto irá destruir. a estrutura do programa, não é recomendado .var a,b: Integer;label X,Y;begin if a > b then goto X else goto Y;X: WriteLn('a > b');Y: WriteLn ('b > a'); fim;se:
//A palavra-chave If leva à instrução condicional If, que é usada para julgar a condição.var a,b: Integer;begin a := 2;= 3; a )) else WriteLn('b=' + IntToStr(b));end;//A estrutura usual da instrução If é If...Then...else, a instrução else é opcional.//Se houver qualquer na instrução If Múltiplas subinstruções, Então você deve usar a estrutura Begin...End para distinguir se a > b thenbegin WriteLn('a>b'); b) );Endelse WriteLn('b>a');implementação:
//Implementação identifica a parte de implementação na unidade. A estrutura básica da unidade é ://Unit...Interface...implementation...end.//O corpo da função, corpo do processo, etc. a palavra-chave de implementação./ /Se o objeto for referenciado após a implementação, o objeto não é público e só pode ser usado pela própria unidade. Implementação usa frmAbout;begin FormAbout.Show;end;//Uma unidade completa deve ter uma implementação. papel.
implementa:
//Implementa indica que uma propriedade é herdada da interface. Neste momento, a propriedade é convertida em um objeto de interface. //Vinculação dinâmica de propriedades através da interface e configuração dinâmica de valores de propriedade. procedimento P2; fim TMyImplclass = propriedade TMyImplClass: TMyImplclass lida; FMyImplclass implementa IMyInterface; procedimento IMyInterface.P1 = MyP1; procedimento MyP1;//Após declaração através de implementos, pode-se apontar a entidade do método na interface quando a classe é declarada, como no exemplo acima: procedimento IMyInterface. P1 = MeuP1;
em:
//In é usado para determinar se um conjunto contém um elemento. O conteúdo a ser determinado deve ser um único elemento de conjunto e uma instância de um conjunto tipo TCol = (cA,cB,cC); Cols: TCols;begin Cols := [cA,cB]; if cA in Cols then ShowMessage('cA in Cols') else ShowMessage('cA not in Cols');end;//In também é usado em arquivos de projeto, Usado para identificar se um arquivo é referenciado pelo projeto. Usa Unit1 em 'Unit1.pas'; //In pode ser usado na instrução For para fazer o loop de elementos em uma coleção. .. para s Em sl comece ShowMessage(s);índice:
//O índice é usado para identificar o número de série no atributo para que o mesmo método de atributo (Get, Set) possa ser usado para operar diferentes atributos. type TForm1 = class(TForm) private function GetInfo(const Index: Integer): Longint. ; procedimento SetInfo (const Index: Integer; const Value: Longint); propriedade pública iLeft:Longint index 0 read GetInfo write SetInfo propriedade iTop:Longint index 1 read; GetInfo escreve SetInfo; propriedade iWidth:Longint index 2 read GetInfo write SetInfo; propriedade iHeight:Longint index 3 read GetInfo write SetInfo end;função TForm1.GetInfo(const Index: Integer): Longint;begin case Índice de 0: resultado:= self.Left; 1: Resultado := self.Top 2: resultado := self.Width; := self.Height; end;end;//A palavra-chave Index também é usada para indicar vários elementos em propriedades, por exemplo: property Selected[Index: Integer]: Boolean read GetSelected write SetSelected;
herdado:
//Herdado é usado para chamar o método da classe pai.type TDemo = class(TComponent) public constructor Create(AOwner: TComponent override);constructor TDemo.Create(AOwner: TComponent);begin herdado Create(AOwner);end; ; //Se você estiver chamando um método com o mesmo nome, você também pode omitir o nome do método e os parâmetros. Por exemplo, herdado no exemplo acima. Create(AOwner);//pode ser alterado para:Inherited;
inicialização:
//A palavra-chave de inicialização identifica o método a ser chamado quando a unidade é carregada //Normalmente é usada para inicializar alguns objetos que não podem ser inicializados automaticamente, mas não precisa ser usada. inicialização é inicializar objetos OLE inicialização ActiveX.
em linha:
//A palavra-chave InLine é usada na estrutura Asm ou assembler, //É usada para indicar que a instrução assembly é compatível com versões anteriores. Não tem impacto na compilação do programa IntToStr(Value: Integer): string; asm InLine; System.@LStrFromPCharLen ADICIONAR ESP, 16 POP ESIend;
interface:
//Interface identifica a parte da interface na unidade é://Unit...Interface...implementation...end.//Declarações de funções, procedimentos, etc. Palavra-chave Interface./ /Se o objeto for referenciado após a Interface, o objeto não possui instância e deve ser instanciado quando usado. Interface usa frmAbout;var FAbout: TFormAbout;begin FAbout := TFormAbout.Create(Self); FAbout.Show;end;//Uma unidade completa deve ter uma parte de Interface.//Interface também pode ser usada como uma declaração de uma interface.type IMalloc = interface(IInterface) ['{00000002-0000-0000-C000-000000000046 }'] função Alloc(Tamanho: Inteiro): Ponteiro; stdcall; função Realloc(P: Ponteiro; Tamanho: Inteiro): Ponteiro; stdcall; função DidAlloc (P: Ponteiro); stdcall;é:
//A palavra-chave Is é usada para julgamento de objetos. Em alguns casos, também pode ser usada como "As".var Comp: TComponent;begin ... if Comp Is TEdit then (Comp as TEdit).Text := 'Edit ' ;fim;
rótulo:
//a palavra-chave label é usada para declarar o rótulo do número da linha para que Goto possa ser usado para direção. Não é recomendado usar.var a,b: Integer;label X,Y;begin if a > b then goto X else goto. Y;X: WriteLn( 'a>b');Y: WriteLn('b>a');fim;biblioteca:
//A palavra-chave Biblioteca é usada para indicar que um projeto é uma biblioteca de classes. A biblioteca de classes gera um arquivo DLL após a compilação, que pode ser chamado por outros editores de biblioteca. nome concluído, nome InsertText Insert , nome DeleteSelection Delete, FormatSelection, nome PrintSelection Print, SetErrorHandler;begin InitLibrary;end.
mensagem:
//A palavra-chave Message é usada para declarar métodos de mensagem. //O método com Message deve indicar o tipo de mensagem recebida e passar a mensagem para o método por referência para processamento.procedure Refresh(var Msg: TMessageRecordtype); Refresh(var Msg: TMessageRecordtype);beginif Chr(Msg.Code) = #13 then...elseinherited;end;//Os usuários podem personalizar mensagens, Mensagens personalizadas também podem ser recebidas por eventos de mensagem e gatilho.
moda:
//Mod é usado para encontrar o módulo inteiro de dois números, ou seja, o resto Os dois valores usados na operação Mod devem ser inteiros e os resultados das operações também devem ser inteiros. , b, c: Inteiro a := 20;
nome:
//A palavra-chave Name é usada para indicar o alias de um método. //Para que um método seja referenciado externamente, é recomendado usar Name para solicitar um alias de método para evitar que programas externos alterem o conteúdo da entidade do método. //Ao referenciar um método externamente, se o método tiver um alias, ele deve ser identificado por Name. function MessageBox(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer external 'user32; .dll' nome 'MessageBoxA';
aproximar:
//Near marca o protocolo de chamada da função, indicando que a função pode ser chamada localmente. //Outros programas podem chamar funções no programa na forma de dll É compatível com versões anteriores. ; near;//Se este programa for compilado em Demo.exe e outro programa local precisar chamar esta função, você poderá usar a seguinte instrução: function Add(a,b: Integer): Integer external stdcall; 'Demo.exe';
nada:
//Nil é usado para representar um ponteiro nulo ou um objeto sem uma instância enquanto Node <> nil dobegin ListBox1.Items.Add(Node.Text := Node.GetNext;end;
padrão do nó:
//A palavra-chave NoDefault indica que uma propriedade não permite um valor padrão, que geralmente é usado em herança tipo TClassA = class private fValue: Integer; public property Value: Integer read fValue write fValue default 0; TClassA ) propriedade publicada Value:Integer read fValue write fValue nodefault;//Como pode ser visto no exemplo acima, Value em TClassA tem um valor padrão de 0, //TClassB herda TClassA, portanto também herda seu valor padrão Use NoDefault para remover o valor padrão aqui.
não:
//Not é usado para negar, ele nega o resultado original. Por exemplo: se a > b então // Pode ser escrito como: if not (a < b) then // A palavra-chave Not é geralmente usada para mudar o booleano. procedimento de atributo Button1Click (Sender: TObject);begin StatusBar1.Visible := não StatusBar1.Visible;end;
objeto:
//Objeto é usado para declarar um objeto. Este objeto pode ser arbitrário e é compatível com versões anteriores. O objeto só pode ser herdado por Object. object end; ODemoB = object(ODemoA) end;//A palavra-chave Object também é usada para declarar funções ou procedimentos dinâmicos, por exemplo: type TMyFun = function(i: Integer): Integer of Object; ) de object;//A função ou procedimento declarado por object pode ser vinculado dinamicamente ao corpo da função especificado ou vinculado ao evento de controle.
de:
//A chave Of é usada para formar uma estrutura especificada com outras palavras-chave. Of pode ser usada com Case, Class, Array, File, Set, Object. //Instrução Case: case Tag Of 0: Result := 'a'; : Resultado := 'b';end;//Instrução de classe: tipo TDemo = classe de TComponent;//Estrutura do array: var MyInt: array de Integer;//Estrutura do arquivo: var MeuArquivo: arquivo de Byte;//Instrução Set: type TCol = (cA,cB,cC); TCols = conjunto de TCol;//Estrutura do objeto: type MyFun = function(I: Integer): Integer of Object;
sobre:
//A palavra-chave On é usada para tratamento de exceções, apontando a exceção que ocorreu e obtendo informações sobre a exceção try i := StrToInt(s);except on E: exceção do ShowMessage(E.Message);end;
ou:
//1. Expresso lógico ou if (a>0) ou (b>0) então //2. Expresso de operação de bit vara,b,c: Integer;beginc := (a ou b);end;//Use Or Ao expressar lógica, as expressões ao redor de Or devem ser colocadas entre parênteses para evitar conflitos com condições //Se você usar Or em uma instrução condicional, o editor não sabe o que o usuário está fazendo com Or. Por exemplo: se a>0 ou. b>0 then//O compilador pode entender isso como: if a>(0 or b)>0 then//ou if (a>0) ou (b>0) then//Mas quando realmente compilar, o compilador irá gerar um conflito , reporte um erro //E o primeiro pode conter o formato a>b>c, que não é suportado no Delphi //Então você deve usar parênteses ao usar o operador Or para distinguir as condições esquerda e direita.//Indica bit operações Parênteses também devem ser adicionados quando Coloque Or e os parâmetros esquerdo e direito.
fora:
//A palavra-chave Out descreve o método de saída dos parâmetros do método. //Use Out para retornar vários resultados em uma função. //Out retorna um valor. retorna parâmetros e var é o endereço de um parâmetro inserido diretamente no procedimento. TForm1.Button1Click(Sender: TObject);var i: Integer s: string;begin i := 20;
sobrecarga:
//A palavra-chave Overload indica o método para sobrecarga. Sobrecarga significa que o nome do método é o mesmo, //mas o número, tipo ou ordem dos parâmetros são diferentes. Se esta condição for atendida, constitui uma função de sobrecarga X(i. : Inteiro): string; sobrecarga;função Os requisitos para sobrecarga devem ser atendidos.type TDemo = class(TComponent) public procedure CreateWnd(AOwner: TWinControl); sobrecarga end;//Como no exemplo acima, o método pertencente à subclasse é: procedure CreateWnd {Herdado da classe pai}procedure CreateWnd(AOwner: TWinControl); {Declaração de subclasse }//Existem dois métodos CreateWnd.//Se a sobrecarga não for usada, o método da classe pai pode ser substituído na subclasse.substituir:
//A substituição é usada para substituir um método na forma de Virtual ou Dinâmico. //Ao substituir, a declaração do método substituído deve ser usada e os parâmetros e o tipo de retorno do método original não podem ser modificados. Create(AOwner: TComponent);/ /Override é usado principalmente para herança, usando subclasses para substituir métodos da classe pai. //Como no exemplo acima, Os métodos pertencentes à subclasse são: procedimento X {substituído da classe pai}//Os métodos pertencentes à classe pai são: instrução de procedimento, //ou se houver necessidade de modificar parâmetros, ele deve ser substituído pelo Reintroduza a palavra-chave.pacote:
//A palavra-chave Package é usada para indicar que um projeto é uma biblioteca de controle. //A biblioteca de controle gera um arquivo BPL após a compilação, que pode ser instalado na biblioteca de controle Delphi para que o controle possa ser usado em desenvolvimento futuro do pacote DATAX. ; requer rtl, clx ; contém MyUnit em 'C:/MyProject/MyUnit.pas';end.
embalado:
//A palavra-chave compactada é usada para compactar registros ou matrizes de estrutura. Após o empacotamento, o tamanho do objeto compactado pode ser reduzido significativamente. tipo TPerson = compactado Registro PName: string[32]; PChar;
Pascal:
//Pascal marca o protocolo de chamada da função, //aponta que a função segue Pascal ao chamar, ou seja, inicializa todas as variáveis primeiro, //evita erros causados por chamadas de thread assíncronas É compatível com versões anteriores. ): Inteiro;início Resultado := i * 2;fim;
privado:
//Private indica as permissões de diferenciação de acesso dos elementos dentro da classe. Os elementos diferenciados por Private só podem ser acessados dentro desta classe.
procedimento:
//Procedimento é usado para declarar procedimento procedimento Basta apontar os parâmetros e o nome específico do procedimento pode ser vinculado posteriormente.
programa:
//A palavra-chave do programa é usada para indicar que um projeto é uma aplicação. O arquivo exe é gerado após a compilação da biblioteca de controle e o programa pode ser executado diretamente Project1;usa Forms, Unit1 em 'Unit1.pas';{$R *.Res} BEGIN APLICAÇÃO.Initialize;propriedade:
// A palavra -chave da propriedade é usada para declarar propriedades. : Integr; (Remetente: TOBJETO) do objeto;
protegido:
// Protegido indica as permissões de acesso dos elementos dentro da classe.
público:
// Public indica as permissões de diferenciação de acesso dos elementos dentro da classe.
publicado:
// Publicado indica as permissões de acesso dos elementos dentro da classe. Visualizador de objeto.
elevação:
// A declaração de aumento é usada para lançar exceções. : string; comece se i <0, levantando a exceção.Create ('Inteiro não pode ser menor que 0'); Strtoint (S); exceto em e: exceção aumenta a exceção.create (e.message); end;ler:
// Leia é usado para identificar o membro ou o método usado para ler a propriedade.
READONLY:
// A palavra-chave READONLY é usada para identificar se um objeto é somente leitura.propertyReadonly; // Quando o Readonly está definido como True, os usuários não podem modificar manualmente as propriedades e só podem operar através de outros objetos.
registro:
// A palavra -chave de registro é usada para declarar um registro de estrutura ; fim ;
registro:
// REGISTRO MARCAS O protocolo de chamada de função, indicando que a função pode deixar um registro no registro quando é chamado. Controles de registro ou ferramentas especializadas com a biblioteca de controle ou IDE.
reintroduzir:
// Reintroduzido é usado para republicar os métodos, geralmente quando herdando. . Número inteiro);
repita:
// A palavra -chave repetida é usada para introduzir a estrutura de loop de repetição soma: = soma + i;
requer:
// A palavra -chave requer as condições necessárias para compilar o pacote.
Recurso -Restring:
// Recurso é usado para declarar strings de recursos, que podem ser usados na estrutura declarada 'Borland Rocks';
SafeCall:
// SafeCall é um tipo de contrato de chamada de função, que estipula as regras que as funções chamadas por COM devem cumprir. ;
definir:
// Palavra -chave definida é usada para declarar uma classe de coleta, que permite o uso de operadores de conjunto, como em, etc. Tipo TCOL = (CA, CB, CC); Durante a operação para adicionar ou excluir um elemento de coleta var cols: tcols; iniciar cols: = cols + [ca, cb]; end;
shl:
// shl significa mudar para a esquerda.
SHR:
// SHR significa mudar para a direita.
stdcall:
// stdcall é um tipo de contrato de chamada de função, que estipula as regras que funções que podem ser chamadas por um programa deve cumprir Função de chamada de Callee: Demonstração da Biblioteca; Inteiro): Inteiro;
armazenado:
// armazenado é usado para indicar se o valor de uma propriedade pode ser retido.
corda:
// string é um tipo de dados, que representa um string.var str: string;
então:
// Em seguida, a palavra -chave é usada na instrução IF. ); fim;
Threadvar:
// ThreadVar Identifica uma variável criada quando o thread inicia. ''; // s: = '';
para:
// para palavras -chave é usado na declaração for para indicar que a variável de loop é incrementada. Usado para incrementar as palavras variáveis do loop, use a palavra -chave Down para diminuir.
tentar:
// A instrução Try é usada para manipulação de exceções.
tipo:
// Palavra -chave do tipo é usada para declarar vários objetos. CA, CB, CC);
unidade:
// A unidade identifica o início da unidade. começo.
até:
// A palavra -chave é usada para determinar a condição de loop da estrutura de repetição. = soma + i;
Usos:
// usa é usado para fazer referência a uma unidade externa e pode usar as partes públicas da unidade.
var:
// A palavra -chave var é usada para declarar uma variável ou objeto, e a variável declarada com var é passada pelo valor. (var i: número inteiro): Inteiro; // O parâmetro I na função acima é passada por referência, seu valor pode ser alterado quando a função é executada e retornada à função de chamada.
varargs:
// Varargs identifica o parâmetro de referência, que deve ser usado em conjunto com a palavra -chave CDECL, indicando que a função chamada é permitida por referência O código é da biblioteca da classe C ++ A função Printf é referenciada e os parâmetros podem ser transmitidos por referência.
virtual:
// Virtual é usado para declarar um método virtual.
enquanto:
// enquanto a palavra -chave é usada para introduzir a instrução While Loop. Inc (i); fim;
com:
// com palavras -chave é usado para coletar os mesmos objetos para processamento. Appender ('def'); Parece muito redundante copiar o conteúdo para o código da área de transferência: form1.memo1.lines.clear; form1.memo1.lines.append ('abc'); form1.memo1.lines.append ('Def'); form1.memo1. Lines.savetofile ('c: /demo.txt');escrever:
// gravação é usada para identificar o membro ou o método usado na propriedade.
Writenly:
// A palavra-chave WriteNly é usada para identificar se um objeto é apenas gravação.property writeNly; // Quando o WriteNly é definido como TRUE, os usuários não podem ler as propriedades e só podem operar através de outros objetos.
xor:
// xor é usado para exclusivo ou a xor b então writeln ('a xor b') else WriteLN ('a não xor b'); end; // xor também é usado para calcular o WriteLN exclusivo ou de valor (inttostr (3 xor 5));