Cet article présente en détail les noms et l'utilisation de divers mots-clés couramment utilisés dans Delphi pour votre référence dans le processus de programmation. Les détails sont les suivants :
absolu:
//Il vous permet de créer une nouvelle variable, et l'adresse de début de la variable est la même que celle d'une autre variable.var Str: string[32]; Byte AbsoluteStr;//Cette déclaration spécifie l'adresse de début de la variable StrLen et Str Same.//Puisque la 0ème position de la chaîne stocke la longueur de la chaîne, la valeur de StrLen est la longueur de la chaîne.beginStr := 'abc';Edit1.Text := IntToStr(StrLen);end;
abstrait:
//Il vous permet de créer des méthodes abstraites, y compris des classes avec des méthodes abstraites appelées classes abstraites. //Le mot-clé abstrait doit être utilisé avec des mots-clés virtuels ou dynamiques, car les méthodes abstraites doivent être remplacées. //Les classes abstraites ne peuvent pas être instanciées, les méthodes abstraites ne peuvent pas. contient des corps de méthode. type TDemo = procédure privée protégée X ; résumé ; constructeur public Create ;
et:
//1. Exprimer ET logique si (a>0) et (b>0) alors//2. Exprimer l'opération de bit vara,b,c : Integer;beginc := (a et b);end;//Utiliser And Lors de l'expression de la logique, les expressions autour de And doivent être placées entre parenthèses pour éviter les conflits de conditions.//Par exemple : si a>0 et b>0 alors//Le compilateur peut le comprendre comme : if a>( 0 et b) >0 alors//ou :si (a>0) et (b>0) alors//Mais lors de la compilation, le compilateur générera un conflit et signalera une erreur.//Et le premier peut inclure la forme a>b>c, qui est en Delphi Non pris en charge.//Vous devez donc utiliser des parenthèses lorsque vous utilisez l'opérateur Et pour distinguer les conditions gauche et droite.//Lors de l'expression d'opérations sur les bits, vous devez également ajouter des parenthèses pour encadrer Et et les paramètres gauche et droit.
tableau:
//Le tableau est utilisé pour représenter des tableaux, et n'importe quel objet peut être déclaré comme un tableau. Les tableaux sont divisés en deux types : statique et dynamique //Tableau statique varArr1 : tableau [1..10] d'entiers ;//Tableau dynamique. , car Le nombre d'éléments n'est pas connu au moment de la déclaration, la taille du tableau doit donc être définie ultérieurement à l'aide de la méthode SetLength varArr2 : tableau d'entiers ;//Lorsque le tableau est utilisé comme paramètre, la taille du le tableau ne peut pas être transmis. Vous pouvez uniquement transmettre le nom du tableau, puis utiliser la méthode length pour obtenir le nombre d'éléments dans la fonction de tableau X(A: array of Integer): Integer;vari: Integer;beginResult := 0;for i := 0 à Longueur(A)-1 doResult := Résultat + A[i];end;
comme:
//As est utilisé pour convertir un objet en une autre procédure objet BtnClick(Sender:TObject);begin (Sender as TButton).Caption := 'Clicked';end;//Pour la conversion de l'interface de remplissage d'objet, As doit être utilisé (HTTPRIO comme IExp).GetConnection;//Comme ne peut pas être utilisé pour la conversion de type de données, le code suivant est erroné : vari: Integer;s: string;begins := (i as string);end;//La façon correcte de l'écrire est : s := string(i);
asme :
//Le mot-clé Asm est utilisé pour insérer du code assembleur, vous devez utiliser la structure asm...end; au lieu 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 APPEL CvtInt MOV EDX, ESI POP EAX CALL System.@LStrFromPCharLen AJOUTER ESP, 32 POP ESIend ;
assembleur :
//Le mot-clé Assembler est utilisé pour prendre en charge l'assemblage précoce, tel que 80386, etc. //La différence entre lui et Asm : Asm autorise l'assemblage Win32, tandis qu'Assembler n'autorise que l'assemblage 80x86 et n'autorise pas la fonction d'instruction Invoke IntToHex. (AValue : Int64) : chaîne ; assembleur ;
automatisé :
//Le spécificateur d'accès automatisé est utilisé pour décrire un membre typé automatiquement, ce qui peut rendre la version du programme rétrocompatible. //Les membres et leurs instances dans l'unité ComObj ne peuvent pas utiliser le spécificateur d'accès automatisé.type TDemo = class automation Str:WideString end; //Dans la prochaine version du programme, Str est modifié et devient typeTDemo = classautomatedStr: AnsiString;end//La nouvelle version de la variable Str peut accepter l'ancienne version des données de type WideString, Et automatiquement converti en AnsiString.//Dans le développement réel, s'il n'y a pas de besoin particulier, le séparateur d'accès automatisé n'est généralement pas utilisé.
commencer:
//Le mot-clé start est utilisé pour indiquer le début d'un programme ou d'une structure, et doit se terminer par le mot-clé end procédure Vous devez également utiliser le mot-clé start pour marquer le point de départ de la structure pour i:=1 à. 100 dobeginsum := somme + i;si somme > 1000 alors Break;end;
cas:
// L'instruction Case est utilisée pour compléter la sélection conditionnelle. L'objet sélectionné de l'instruction Case doit être un type ordonné, comprenant un type entier, un type d'énumération, un type de caractère, etc. // L'instruction Case doit être terminée par end, s'il n'y a pas de correspondance. élément de sélection, sinon peut être ajouté pour faire un choix général. fonction GetDays(AYear,AMonth: Integer): Integer;begin case AMonth of 1,3,5,7,8,10,12: Result := 31 ; 4,6,9,11 : Résultat := 30 ; 2 : début si IsLeapYear(AYear) then Résultat :=29 sinon Résultat :=28 sinon Résultat :=0 ; fin ;
cdecl :
//Cdecl est un type d'accord d'appel de fonction, qui stipule les règles qui doivent être suivies lors de l'appel de fonctions à partir d'une DLL écrite en C ou C++. //Il peut convertir des types de données en C ou C++ en Delphi.//Par exemple du Code. en C++ : int X(int i){ return i*2;}//Cette fonction est compilée dans Demo.dll Lors d'un appel avec Delphi, vous devez utiliser : function. 'Démo.dll';classe:
//Le mot-clé Class est utilisé pour déclarer ou hériter d'une classe, ou la classe et l'interface peuvent être héritées en même temps //De plus, le mot-clé Class peut également être utilisé pour déclarer des méthodes communes d'une classe, de sorte que le la classe parent peut accéder aux méthodes de la sous-classe depuis la classe. .type ClassDemo = class(TObject) private public constructor Create;//Si une méthode est déclarée avec la classe, la méthode peut être utilisée à la fois dans la classe et dans celle associée. classes, par exemple : typeClassA = classprivatepublicprocedure Y;end;typeClassB = méthode de procédure class(ClassA)privatepublicclass à appeler.
const :
//Le mot-clé Const est utilisé pour déclarer des constantes. Les données déclarées avec const ne peuvent pas être modifiées dans le programme. //Il peut également être utilisé pour déclarer les paramètres de fonction spécifiés avec const ne peuvent pas être modifiés dans la fonction const MyFileName. = 'Delphi ';const MyInteger = 100;//Lors de la déclaration d'une constante avec Const, vous n'avez pas besoin d'indiquer son type de données. Le système déterminera automatiquement le type et effectuera des ajustements automatiques.//Vous pouvez utiliser const pour déclarer inchangé. paramètres dans une fonction fonction X(const i : Entier) : chaîne ;//À l’heure actuelle, la valeur de i ne peut pas être modifiée pendant l’opération de la fonction.
constructeur:
//Le mot-clé constructor permet de déclarer le constructeur d'une classe. Lorsque la classe est instanciée, cette fonction est d'abord appelée. //Le constructeur est généralement représenté par Create. La méthode Create peut être associée à la méthode CreateWnd qui existe dans. le class.type ClassDemo = class( TObject) private fValue : Integer; public constructor Create;constructor ClassDemo.Create;beginfValue := 0;end;
contient:
//Le mot-clé Contains indique si un package (Package) contient un certain fichier. //Les fichiers introduits avec Contains doivent être ajoutés au fichier du package, ce qui peut éviter la perte de références aux fichiers clés package DATAX require rtl, clx ; contient Db, DBLocal, DBXpress;end.
défaut:
//Le mot-clé Default est utilisé pour indiquer la valeur par défaut d'une propriété //Seules les propriétés de type ordonné permettent l'existence de valeurs par défaut, sinon la valeur de la propriété doit être initialisée dans le constructeur type ClassDemo = class private fValue : Integer property Value; : Integer read fValue write fValue default 0; end;//Il peut également indiquer la propriété par défaut d'une classe property strings[Index: Integer]: string read GetString write PutString Default;
destructeur :
//Le destructeur est utilisé pour identifier le destructeur, qui est automatiquement appelé lorsque la classe est publiée. //Le destructeur peut uniquement être écrasé et aucune surcharge n'est autorisée.Le destructeur utilise généralement Destroy comme type de fonction ClassDemo =. class( TComponent) public destructor Destroy;override; end;//Comme il existe également une méthode Destroy dans la classe TComponent, elle doit être réécrite//Mais si vous souhaitez surcharger le destructeur, ce n'est pas autorisé. est faux : destructeur Détruire ; surcharger ;
dispid:
//Le mot-clé DispId est utilisé dans l'interface DispInterface pour spécifier un numéro de série d'adaptation spécifique. //Dans l'interface DispInterface, le numéro de série d'adaptation doit être unique //Si DispId n'est pas spécifié, le système attribuera automatiquement l'adaptation. le numéro de série est attribué à chaque méthode dans l'interface. //Vous pouvez accéder aux méthodes dans l'interface DispInterface via le type de numéro de série d'adaptation IStringsDisp = dispinterface. ['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}'] propriété ControlDefault[Index : Integer] : Dispid Olevariant 0 ; fonction Count : Entier dispid 1 ; Supprimer (Index : Entier) ; dispid 3 ; procédure Effacer ; 4 ; fonction Add(Item : Olevariant) : Entier ; dispid 5 ; fonction _NewEnum : IUnknown fin ;interface de diffusion :
//DispInterface est utilisé pour déclarer une interface d'adaptateur spécifique. Cet adaptateur peut accepter les données entrantes et sortantes dans l'interface système standard. //L'interface déclarée avec DispInterface ne peut pas être héritée et ne peut être référencée que. Appelé et doit être lié dynamiquement. //Vous pouvez utiliser DispId pour attribuer un numéro de série d'adaptation à l'interface. //DispInterface ne peut être utilisé que sur la plateforme Windows. Ensuite, ce mot-clé sera automatiquement bloqué par le système. //Normalement, DispInterface n'est pas utilisé //Pour des exemples, voir DispId.
div :
//Div est utilisé pour trouver le quotient entier de deux nombres. Les deux valeurs utilisées dans l'opération Div doivent toutes deux être des entiers, et les résultats de l'opération sont également des entiers var a, b, c : Integer start a. := 20; b := 3; c := un div {6}fin;faire:
//Le mot clé Do est utilisé dans les instructions For, While, On, With pour former une structure spécifique //Instruction For : for i := 1 à 100 do sum:=sum+i;//Instruction While : while i < 100 dobegin sum := sum + i; Inc(i);end;//On instruction (gestion des exceptions):try i := StrToInt(s);sauf en cas d'exception do ShowMessage('Error!');end;//With déclaration : avec Memo1.Lines dobegin Clear; Append('abc'); Append('123');end;jusqu'à :
//Le mot clé DownTo est utilisé dans l'instruction For pour indiquer que la variable de boucle est décrémentée for i := 100 jusqu'à 1 doListBox1.Items.Add(IntToStr(i));//Dans l'instruction For, le mot clé To est utilisé. pour incrémenter la variable de boucle, utilisez le mot-clé DownTo pour décrémenter.
dynamique:
//Dynamic est utilisé pour déclarer une méthode dynamique. //Les méthodes dynamiques peuvent être remplacées et peuvent réduire la taille du code autant que possible (différent de Virtual).procedure X(i: Integer Dynamic);
autre:
//else est utilisé pour guider le sens d'exécution du programme. Il peut être utilisé conjointement avec les instructions If, Case et On. Lorsque la condition n'est pas remplie, accédez à l'instruction else pour exécuter l'instruction //If (dans l'instruction If. , aucun point n'est autorisé avant else No.):if a > b thenc := aelsec:=b;//Instruction Case : case Tag Of1:Result:=1;2:Result:=2;3:Result:=3;elseResult:=0;end;//On instruction (gestion des exceptions):tryi := StrToInt(s);Excpeton EZeroDivide do Result: = 1;sur EOverflow faire Result := 2;elseResult := 0;end;
fin:
//End est utilisé pour terminer un bloc d'instructions ou une unité. //Il peut correspondre à un début, un cas, une classe, une interface, un Asm, une unité, un package, etc. //Pour les blocs d'instructions (fin locale), End doit être ajouté après. Point-virgule.//Pour les unités ou les packages (fin globale), un point doit être ajouté après la fin.//Aucun symbole n'est autorisé après End avant le mot-clé else dans l'instruction If. La procédure X commence par Button1 et commence if Button1. alors Button1.Caption := 'Hinted' else Button1.Caption := 'Not Hinted'; end;end;//Utilisez End dans le package pour terminer : package DATAX;requiresrtl,clx;contains Db, DBLocal, DBXpress;end.
sauf:
//Le mot clé except est utilisé pour la gestion des exceptions et doit être utilisé dans l'instruction try. Si une exception se produit, l'instruction après except est exécutée try i := StrToInt(s);sauf ShowMessage('Error!');end;exporter:
//Export indique le protocole d'appel de la fonction, indiquant que la fonction peut être exportée et que la fonction exportée peut être appelée localement ou à distance. //D'autres programmes peuvent appeler des fonctions dans le programme sous forme de dll. Add( a,b: Integer) : Integer; export;//Si ce programme est compilé en tant que Demo.exe et qu'un autre programme doit appeler cette fonction, vous pouvez utiliser l'instruction suivante function Add(a,b: Integer) : Entier ; appel standard ; 'Démo.exe';
exportations:
//exports est utilisé pour générer des objets.Il doit être utilisé entre l'interface et l'implémentation. Plusieurs éléments peuvent être générés en même temps, séparés par des virgules libraryDemo;function X(i: Integer): string;begin Result. :=IntToStr(i);end;exports X(i: Integer): chaîne; surcharge; stdcall;begin Résultat := IntToStr(i);end;fonction X(s: chaîne): Integer; stdcall;begin Résultat := StrToInt(s);end;exportsX (i : entier) nom 'x1', X(s : chaîne) nom 'x2' ; début fin.
externe:
//Le mot-clé External est utilisé pour référencer une méthode externe ou dans OBJ.{$L Demo.OBJ}procédure X(i:Integer);external;//S'il est référencé à partir d'une DLL ou d'un programme externe, il peut être utilisé Le code suivant : function A(FileName: string): string; external 'Demo.dll';//Si la fonction référencée est surchargée, le nom référencé doit être spécifié en plus function A(Name: string): string surcharge ; stdcall ; nom externe 'Demo.dll' 'A1' ; fonction A(Code : Integer) : surcharge de chaîne ; au cas échéant, sinon une erreur se produira.loin:
//Far indique le protocole d'appel de la fonction, indiquant que la fonction peut être appelée à distance. //D'autres programmes peuvent appeler des fonctions dans le programme sous forme de dll. functionAdd(a,b: Integer); Far ;//Si ce programme est compilé dans Demo.exe et qu'un autre programme sur un autre ordinateur doit appeler cette fonction, vous pouvez utiliser l'instruction suivante : function Add(a,b: Integer) : Integer; 'Démo.exe';
déposer:
//Le mot-clé File indique le type d'opération de fichier. Le fichier doit être déclaré comme File. //Si Of et le type de fichier sont ajoutés après File, le fichier peut être défini pour lire et écrire le type de données spécifié.type TPerson = record. PName : string[ 32] ; PAge : Integer ; fin ;var PFile : fichier de TPerson ;
finalisation :
//Le mot-clé de finalisation identifie la méthode à appeler lorsque l'unité est libérée. //Habituellement, il libère les objets de l'unité qui ne peuvent pas être automatiquement libérés. //Le cas de finalisation le plus couramment utilisé est de. -initialiser les objets OLE. initialisation ActiveX.OleInitialize(nil);finalisation ActiveX.OleUninitialize;
enfin:
//Le mot-clé enfin indique la dernière méthode qui doit être appelée dans la gestion des exceptions. //Qu'une exception se produise ou non, l'instruction qui suit enfin est toujours exécutée à la fin de l'instruction try Node := Node.GetNext; .Text := Node.Text;finalement Node := nil;end;
pour:
//Le mot-clé For mène à la structure de boucle For, qui est utilisée pour effectuer un nombre spécifié de boucles. for i := 1 à 100 dosum := sum + i;//Si la variable de boucle est décrémentée, vous pouvez utiliser le Mot-clé DownTo pour i : = 100 downto 1 do Inc(sum) ;
avant:
//Le mot-clé Forward est utilisé pour la définition directe des méthodes. Définissez uniquement la déclaration de méthode, puis implémentez la méthode plus tard dans le programme // Cela est bénéfique pour la lisibilité du code, et toutes les déclarations peuvent ensuite être rassemblées. rassembler toutes les implémentations. function X(i: Integer): Integer; forward;procedure Y(s: string);...function X;begin Result := i * 2;end;procedure Y;beginWriteLn(s);end;//Les méthodes pré-déclarées Forward n'ont pas besoin de saisir les paramètres et de renvoyer les valeurs de la méthode lors de son implémentation, utilisez simplement le nom de la méthode directement.
fonction:
//La fonction est utilisée pour déclarer la fonction des fonctions. Pour le nom de la fonction, il vous suffit d'indiquer les paramètres et le type de retour. Le nom de la fonction spécifique peut être lié ultérieurement.
aller à :
// L'instruction Goto est utilisée pour accéder à un numéro de ligne, qui peut accéder à n'importe quelle position dans la couche de structure actuelle. // Le numéro de ligne doit être déclaré avec le mot-clé label lors de la déclaration // Puisque l'instruction Goto va détruire. la structure du programme, ce n'est pas recommandé. .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');fin;si:
//Le mot-clé If mène à l'instruction conditionnelle If, qui est utilisée pour juger la condition.var a,b: Integer;begin a := 2; if a>b then WriteLn('a=' + IntToStr( a )) else WriteLn('b=' + IntToStr(b));end;//La structure habituelle de l'instruction If est If...Then...sinon, l'instruction else est facultative.//S'il y a n'importe lequel dans l'instruction If Plusieurs sous-instructions, Ensuite, vous devez utiliser la structure start...End pour distinguer si a > b thenbegin WriteLn('a>b'); b) );Endelse WriteLn('b>a');mise en œuvre:
//L'implémentation identifie la partie implémentation dans l'unité. La structure de base de l'unité est ://Unit...Interface...implementation...end.//Le corps de la fonction, le corps du processus, etc. doivent être écrits après. le mot-clé d'implémentation./ /Si l'objet est référencé après l'implémentation, l'objet est non public et ne peut être utilisé que par l'unité elle-même. L'implémentation utilise frmAbout;begin FormAbout.Show;end;//Une unité complète doit avoir une implémentation. partie.
met en œuvre :
//Implements souligne qu'une propriété est héritée de l'interface.À ce stade, la propriété est convertie en un objet d'interface //Liaison dynamique des propriétés via l'interface et le paramètre dynamique des valeurs de propriété IMyInterface = procédure d'interface P1; procédure P2 ; fin ; TMyImplclass = procédure de classe P1 ; procédure P2 : fin de la classe (TInterfacedObject, IMyInterface) FMyImplClass : propriété MyImplClass ; FMyImplclass implémente IMyInterface; procédure IMyInterface.P1 = MyP1; procédure MyP1; end;//Après la déclaration via Implements, vous pouvez indiquer l'entité de la méthode dans l'interface lorsque la classe est déclarée, comme dans l'exemple ci-dessus : procédure IMyInterface. P1 = MonP1 ;
dans:
//In est utilisé pour déterminer si un ensemble contient un élément. Le contenu à déterminer doit être un élément d'ensemble unique et une instance d'un type d'ensemble 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 est également utilisé dans les fichiers de projet, Utilisé pour identifier si un fichier est référencé par le projet. Utilise Unit1 dans 'Unit1.pas' ; //In peut être utilisé dans l'instruction For pour boucler les éléments d'une collection. .. pour s Dans sl, commencez ShowMessage(s);indice:
//Index est utilisé pour identifier le numéro de série dans l'attribut afin que la même méthode d'attribut (Get, Set) puisse être utilisée pour faire fonctionner différents attributs type TForm1 = class(TForm) fonction privée GetInfo(const Index : Integer) : Longint. ; procédure SetInfo (const Index : Integer ; const Value : Longint) ; propriété publique iLeft : Longint index 0 lire GetInfo écrire SetInfo ; GetInfo écrire SetInfo ; propriété iWidth : Longint index 2 lire GetInfo écrire SetInfo ; propriété iHeight : Longint index 3 lire GetInfo écrire SetInfo ; fonction TForm1.GetInfo (const Index : Integer) : Longint ; début du cas Index de 0 : résultat : = self.Left; 1 : Résultat := self.Top 2 : résultat := self.Width ; := self.Height; end;end;//Le mot clé Index est également utilisé pour indiquer plusieurs éléments dans les propriétés, par exemple : property Selected[Index: Integer]: Boolean read GetSelected write SetSelected;
hérité:
//Hérité est utilisé pour appeler la méthode de la classe parent.type TDemo = class(TComponent) public constructor Create(AOwner: TComponent); end;constructor TDemo.Create(AOwner: TComponent);begin generic Create(AOwner);end ; //Si vous appelez une méthode avec le même nom qu'elle, vous pouvez également omettre le nom de la méthode et les paramètres, par exemple hérités dans l'exemple ci-dessus. Create(AOwner);//peut être modifié en : Hérité ;
initialisation :
//Le mot-clé d'initialisation identifie la méthode à appeler lors du chargement de l'unité. //Habituellement, il est utilisé pour initialiser certains objets qui ne peuvent pas être initialisés automatiquement, mais il n'est pas nécessaire de l'utiliser //Le cas le plus couramment utilisé. l'initialisation consiste à initialiser les objets OLE. initialisation ActiveX OleInitialize(nil);finalisation ActiveX.OleUninitialize;
en ligne：
//Le mot clé InLine est utilisé dans la structure Asm ou assembleur, //Il est utilisé pour indiquer que l'instruction assembly est rétrocompatible. Il n'a aucun impact sur la compilation du programme. 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 AJOUTER ESP, 16 POP ESIend ;
interface:
//Interface identifie la partie interface dans l'unité. La structure de base de l'unité est://Unit...Interface...implementation...end.//Les déclarations de fonctions, procédures, etc. doivent être écrites après le Mot-clé d'interface./ /Si l'objet est référencé après l'interface, l'objet n'a pas d'instance et doit être instancié lorsqu'il est utilisé. L'interface utilise frmAbout;var FAbout: TFormAbout;begin FAbout := TFormAbout.Create(Self); FAbout.Show;end;//Une unité complète doit avoir une partie Interface.//L'interface peut également être utilisée comme déclaration d'une interface.type IMalloc = interface(IInterface) ['{00000002-0000-0000-C000-000000000046 }'] function Alloc(Size: Integer): Pointeur; stdcall; function Realloc(P: Pointeur; Taille: Entier : Pointeur ; stdcall ; procédure Free(P : Pointeur ); fonction GetSize(P : Pointeur ): Integer ; stdcall function DidAlloc : Integer ;est:
//Le mot-clé Is est utilisé pour le jugement d'objet. Dans certains cas, il peut également être utilisé comme "As".var Comp: TComponent;begin ... if Comp Is TEdit then (Comp as TEdit).Text := 'Edit ' ;fin;
étiquette:
//le mot-clé label est utilisé pour déclarer l'étiquette du numéro de ligne afin que Goto puisse être utilisé pour le pilotage. Il n'est pas recommandé d'utiliser.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');end;bibliothèque:
//Le mot-clé Bibliothèque est utilisé pour indiquer qu'un projet est une bibliothèque de classes. La bibliothèque de classes génère un fichier DLL après compilation, qui peut être appelé par d'autres programmes éditeurs de bibliothèque ; utilise EdInit, EdInOut, EdFormat, EdPrint ; nom terminé, nom InsertText Insert , nom DeleteSelection Supprimer, FormatSelection, nom PrintSelection Print, SetErrorHandler; début InitLibrary; fin.
message:
//Le mot clé Message est utilisé pour déclarer les méthodes de message. //La méthode avec Message doit indiquer le type de message reçu et transmettre le message dans la méthode par référence pour le traitement.procedure Refresh(var Msg: TMessageRecordtype); Refresh(var Msg: TMessageRecordtype);beginif Chr(Msg.Code) = #13 then...elseinherited;end;//Les utilisateurs peuvent personnaliser les messages, Des messages personnalisés peuvent également être reçus par Message et déclencher des événements.
mod :
//Mod est utilisé pour trouver le module entier de deux nombres, c'est-à-dire le reste. Les deux valeurs utilisées dans l'opération Mod doivent toutes deux être des entiers, et les résultats des opérations doivent également être des entiers var a. , b, c : Entier ; début a := 20 ; b := 3 ; c := a mod {2}fin ;nom:
//Le mot-clé Name est utilisé pour indiquer l'alias d'une méthode. //Pour qu'une méthode soit référencée en externe, il est recommandé d'utiliser Name pour demander un alias de méthode afin d'empêcher les programmes externes de modifier le contenu de l'entité de la méthode. //Lors du référencement d'une méthode de l'extérieur, si la méthode a un alias, elle doit être identifiée par Name function MessageBox(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer external 'user32; .dll' nom 'MessageBoxA';
près:
//Near marque le protocole d'appel de la fonction, indiquant que la fonction peut être appelée localement. //D'autres programmes peuvent appeler des fonctions dans le programme sous forme de dll. Fonction Add(a,b: Integer). ; near;//Si ce programme est compilé dans Demo.exe et qu'un autre programme local doit appeler cette fonction, vous pouvez utiliser l'instruction suivante : function Add(a,b: Integer): Integer external; 'Démo.exe';
néant:
//Nil est utilisé pour représenter un pointeur nul ou un objet sans instance while Node <> nil dobegin ListBox1.Items.Add(Node.Text);
défaut de nœud :
//Le mot clé NoDefault indique qu'une propriété n'autorise pas une valeur par défaut, qui est généralement utilisée dans l'héritage. type TClassA = class private fValue : Integer ; TClassA ) propriété publiée Value:Integer read fValue write fValue nodefault;//Comme le montre l'exemple ci-dessus, la valeur dans TClassA a une valeur par défaut de 0, //TClassB hérite de TClassA, il hérite donc également de sa valeur par défaut. Utilisez NoDefault pour supprimer la valeur par défaut ici.
pas:
//Not est utilisé pour nier, il annule le résultat original. Par exemple : si a > b then//Il peut être écrit comme : if not (a < b) then//Le mot-clé Not est généralement utilisé pour changer de booléen. procédure d'attribut Button1Click (Expéditeur : TObject);begin StatusBar1.Visible := pas StatusBar1.Visible;end;
objet:
//L'objet est utilisé pour déclarer un objet.Cet objet peut être arbitraire et est rétrocompatible.L'objet ne peut être hérité que par l'objet //La méthode de déclaration d'un objet est la même que la méthode de déclaration d'une classe. object end; ODemoB = object(ODemoA) end;//Le mot-clé Object est également utilisé pour déclarer des fonctions ou des procédures dynamiques, par exemple : tapez TMyFun = function(i: Integer) : Integer of Object; ) de object;//La fonction ou la procédure déclarée par object peut être liée dynamiquement au corps de fonction spécifié, ou liée à l'événement de contrôle.
de:
//Of key est utilisé pour former une structure spécifiée avec d'autres mots-clés. Of peut être utilisé avec Case, Class, Array, File, Set, Object //Instruction Case : case Tag Of 0: Result := 'a'; : Résultat := 'b';end;//Instruction de classe : type TDemo = classe de TComponent;//Structure du tableau : var MyInt : tableau d'Integer;//Structure du fichier : var MyFile : fichier de Octet ;//Instruction Set : type TCol = (cA,cB,cC); TCols = ensemble de TCol;//Structure de l'objet : type MyFun = function(I : Integer) : Entier de l'objet ;
sur:
//Le mot-clé On est utilisé pour la gestion des exceptions, en signalant l'exception qui s'est produite et en obtenant des informations sur l'exception. try i := StrToInt(s);sauf sur E: exception do ShowMessage(E.Message);end;
ou:
//1. Exprimer logique ou si (a>0) ou (b>0) alors//2. Opération de bit express vara,b,c : Integer;beginc := (a ou b);end;//Utiliser Ou Lors de l'expression de la logique, les expressions autour de Or doivent être placées entre parenthèses pour éviter les conflits avec les conditions. //Si vous utilisez Or dans une instruction conditionnelle, l'éditeur ne sait pas ce que l'utilisateur fait avec Or. Par exemple : si a>0 ou. b>0 then//Le compilateur peut le comprendre comme : if a>(0 or b)>0 then//ou if (a>0) ou (b>0) then//Mais lors de la compilation, le compilateur générera un conflit , signale une erreur //Et le premier peut contenir la forme a>b>c, qui n'est pas prise en charge dans Delphi //Vous devez donc utiliser des parenthèses lorsque vous utilisez l'opérateur Ou pour distinguer les conditions gauche et droite.//Indique le bit opérations Des parenthèses doivent également être ajoutées lorsque Joignez Or et les paramètres gauche et droit.
dehors:
//Le mot-clé Out décrit la méthode de sortie des paramètres de méthode. Une fonction générale ne peut avoir qu'une seule valeur de retour. //Utiliser Out pour renvoyer plusieurs résultats dans une fonction //Out est différent de var. renvoie les paramètres et var est l'adresse d'un paramètre directement saisi dans la procédure. TForm1.Button1Click(Expéditeur : TObject);var i : Integer; s: string;begin i := 20;
surcharge:
//Le mot-clé Overload indique la méthode de surcharge. La surcharge signifie que le nom de la méthode est le même, //mais le nombre, le type ou l'ordre des paramètres sont différents. Si cette condition est remplie, cela constitue une fonction de surcharge X(i. : Integer): string; surcharge;fonction Les conditions de surcharge doivent être remplies.type TDemo = class(TComponent) public Procedure CreateWnd(AOwner: TWinControl); surcharge;//Comme dans l'exemple ci-dessus, la méthode appartenant à la sous-classe est : procédure CreateWnd;procedure CreateWnd(AOwner: TWinControl); {Déclaration de sous-classe }//Il existe deux méthodes CreateWnd.//Si la surcharge n'est pas utilisée, la méthode de la classe parent peut être remplacée dans la sous-classe.outrepasser:
//Le remplacement est utilisé pour remplacer une méthode sous la forme virtuelle ou dynamique. //En cas de remplacement, la déclaration de la méthode remplacée doit être utilisée, et les paramètres et le type de retour de la méthode d'origine ne peuvent pas être modifiés. Create(AOwner: TComponent);/ /Override est principalement utilisé pour l'héritage, en utilisant des sous-classes pour remplacer les méthodes de classe parent. //Comme dans l'exemple ci-dessus, Les méthodes appartenant à la sous-classe sont : procédure X ; {remplacée par la classe parent}//Les méthodes appartenant à la classe parent sont : procédure Statement, //ou s'il est nécessaire de modifier les paramètres, elle doit être remplacée par le Réintroduisez le mot-clé.emballer:
//Le mot-clé Package est utilisé pour indiquer qu'un projet est une bibliothèque de contrôles. //La bibliothèque de contrôles génère un fichier BPL après compilation, qui peut être installé dans la bibliothèque de contrôles Delphi afin que le contrôle puisse être utilisé dans le développement futur du package DATAX. ; nécessite rtl, clx ; contient MyUnit dans 'C:/MyProject/MyUnit.pas';end.
emballé:
//Le mot-clé Packed est utilisé pour compresser des enregistrements de structure ou des tableaux. Après l'empaquetage, la taille de l'objet compressé peut être considérablement réduite. type TPerson = packed Record PName: string[32]; PChar;
pascal:
//Pascal marque le protocole d'appel de la fonction, // souligne que la fonction suit Pascal lors de l'appel, c'est-à-dire qu'elle initialise d'abord toutes les variables, //évite les erreurs causées par les appels de thread asynchrones. Elle est rétrocompatible avec la fonction X (i : Integer. ): Entier; Pascal; début Résultat := i * 2; fin;
privé:
//Private indique les autorisations de différenciation d'accès des éléments de la classe. Les éléments distingués par Private ne sont accessibles qu'au sein de cette classe.
procédure:
//La procédure est utilisée pour déclarer la procédure procédure. Indiquez simplement les paramètres et le nom spécifique de la procédure peut être lié ultérieurement.
programme:
//Le mot-clé Programme est utilisé pour indiquer qu'un projet est une application. Le fichier exe est généré après la compilation de la bibliothèque de contrôle et le programme peut être exécuté directement Project1;utilise Forms, Unit1 dans 'Unit1.pas';{$R *.res}début Application.Initialize ; Application.CreateForm(TForm1, Form1);end.propriété:
// Le mot-clé de la propriété est utilisé pour déclarer les propriétés. : INTERGEMENT; Valeur de la propriété publiée: Integer Read Fvalue Write FValue; (Expéditeur: tobject) de l'objet;
protégé:
// Protégé indique les autorisations d'accès des éléments au sein de la classe.
publique:
// Le public indique que les autorisations d'accès des éléments au sein de la classe.
Publié:
// Publié indique les autorisations d'accès des éléments au sein de la classe. Vue d'objets.
augmenter:
// L'instruction RISE est utilisée pour lancer des exceptions. : String; commencez si i <0 augmente alors exception.create ('Integer ne peut pas plus petit que 0'); StrToint (s); sauf sur e: exception, soulève une exception.Create (e.Message); fin;lire:
// Lecture est utilisée pour identifier le membre ou la méthode utilisée pour lire la propriété.
Readonly:
// Le mot-clé ReadOnly est utilisé pour identifier si un objet est en lecture seule.PropertyReadonly; // Lorsque ReadOnly est défini sur true, les utilisateurs ne sont pas autorisés à modifier manuellement les propriétés et ne peuvent fonctionner que via d'autres objets.
enregistrer:
// Le mot-clé d'enregistrement est utilisé pour déclarer un enregistrement de structure. ; fin ;
registre:
// Registre marque le protocole d'appel de fonction, indiquant que la fonction peut laisser un enregistrement dans le registre lorsqu'il est appelé. Registre des contrôles ou des outils d'experts avec la bibliothèque de contrôle ou IDE.
réintroduire:
// Réintroduction est utilisée pour republier des méthodes, généralement lors de l'héritage. Méthodes virtuelles ou dynamiques, vous pouvez utiliser directement le remplacement. Entier);
répéter:
// Le mot-clé répété est utilisé pour introduire la structure de la boucle de répétition. sum: = sum + i; inc (i); jusqu'à (i> = 100);
Exige:
// Le mot-clé nécessite les conditions nécessaires pour compiler le package.
Ressourcestring:
// Resourcestring est utilisé pour déclarer les chaînes de ressources, qui peuvent être utilisées dans la structure déclarée. «Borland Rocks»;
Safecall:
// SafeCall est un type d'accord d'appel de fonction, qui stipule les règles que les fonctions appelées par com doivent respecter. ;
ensemble:
// Le mot clé est utilisé pour déclarer une classe de collecte, qui permet l'utilisation d'opérateurs de sets, tels que dans, etc. Type TCOL = (CA, CB, CC); Pendant le fonctionnement pour ajouter ou supprimer un élément de collection var cols: tcols; begin cols: = Cols + [Ca, CB]; end;
SHL:
// SHL signifie se déplacer vers la gauche.
SHR:
// SHR signifie se déplacer vers la droite.
stdcall:
// STDCALL est un type d'accord d'appel de fonction, qui stimule les règles qui peuvent être appelées par un programme. Fonction d'appel Callee: Demo de la bibliothèque; Entier): entier;
stocké:
// stocké est utilisé pour indiquer si la valeur d'une propriété peut être conservée.
chaîne:
// String est un type de données, qui représente un string.var str: string;
alors:
// Le mot-clé est alors utilisé dans l'instruction if. ); fin;
ThreadVar:
// ThreadVar identifie une variable créée lorsque le thread démarre. ''; // s: = ''; c'est-à-dire la mémoire occupée par la variable S.
à:
// Le mot-clé est utilisé dans l'instruction FOR pour indiquer que la variable de boucle est incrémentée. Utilisé pour incrémenter les mots variables de boucle, utilisez le mot-clé Downto pour décrémenter.
essayer:
// L'instruction TRY est utilisée pour la gestion des exceptions.
taper:
// Le mot-clé est utilisé pour déclarer divers objets. CA, CB, CC);
unité:
// L'unité identifie le début de l'unité. début.
jusqu'à:
// Le mot clé est utilisé pour déterminer la condition de boucle de la structure de la boucle de répétition. = sum + i; Inc (i); jusqu'à (i> = 100);
Utilisations:
// use est utilisé pour référencer une unité externe et peut utiliser les parties publiques de l'unité.
var:
// Le mot-clé VAR est utilisé pour déclarer une variable ou un objet, et la variable déclarée avec VAR est passé par valeur. (var i: entier): entier; // Le paramètre I dans la fonction ci-dessus est passé par référence, sa valeur peut être modifiée lorsque la fonction est exécutée et renvoyée à la fonction d'appel.
Varargs:
// Varargs identifie le paramètre de référence, qui doit être utilisé conjointement avec le mot-clé CDECL, indiquant que la fonction appelée est autorisée par référence. Le code provient de la bibliothèque de classe C ++ La fonction printf est référencée et les paramètres peuvent être transmis par référence.
virtuel:
// Virtual est utilisé pour déclarer une méthode virtuelle.
alors que:
// Bien que les mots-clés soient utilisés pour introduire l'instruction While Loop. Inc (i); fin;
avec:
// avec un mot-clé est utilisé pour collecter les mêmes objets pour le traitement. Ajouter ('def'); Il semble très redondant de copier du contenu dans le code du presse-papiers: form1.memo1.lines.clear; form1.memo1.lines.append ('ABC'); form1.memo1.lines.append ('def'); form1.memo1. Lines.savetofile ('c: /demo.txt');écrire:
// Écriture est utilisé pour identifier le membre ou la méthode utilisée pour écrire dans la propriété.
WriteOnly:
// Le mot clé WriteOnly est utilisé pour identifier si un objet est écrite-seul.property writeOnly; // Lorsque WriteOnly est défini sur true, les utilisateurs ne sont pas autorisés à lire les propriétés et ne peuvent fonctionner que via d'autres objets.
Xor:
// XOR est utilisé pour l'exclusion ou. a xor b alors writeln ('a xor b') else writeln ('a not xor b'); end; // xor est également utilisé pour calculer l'exclusivité ou la valeur writeln (intToStr (3 xor 5));