Este artículo presenta en detalle los nombres y el uso de varias palabras clave comúnmente utilizadas en Delphi para su referencia en el proceso de programación. Los detalles son los siguientes:
absoluto:
//Le permite crear una nueva variable, y la dirección inicial de la variable es la misma que la de otra variable.var Str: string[32]; StrLen: Byte absolutStr;//Esta declaración especifica la dirección inicial de la variable StrLen y Str Same.//Dado que la posición 0 de la cadena almacena la longitud de la cadena, el valor de StrLen es la longitud de la cadena.beginStr := 'abc';Edit1.Text := IntToStr(StrLen);end;
abstracto:
// Le permite crear métodos abstractos, incluidas clases con métodos abstractos llamados clases abstractas. // La palabra clave abstracta debe usarse junto con palabras clave virtuales o dinámicas, porque los métodos abstractos deben anularse // Las clases abstractas no pueden crear instancias, los métodos abstractos no pueden. contiene cuerpos de método. tipo TDemo = procedimiento protegido privado X; resumen del constructor público Destruir;
y:
//1. Expresar AND lógico si (a>0) y (b>0) entonces //2. Expresar operación de bits vara,b,c: Integer;beginc := (a y b);end;//Usar Y Al expresar lógica, las expresiones alrededor de And deben estar entre paréntesis para evitar conflictos de condiciones.//Por ejemplo: si a>0 y b>0 entonces//El compilador puede entenderlo como: si a>( 0 y b) >0 entonces//o:si (a>0) y (b>0) entonces//Pero al compilar realmente, el compilador generará un conflicto e informará un error.//Y el primero puede incluir la forma de a>b>c, que está en Delphi no es compatible.//Por lo tanto, debe usar paréntesis cuando utilice el operador Y para distinguir las condiciones izquierda y derecha.//Al expresar operaciones de bits, también debe agregar paréntesis para encerrar Y y los parámetros izquierdo y derecho.
formación:
// La matriz se utiliza para representar matrices y cualquier objeto se puede declarar como una matriz. Las matrices se dividen en dos tipos: estáticas y dinámicas. // Matriz estática varArr1: matriz [1..10] de Integer; // Matriz dinámica , porque el número de elementos no se conoce en el momento de la declaración, por lo que el tamaño de la matriz se debe establecer más adelante usando el método SetLength varArr2: array of Integer;// Cuando la matriz se usa como parámetro, el tamaño del La matriz no se puede pasar. Solo puede pasar el nombre de la matriz y luego usar el método Longitud para obtener el número de elementos en la función de matriz X(A: matriz de enteros): Integer;vari: Integer;beginResult := 0;for i := 0 a Longitud(A)-1 doResultado:= Resultado + A[i];fin;
como:
//Como se utiliza para convertir un objeto en otro procedimiento de objeto BtnClick(Sender:TObject);begin (Sender as TButton).Caption := 'Clicked';end;//Para la conversión de la interfaz de llenado de objetos, Como debe ser usado (HTTPRIO como IExp).GetConnection;//Como no se puede usar para la conversión de tipos de datos, el siguiente código es incorrecto: vari: Integer;s: string;begins := (i as string);end;//La forma correcta de escribirlo es: s := string(i);
conjunto:
//La palabra clave Asm se usa para insertar código ensamblador. Cuando se usa código ensamblador, debe usar la estructura asm...end; en lugar de comenzar...end;función IntToHex(Valor: Integer; Dígitos: 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 LLAMADA CvtInt MOV EDX, ESI POP EAX CALL System.@LStrFromPCharLen AGREGAR ESP, 32 POP ESIend;
ensamblador:
// La palabra clave Assembler se usa para admitir el ensamblaje temprano, como 80386, etc. // La diferencia entre este y Asm: Asm permite el ensamblaje Win32, mientras que Assembler solo permite el ensamblaje 80x86 y no permite la función de declaración Invoke IntToHex. (Valor A: Int64): cadena;
automatizado:
// El especificador de acceso automatizado se utiliza para describir un miembro escrito automáticamente, lo que puede hacer que la versión del programa sea compatible con versiones anteriores. // Los miembros y sus instancias en la unidad ComObj no pueden usar el especificador de acceso automatizado.type TDemo = class automatizado Str:WideString end; //En la próxima versión del programa, Str se modifica y se convierte en typeTDemo = classautomatedStr: AnsiString;end//La nueva versión de la variable Str puede aceptar la versión anterior de datos de tipo WideString, Y se convierte automáticamente en AnsiString.// En el desarrollo real, si no hay una necesidad especial, generalmente no se utiliza el separador de acceso automatizado.
comenzar:
//La palabra clave de inicio se usa para indicar el comienzo de un programa o estructura, y debe terminar con la palabra clave de finalización del procedimiento. También debe usar la palabra clave de inicio para marcar el punto de inicio de la estructura para que i:=1. 100 dobeginsum := suma + i;si suma > 1000 entonces Break;end;
caso:
// La declaración de caso se utiliza para completar la selección condicional. El objeto seleccionado de la declaración de caso debe ser un tipo ordenado, incluido el tipo entero, el tipo de enumeración, el tipo de carácter, etc. // La declaración de caso debe terminar al final, si no hay coincidencia. elemento de selección; de lo contrario, se puede agregar para realizar una elección general. GetDays(AYear,AMonth: Integer): Integer;comenzar caso AMonth de 1,3,5,7,8,10,12: Resultado:=. 31; 4,6,9,11: Resultado:= 30; 2: comenzar si IsLeapYear(AYear) entonces Resultado:=29 más Resultado:=28;
cdecl:
//Cdecl es un tipo de acuerdo de llamada de función, que estipula las reglas que se deben seguir al llamar a funciones desde una DLL escrita en C o C++ //Puede convertir tipos de datos en C o C++ a Delphi.//Por ejemplo, Código. en C++: int X(int i){ return i*2;}//Esta función está compilada en Demo.dll Al llamar con Delphi, debe usar: función. 'Demo.dll';clase:
// La palabra clave Class se usa para declarar o heredar una clase, o la clase y la interfaz se pueden heredar al mismo tiempo // Además, la palabra clave Class también se puede usar para declarar métodos comunes de una clase, de modo que la clase principal puede acceder a los métodos de la subclase desde dentro de la clase. type ClassDemo = class(TObject) private public constructor Create;// Si un método se declara con la clase, el método se puede utilizar tanto en la clase como en la relacionada. clases, por ejemplo: typeClassA = classprivatepublicprocedure Y;end;typeClassB = clase (Clase A) método de procedimiento de clase pública privada a llamar.
constante:
// La palabra clave Const se usa para declarar constantes. Los datos declarados con const no se pueden cambiar en el programa. // También se puede usar para declarar parámetros de función. Los parámetros especificados con const no se pueden cambiar en la función. = 'Delphi ';const MyInteger = 100;//Al declarar una constante con Const, no es necesario indicar su tipo de datos. El sistema determinará automáticamente el tipo y realizará ajustes automáticos.//Puede usar const para declarar inmutable. parámetros en una función función X(const i: Integer): string;//En este momento, el valor de i no se puede cambiar durante la operación de la función.
constructor:
// La palabra clave constructor se utiliza para declarar el constructor de una clase. Cuando se crea una instancia de la clase, esta función se llama primero. // El constructor generalmente está representado por Create. El método Create se puede asociar con el método CreateWnd. la clase.tipo ClassDemo = clase (TObject) fValue privado: entero público constructor Crear fin;constructor ClassDemo.Create;beginfValue := 0;fin;
contiene:
// La palabra clave Contiene indica si un paquete (Paquete) contiene un determinado archivo. // Los archivos introducidos con Contiene deben agregarse al archivo del paquete, lo que puede evitar la pérdida de referencias a archivos clave DATAX; contiene Db, DBLocal, DBXpress;fin.
por defecto:
//La palabra clave predeterminada se utiliza para indicar el valor predeterminado de una propiedad //Solo las propiedades de tipo ordenado permiten la existencia de valores predeterminados; de lo contrario, el valor de la propiedad debe inicializarse en el constructor. tipo ClassDemo = clase privada fValue: Integer valor de propiedad publicada; : Integer read fValue write fValue default 0; end;// También puede señalar la propiedad predeterminada de una clase strings[Índice: Integer]: string read GetString write PutString;
incinerador de basuras:
// El destructor se usa para identificar el destructor, que se llama automáticamente cuando se libera la clase. // Solo se permite sobrescribir el destructor y no se permite la sobrecarga. El destructor generalmente usa Destroy como nombre de función. class( TComponent) public destructor Destroy;override; end;//Dado que también hay un método Destroy en la clase TComponent, es necesario reescribirlo//Pero si desea sobrecargar el destructor, no está permitido. está mal: destructor Destruir; sobrecargar;
despreciable:
// La palabra clave DispId se utiliza en la interfaz DispInterface para especificar un número de serie de adaptación específico. // En la interfaz DispInterface, el número de serie de adaptación debe ser único. // Si no se especifica DispId, el sistema asignará automáticamente la adaptación. El número de serie se proporciona a cada método en la interfaz. // Puede acceder a los métodos en la interfaz DispInterface a través del número de serie de adaptación IStringsDisp = dispinterface. ['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}'] propiedad ControlDefault[Índice: Entero]: Olevariante dispid 0; predeterminado; función Conteo: Entero; propiedad dispid Índice: Entero: Olevariante 2; Eliminar (Índice: Entero); dispid 3; procedimiento Borrar; 4; función Agregar (Artículo: Olevariante): Entero; dispid 5; función _NewEnum: IUnknown -4;interfaz dispin:
//DispInterface se utiliza para declarar una interfaz de adaptador específica. Este adaptador puede aceptar datos entrantes y salientes en la interfaz estándar del sistema. //La interfaz declarada con DispInterface no se puede heredar y solo se puede hacer referencia a ella. Se llama y debe vincularse dinámicamente. // Puede usar DispId para asignar un número de serie de adaptación a la interfaz. // DispInterface solo se puede usar en la plataforma Windows. Entonces el sistema bloqueará automáticamente esta palabra clave. // Normalmente, no se utiliza DispInterface. // Para ver ejemplos, consulte DispId.
div:
// Div se usa para encontrar el cociente entero de dos números. Los dos valores utilizados en la operación Div deben ser enteros y los resultados de la operación también son enteros var a, b, c: Integer a; := 20; b := 3; c := un div b;
hacer:
//La palabra clave Do se usa en declaraciones For, While, On, With para formar una estructura específica //Declaración For: for i := 1 a 100 do sum:=sum+i;//Declaración While: while i < 100 dobegin sum := sum + i; Inc(i);end;//On declaración (manejo de excepciones):try i := StrToInt(s);excepto en excepción do ShowMessage('Error!');end;//With declaración :con Memo1.Lines dobegin Borrar; Append('abc'); Append('123');end;hasta:
//La palabra clave DownTo se usa en la declaración For para indicar que la variable de bucle se reduce para i := 100 downto 1 doListBox1.Items.Add(IntToStr(i));//En la declaración For, se usa la palabra clave To. para incrementar la variable de bucle, use la palabra clave DownTo para disminuir.
dinámica:
//Dynamic se utiliza para declarar un método dinámico. //Los métodos dinámicos se pueden anular y pueden reducir el tamaño del código tanto como sea posible (a diferencia de Virtual).procedure X(i: Integer);
demás:
//else se usa para guiar la dirección de ejecución del programa. Se puede usar junto con las declaraciones If, Case y On. Cuando no se cumple la condición, vaya a la declaración else para ejecutar //If (en la declaración If). , no se permiten puntos antes de else No.):if a > b thenc := aelsec:=b;// Declaración de caso: etiqueta de caso Of1:Result:=1;2:Result:=2;3:Result:=3;elseResult:=0;end;//Instrucción On (manejo de excepciones):tryi := StrToInt(s);Excpeton EZeroDivide do Result: = 1;en EOverflow hacer resultado:= 2;elseResult:= 0;end;
fin:
//El final se utiliza para finalizar un bloque de instrucciones o una unidad. //Puede coincidir con inicio, caso, clase, interfaz, conjunto, unidad, paquete, etc. //Para los bloques de instrucciones (final local), se debe agregar el final después. Punto y coma.//Para unidades o paquetes (final global), se debe agregar un punto después del final.//No se permiten símbolos después de Fin antes de la palabra clave else en la instrucción If. El procedimiento X comienza con el Botón1. entonces Button1.Caption := 'Insinuado' else Button1.Caption := 'No insinuado'; end;end;//Utilice End en el paquete para finalizar: paquete DATAX;requiresrtl,clx;contiene Db, DBLocal, DBXpress;end.
excepto:
//La palabra clave except se usa para el manejo de excepciones y debe usarse dentro de la declaración try. Si ocurre una excepción, se ejecuta la declaración después de except try i := StrToInt(s);except ShowMessage('Error!');end;exportar:
// Exportar indica el protocolo de llamada de función, lo que indica que la función se puede exportar y la función exportada se puede llamar de forma local o remota. // Otros programas pueden llamar a funciones en el programa en forma de dll. Add( a,b: Integer): Integer; export;// Si este programa está compilado como Demo.exe y otro programa necesita llamar a esta función, puede usar la siguiente función de declaración Add(a,b: Integer): Entero; llamada estándar; 'Demo.exe';
exportaciones:
// exports se usa para generar objetos. Debe usarse entre la interfaz y la implementación. Se pueden generar varios elementos al mismo tiempo, separados por comas. :=IntToStr(i);fin;exportaciones X(i: Entero): cadena; stdcall;comenzar Resultado:= IntToStr(i);fin;función X(s: cadena): Entero sobrecarga;comenzar Resultado:= StrToInt(s);end;exportacionesX (i: entero) nombre 'x1',X(s: cadena) nombre 'x2';comienzo.
externo:
//La palabra clave Externa se usa para hacer referencia a un método externo dentro de OBJ.{$L Demo.OBJ}procedure X(i:Integer);external;//Si se hace referencia a ella desde una dll o un programa externo, se puede usar El siguiente código: function A(FileName: string): string; external 'Demo.dll';// Si la función referenciada está sobrecargada, el nombre referenciado debe especificarse adicionalmente function A(Name: string): sobrecarga; stdcall; nombre externo 'Demo.dll' 'A1'; // Cuando use la palabra clave externa, debe prestar atención al caso, de lo contrario se producirá un error.lejos:
// Far indica el protocolo de llamada de función, lo que indica que la función se puede llamar de forma remota. // Otros programas pueden llamar a funciones en el programa en forma de dll. Es compatible con versiones anteriores. Far ;// Si este programa está compilado en Demo.exe y otro programa en otra computadora necesita llamar a esta función, puede usar la siguiente declaración: function Add(a,b: Integer): Integer external stdcall; 'Demo.exe';
archivo:
//La palabra clave Archivo indica el tipo de operación del archivo. El archivo debe declararse como Archivo. //Si se agrega Of y el tipo de archivo después de Archivo, el archivo se puede definir para leer y escribir el tipo de datos especificado.tipo TPerson = registro PName: cadena [32]; PÁGINA: Entero; fin; var PFile: archivo de TPerson;
finalización:
//La palabra clave de finalización identifica el método que se llamará cuando se libera la unidad. //Por lo general, libera objetos en la unidad que no se pueden liberar automáticamente. //El caso de finalización más utilizado es de. -inicializar objetos OLE inicialización ActiveX.OleInitialize(nil);finalización ActiveX.OleUninitialize;
finalmente:
// La palabra clave finalmente indica el último método que debe llamarse en el manejo de excepciones. // Independientemente de si ocurre una excepción, la declaración posterior a finalmente siempre se ejecuta al final de la declaración try. .Texto := Nodo.Texto;finalmente Nodo := nil;fin;
para:
//La palabra clave For conduce a la estructura del bucle For, que se utiliza para realizar un número específico de bucles for i := 1 to 100 dosum := sum + i;//Si la variable del bucle está disminuyendo, puede utilizar el Palabra clave DownTo para i: = 100 downto 1 do Inc(suma);
adelante:
// La palabra clave Forward se utiliza para la definición directa de métodos. Solo define la declaración del método y luego implementa el método más adelante en el programa. // Esto es beneficioso para la legibilidad del código y todas las declaraciones se pueden combinar. junte todas las implementaciones función X(i: Entero): Entero;procedimiento Y(s: cadena adelante;...función X;comenzar Resultado:= i * 2;fin;procedimiento); Y;beginWriteLn(s);end;// Los métodos reenviados predeclarados no necesitan ingresar los parámetros y valores de retorno del método al implementarlo, solo use el nombre del método directamente.
función:
// La función se utiliza para declarar funciones function Para el nombre de la función, solo necesita indicar los parámetros y el tipo de retorno. El nombre de la función específica se puede vincular más adelante.
ir a:
//La declaración Goto se usa para saltar a un número de línea, que puede saltar a cualquier posición dentro de la capa de estructura actual //El número de línea debe declararse con la palabra clave etiqueta en la declaración //Dado que la declaración Goto destruirá. la estructura del programa, no se recomienda. ('b > a'); fin;si:
//La palabra clave If conduce a la declaración condicional If, que se utiliza para juzgar la condición.var a,b: Integer;begin a := 2; b := 3; if a>b then WriteLn('a=' + IntToStr( a )) else WriteLn('b=' + IntToStr(b));end;//La estructura habitual de la declaración If es If...Then...else, la declaración else es opcional.//Si hay cualquiera en la declaración If Múltiples subdeclaraciones, Luego debes usar la estructura comenzar...End para distinguir si a > b entoncesbegin WriteLn('a>b'); WriteLn('a=' + IntToStr(a)); b) );Endelse WriteLn('b>a');implementación:
//La implementación identifica la parte de implementación en la unidad. La estructura básica de la unidad es:://Unit...Interface...implementation...end.//El cuerpo de la función, el cuerpo del proceso, etc. deben escribirse después. la palabra clave de implementación./ /Si se hace referencia al objeto después de la implementación, el objeto no es público y solo puede ser utilizado por la propia unidad. La implementación utiliza frmAbout;begin FormAbout.Show;end;//Una unidad completa debe tener una implementación. parte.
implementos:
// Implements señala que una propiedad se hereda de la interfaz. En este momento, la propiedad se convierte en un objeto de interfaz. // Enlace dinámico de propiedades a través de la interfaz y configuración dinámica de valores de propiedad tipo IMyInterface = procedimiento de interfaz P1; procedimiento P2; fin de TMyImplclass = procedimiento de clase P1; fin de procedimiento TMyclass = clase (TInterfacedObject, IMyInterface) FMyImplClass: propiedad TMyImplClass: lectura de TMyImplclass; FMyImplclass implementa IMyInterface; procedimiento IMyInterface.P1 = MyP1; procedimiento MyP1; end;// Después de la declaración a través de implementos, puede señalar la entidad del método en la interfaz cuando se declara la clase, como en el ejemplo anterior: procedimiento IMyInterface. P1 = MiP1;
en:
//In se utiliza para determinar si un conjunto contiene un elemento. El contenido a determinar debe ser un único elemento del conjunto y una instancia de un conjunto tipo TCol = (cA,cB,cC); Cols: TCols;begin Cols := [cA,cB]; si cA en Cols entonces ShowMessage('cA in Cols') else ShowMessage('cA not in Cols');end;//In también se usa en archivos de proyecto, Se utiliza para identificar si el proyecto hace referencia a un archivo. Utiliza Unit1 en 'Unit1.pas'; //In se puede utilizar en la instrucción For para extraer elementos de una colección. .. para s En sl comience ShowMessage(s);índice:
// El índice se usa para identificar el número de serie en el atributo, de modo que el mismo método de atributo (Get, Set) se pueda usar para operar diferentes atributos tipo TForm1 = class(TForm) función privada GetInfo(const Index: Integer): Longint. ; procedimiento SetInfo (índice constante: entero; valor constante: propiedad pública iLeft: índice Longint 0 lectura GetInfo escritura propiedad SetInfo iTop: índice Longint 1); GetInfo escribe SetInfo propiedad iWidth: Longint índice 2 lee GetInfo escribe SetInfo propiedad iHeight: Longint índice 3 lee GetInfo escribe SetInfo fin; self.Izquierda; 1: Resultado:= self.Top; 2: resultado:= self.Width; := self.Height; end;end;// La palabra clave Índice también se utiliza para indicar varios elementos en las propiedades, por ejemplo: propiedad Seleccionado[Índice: Integer]: lectura booleana GetSelected escritura SetSelected;
heredado:
// Heredado se usa para llamar al método de la clase principal. tipo TDemo = class(TComponent) public constructor Create(AOwner: TComponent override;constructor TDemo.Create(AOwner: TComponent);begin heredado Create(AOwner);end ; // Si llama a un método con el mismo nombre, también puede omitir el nombre y los parámetros del método, como los heredados en el ejemplo anterior. Create(AOwner);//se puede cambiar a:Heredado;
inicialización:
// La palabra clave de inicialización identifica el método que se llamará cuando se carga la unidad. // Generalmente se usa para inicializar algunos objetos que no se pueden inicializar automáticamente, pero no es necesario usarlo // El caso más común de. la inicialización es inicializar objetos OLE. inicialización ActiveX OleInitialize(nil);finalización ActiveX.OleUninitialize;
en línea:
//La palabra clave InLine se usa en la estructura Asm o ensamblador, //Se usa para indicar que la declaración ensambladora es compatible con versiones anteriores. No tiene ningún impacto en la compilación del programa. IntToStr(Value: Integer): string; asm InLine PUSH ESI MOV ESI, ESP SUB ESP, 16 xor ECX, ECX PUSH EDX xor EDX, EDX CALL CvtInt MOV EDX, ESI POP EAX CALL; System.@LStrFromPCharLen AGREGAR ESP, 16 POP ESIend;
interfaz:
//Interfaz identifica la parte de la interfaz en la unidad. La estructura básica de la unidad es://Unidad...Interfaz...implementación...end.//Las declaraciones de funciones, procedimientos, etc. deben escribirse después de la. Palabra clave de interfaz./ /Si se hace referencia al objeto después de la interfaz, el objeto no tiene instancia y se debe crear una instancia cuando se usa. La interfaz usa frmAbout;var FAbout: TFormAbout;begin FAbout := TFormAbout.Create(Self); FAbout.Show;end;//Una unidad completa debe tener una parte de Interfaz.//La interfaz también se puede usar como una declaración de una interfaz.type IMalloc = interface(IInterface) ['{00000002-0000-0000-C000-000000000046 }'] función Alloc(Tamaño: Entero): Puntero; stdcall función Realloc(P: Puntero; Tamaño: Entero): puntero; stdcall; función DidAlloc (P: puntero): entero;es:
// Esta palabra clave se usa para juzgar objetos. En algunos casos, también se puede usar como "As".var Comp: TComponent;begin ... si Comp es TEdit entonces (Comp as TEdit).Text := 'Edit '. ;fin;
etiqueta:
//la palabra clave etiqueta se usa para declarar la etiqueta del número de línea para que Goto pueda usarse para la dirección. No se recomienda usar.var a,b: Integer;label X,Y;begin if a > b then goto X else goto. Y;X: EscribirLn('a>b');Y: EscribirLn('b>a');fin;biblioteca:
// La palabra clave de biblioteca se usa para indicar que un proyecto es una biblioteca de clases. La biblioteca de clases genera un archivo DLL después de la compilación, que otros programas pueden llamar. Los editores utilizan EdInit, EdInOut, EdFormat, EdPrint y exportan InitEditors. nombre hecho, Insertar texto nombre Insertar, Eliminar nombre de selección Eliminar, Formato de selección, Imprimir nombre de selección Imprimir, SetErrorHandler; comenzar InitLibrary; finalizar.
mensaje:
//La palabra clave Message se utiliza para declarar métodos de mensaje. //El método con Message debe indicar el tipo de mensaje recibido y pasar el mensaje al método por referencia para su procesamiento.procedure Refresh(var Msg: TMessageRecordtype); Refresh(var Msg: TMessageRecordtype);beginif Chr(Msg.Code) = #13 luego...elseinherited;end;//Los usuarios pueden personalizar los mensajes, Los mensajes personalizados también se pueden recibir mediante mensajes y eventos desencadenantes.
modo:
// Mod se usa para encontrar el módulo entero de dos números, es decir, el resto Los dos valores utilizados en la operación Mod deben ser enteros y los resultados de la operación también deben ser enteros. , b, c: Entero; comenzar a := 20; b := 3 c := a mod b;
nombre:
// La palabra clave Nombre se usa para indicar el alias de un método. // Para hacer referencia a un método externamente, se recomienda usar Nombre para solicitar un alias de método para evitar que programas externos cambien el contenido de la entidad del método. //Al hacer referencia a un método desde el exterior, si el método tiene un alias, debe identificarse por Nombre. función MessageBox(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer external 'user32; .dll' nombre 'MessageBoxA';
cerca:
// Cerca marca el protocolo de llamada de función, lo que indica que la función se puede llamar localmente. // Otros programas pueden llamar funciones en el programa en forma de dll. Es compatible con versiones anteriores. ; near;// Si este programa está compilado en Demo.exe y otro programa local necesita llamar a esta función, puede usar la siguiente declaración: function Add(a,b: Integer): Integer external stdcall; 'Demo.exe';
nulo:
//Nil se usa para representar un puntero nulo o un objeto sin una instancia. while Node <> nil dobegin ListBox1.Items.Add(Node.Text):= Node.GetNext;end;
nodo predeterminado:
// La palabra clave NoDefault indica que una propiedad no permite un valor predeterminado, que generalmente se usa en herencia. tipo TClassA = class private fValue: Integer; propiedad publicada Valor: Integer read fValue write fValue default 0; TClassA) propiedad publicada Valor:Entero leer fValue escribir fValue nodefault end;// Como se puede ver en el ejemplo anterior, el valor en TClassA tiene un valor predeterminado de 0, // TClassB hereda TClassA, por lo que también hereda su valor predeterminado. Utilice NoDefault para eliminar el valor predeterminado aquí.
no:
//Not se usa para negar, niega el resultado original. Por ejemplo: si a > b entonces//Se puede escribir como: si no (a < b) entonces//La palabra clave Not generalmente se usa para cambiar el valor booleano. procedimiento de atributo Button1Click (Remitente: TObject);comenzar StatusBar1.Visible := no StatusBar1.Visible;end;
objeto:
// El objeto se utiliza para declarar un objeto. Este objeto puede ser arbitrario y es compatible con versiones anteriores. El objeto solo puede ser heredado por Objeto. // El método para declarar un objeto es el mismo que el método para declarar una clase. object end; ODemoB = object(ODemoA) end;// La palabra clave Object también se utiliza para declarar funciones o procedimientos dinámicos, por ejemplo: tipo TMyFun = function(i: Integer): Integer of Object; ) de object;// La función o procedimiento declarado por el objeto puede vincularse dinámicamente al cuerpo de la función especificada o al evento de control.
de:
//La clave Of se usa para formar una estructura específica con otras palabras clave. Of se puede usar con Caso, Clase, Matriz, Archivo, Conjunto, Objeto //Declaración de caso: etiqueta de caso 0: Resultado := 'a'; : Resultado := 'b';end;//Declaración de clase: tipo TDemo = clase de TComponent;//Estructura de matriz: var MyInt: matriz de Integer;//Estructura de archivo: var MyFile: archivo de Byte;//Establecer declaración: tipo TCol = (cA,cB,cC); TCols = conjunto de TCol;//Estructura del objeto: tipo MyFun = función(I: Entero): Entero del objeto;
en:
// La palabra clave On se utiliza para el manejo de excepciones, señalando la excepción que ocurrió y obteniendo información sobre la excepción try i := StrToInt(s);except on E: excepción do ShowMessage(E.Message);end;
o:
//1. Expresar lógico o si (a>0) o (b>0) entonces //2. Expresar operación de bits vara,b,c: Integer;beginc := (a o b);end;//Usar O Al expresar lógica, las expresiones alrededor de Or deben estar entre paréntesis para evitar conflictos con las condiciones //Si usa Or en una declaración condicional, el editor no sabe qué está haciendo el usuario con Or. Por ejemplo: si a>0 o. b>0 entonces//El compilador puede entenderlo como: si a>(0 o b)>0 entonces//o si (a>0) o (b>0) entonces//Pero al compilar realmente, el compilador generará un conflicto , informar un error //Y el primero puede contener la forma a>b>c, que no es compatible con Delphi //Por lo tanto, debe usar paréntesis cuando use el operador Or para distinguir las condiciones izquierda y derecha.//Indica bit operaciones. También se deben agregar paréntesis cuando Adjunte O y los parámetros izquierdo y derecho.
afuera:
// La palabra clave Out describe el método de salida de los parámetros del método. Una función general solo puede tener un valor de retorno. // Utilice Out para devolver múltiples resultados en una función. // Out es diferente de var. devuelve parámetros y var es la dirección de un parámetro que se ingresa directamente en el procedimiento. TForm1.Button1Click(Remitente: TObject);var i: Integer; s: string;begin i := 20;= 'xxx';
sobrecarga:
//La palabra clave Overload indica el método para sobrecargar. Sobrecarga significa que el nombre del método es el mismo, //pero el número, tipo u orden de los parámetros son diferentes. Si se cumple esta condición, constituye una función de sobrecarga X(i). : Entero): cadena; sobrecarga; función Se deben cumplir los requisitos para la sobrecarga.tipo TDemo = clase(TComponent) procedimiento público CreateWnd(AOwner: TWinControl); sobrecarga; // Como en el ejemplo anterior, el método propiedad de la subclase es: procedimiento CreateWnd {Heredado de la clase principal}procedimiento CreateWnd(AOwner: TWinControl); {Declaración de subclase}//Hay dos métodos CreateWnd.//Si no se utiliza la sobrecarga, el método de la clase principal se puede anular en la subclase.anular:
// La anulación se utiliza para anular un método en forma virtual o dinámica. // Al anular, se debe utilizar la declaración del método anulado y no se permite modificar los parámetros y el tipo de retorno del procedimiento original. Create(AOwner: TComponent); override;/ / Override se usa principalmente para herencia, usando subclases para anular métodos de clase principal. //Como en el ejemplo anterior, Los métodos propiedad de la subclase son: procedimiento X; {anulado de la clase padre}//Los métodos propiedad de la clase padre son: procedimiento Declaración, //o si es necesario modificar parámetros, se debe anular con el Vuelva a introducir la palabra clave.paquete:
//La palabra clave del paquete se usa para indicar que un proyecto es una biblioteca de control. //La biblioteca de control genera un archivo BPL después de la compilación, que se puede instalar en la biblioteca de control de Delphi para que el control pueda usarse en el paquete de desarrollo futuro. ; requiere rtl, clx ; contiene MyUnit en 'C:/MyProject/MyUnit.pas';end.
lleno:
// La palabra clave empaquetada se utiliza para empaquetar registros de estructura o matrices. Después del empaquetado, el tamaño del objeto empaquetado se puede reducir significativamente. tipo TPerson = registro empaquetado PName: cadena [32]; PCar;
pascal:
// Pascal marca el protocolo de llamada de función, // señala que la función sigue a Pascal al llamar, es decir, inicializa todas las variables primero, // evita errores causados por llamadas de subprocesos asincrónicos. Es compatible con versiones anteriores de la función X (i: Integer. ): Entero; Pascal;comenzar Resultado := i * 2;final;
privado:
// Privado indica los permisos de diferenciación de acceso de los elementos dentro de la clase. Solo se puede acceder a los elementos distinguidos por Privado dentro de esta clase.
procedimiento:
// El procedimiento se utiliza para declarar el procedimiento. Simplemente indique los parámetros y el nombre del procedimiento específico se podrá vincular más adelante.
programa:
// La palabra clave del programa se usa para indicar que un proyecto es una aplicación. El archivo exe se genera después de compilar la biblioteca de control y el programa se puede ejecutar directamente Proyecto1; usa Formularios, Unidad1 en 'Unidad1.pas';{$R *.res}comenzar Aplicación.Inicializar; Aplicación.CrearForm(TForm1, Formulario1);propiedad:
// La palabra clave de la propiedad se usa para declarar propiedades. : Integre el valor de la propiedad publicada: Integer Read FValue Write FValue; (Remitente: tobject) de objeto;
protegido:
// Protegido indica los permisos de acceso de los elementos dentro de la clase.
público:
// El público indica los permisos de diferenciación de acceso de los elementos dentro de la clase.
publicado:
// Publicado indica los permisos de acceso de los elementos dentro de la clase. Visor de objetos.
aumentar:
// La declaración de subida se usa para lanzar excepciones. : string; comience si i <0 luego eleva la excepción.create ('Integer no puede más pequeño que 0'); Strtoint (s); excepto en e: excepción eleva la excepción. CREATE (E.Message); final;leer:
// Se utiliza para identificar el miembro o el método utilizado para leer la propiedad.
Readonly:
// La palabra clave Readonly se usa para identificar si un objeto es de solo lectura.
registro:
// La palabra clave de registro se usa para declarar un registro de estructura. ; fin ;
registro:
// El registro marca el protocolo de llamadas de la función, lo que indica que la función puede dejar un registro en el registro cuando se llama. Registro de controles o herramientas expertas con la biblioteca de control o IDE.Procedure Register; Comenzar los componentes de registro ('muestra', [tdemo]); end;reintroducir:
// Reintroduce se usa para volver a publicar métodos, generalmente al heredar. . /Para los métodos virtuales o dinámicos, puede usar directamente para anular. Entero);
repetir:
// La palabra clave repetida se usa para introducir la estructura de bucle de repetición. suma: = suma + i;
requiere:
// La palabra clave requiere las condiciones necesarias para compilar el paquete.
Resourcestring:
// RECURSACIÓN Se utiliza para declarar cadenas de recursos, que se pueden usar dentro de la estructura declarada. 'Borland Rocks';
Safecall:
// Safecall es un tipo de acuerdo de llamada de función, que estipula las reglas que las funciones llamadas por COM deben cumplir. ;
colocar:
// La palabra clave SET se usa para declarar una clase de colección, que permite el uso de operadores establecidos, como en, etc., se permiten tcol = (CA, CB, CC); durante la operación para agregar o eliminar un elemento de recolección var cols: tcols; comenzar cols: = cols + [ca, cb]; final;
SHL:
// shl significa cambiar a la izquierda.
SHR:
// SHR significa cambiar a la derecha.
stdcall:
// stdcall es un tipo de acuerdo de llamada de función, que estipula las reglas que las funciones que pueden llamar un programa deben cumplir. Función de llamadas de Callee: Demo de la biblioteca; Entero): entero;
almacenado:
// almacenado se utiliza para indicar si el valor de una propiedad puede ser retenido.
cadena:
// String es un tipo de datos, que representa un string.var str: string;
entonces:
// entonces la palabra clave se usa en la instrucción if. ); fin;
ThreadVar:
// ThreadVar identifica una variable creada cuando se inicia el hilo. ''; // s: = '';
a:
// a la palabra clave se usa en la instrucción for para indicar que la variable de bucle está incrementada. Utilizado para incrementar las palabras variables de bucle, use la palabra clave Downto para disminuir.
intentar:
// La declaración de prueba se usa para el manejo de excepciones.
tipo:
// La palabra clave se usa para declarar varios objetos. Ca, CB, CC);
unidad:
// la unidad identifica el comienzo de la unidad. comienzo.
hasta:
// La palabra clave hasta determinar la condición de bucle de la estructura de bucle de repetición. = suma + i;
usos:
// se utiliza para hacer referencia a una unidad externa y puede usar las partes públicas de la unidad.
Var:
// La palabra clave VAR se usa para declarar una variable u objeto, y la variable declarada con VAR se pasa por valor. (Var I: Integer): Integer; // El parámetro I en la función anterior se pasa por referencia, su valor se puede cambiar cuando la función se ejecuta y se devuelve a la función de llamada.
Varargs:
// Varargs identifica el parámetro de referencia, que debe usarse junto con la palabra clave CDECL, lo que indica que la función llamada se puede pasar por referencia. El código es de la biblioteca de clases C ++, se hace referencia a la función printf y se permite que los parámetros se pasen por referencia.
virtual:
// Virtual se usa para declarar un método virtual.
mientras:
// Mientras se usa la palabra clave para introducir la instrucción While Loop. Inc (i); final;
con:
// con la palabra clave se usa para recopilar los mismos objetos para el procesamiento. Append ('def'); Parece muy redundante copiar contenido al código del portapapeles: form1.memo1.lines.clear; form1.memo1.lines.append ('ABC'); form1.memo1.lines.append ('def'); form1.memo1. Líneas.savetofile ('c: /demo.txt');escribir:
// Se utiliza para identificar el miembro o el método utilizado para escribir en la propiedad.
WriteDonly:
// La palabra clave WriteDonly se usa para identificar si un objeto es solo Write.Property WriteDonly; // Cuando WriteNly se establece en True, los usuarios no pueden leer propiedades y solo pueden funcionar a través de otros objetos.
Xor:
// xor se usa para exclusivo o cuando los dos operandos son iguales, devuelve falso, y cuando no son iguales, devuelve verdadero.var a, b: entero; A Xor B luego WriteLn ('A Xor B') Else WriteLn ('A no Xor B'); End; // Xor también se usa para calcular el exclusivo o valor WriteLn (intToStr (3 Xor 5));