In diesem Artikel werden die Namen und die Verwendung verschiedener Schlüsselwörter, die in Delphi häufig verwendet werden, als Referenz im Programmierprozess ausführlich vorgestellt. Einzelheiten sind wie folgt:
Absolute:
//Es ermöglicht Ihnen, eine neue Variable zu erstellen, und die Startadresse der Variablen ist dieselbe wie bei einer anderen Variablen.var Str: string[32]; StrLen: Byte absoluteStr;//Diese Deklaration gibt die Startadresse der Variablen StrLen an und Str Gleich.//Da die 0. Position der Zeichenfolge die Länge der Zeichenfolge speichert, ist der Wert von StrLen die Länge der Zeichenfolge.beginStr := 'abc';Edit1.Text := IntToStr(StrLen);end;
Abstrakt:
//Es ermöglicht Ihnen, abstrakte Methoden zu erstellen, einschließlich Klassen mit abstrakten Methoden, die als abstrakte Klassen bezeichnet werden. //Abstract-Schlüsselwörter müssen zusammen mit virtuellen oder dynamischen Schlüsselwörtern verwendet werden, da abstrakte Methoden nicht instanziiert werden können, abstrakte Methoden nicht Enthalten Sie Methodenkörper.
Und:
//1. Logisches UND ausdrücken, wenn (a>0) und (b>0), dann//2. Bitoperation ausdrücken vara,b,c: Integer;beginc := (a and b);end;//Und verwenden Beim Ausdrücken von Logik müssen die Ausdrücke um „Und“ in Klammern gesetzt werden, um Konflikte zwischen Bedingungen zu vermeiden.//Zum Beispiel: wenn a>0 und b>0 dann//Der Compiler könnte es so verstehen: wenn a>( 0 und b) >0 dann//oder:wenn (a>0) und (b>0) dann//Aber beim tatsächlichen Kompilieren erzeugt der Compiler einen Konflikt und meldet einen Fehler.//Und der erste kann die Form von a>b>c enthalten, die in ist Delphi wird nicht unterstützt.//Sie müssen also Klammern verwenden, wenn Sie den And-Operator verwenden, um die linken und rechten Bedingungen zu unterscheiden.//Wenn Sie Bitoperationen ausdrücken, müssen Sie auch Klammern hinzufügen, um And und die linken und rechten Parameter einzuschließen.
Array:
//Array wird zur Darstellung von Arrays verwendet, und jedes Objekt kann als Array deklariert werden: //Statisches Array varArr1: Array [1..10] of Integer;//Dynamisches Array , weil Die Anzahl der Elemente ist zum Zeitpunkt der Deklaration nicht bekannt, daher muss die Größe des Arrays später mit der SetLength-Methode festgelegt werden. varArr2: array of Integer;//Wenn das Array als Parameter verwendet wird, wird die Größe des Arrays festgelegt Array kann nicht übergeben werden. Sie können nur den Array-Namen übergeben und dann die Längenmethode verwenden, um die Anzahl der Elemente in der Array-Funktion X(A: Array of Integer): Integer;vari: Integer;beginResult := 0;for i := 0 zu erhalten to Length(A)-1 doResult := Result + A[i];end;
als:
//As wird verwendet, um ein Objekt in ein anderes Objekt zu konvertieren. Prozedur BtnClick(Sender:TObject);begin (Sender as TButton).Caption := 'Clicked';end;//Für die Konvertierung der Objektfüllschnittstelle muss As sein used (HTTPRIO as IExp).GetConnection;//Da es nicht für die Datentypkonvertierung verwendet werden kann, ist der folgende Code falsch: vari: Integer;s: string;begins := (i as string);end;//Die richtige Schreibweise ist: s := string(i);
asm:
//Das Schlüsselwort Asm wird zum Einfügen von Assemblercode verwendet. Bei Verwendung von Assemblercode müssen Sie die Struktur asm...end; anstelle von begin...end;function verwenden. 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;
Assembler:
//Das Assembler-Schlüsselwort wird verwendet, um frühe Assemblys wie 80386 usw. zu unterstützen. //Der Unterschied zu Asm: Asm erlaubt Win32-Assemblys, während Assembler nur 80x86-Assemblys zulässt und die Invoke-Anweisungsfunktion IntToHex nicht zulässt (AValue: Int64): string assembler;
automatisiert:
//Automatisierter Zugriffsspezifizierer wird verwendet, um ein automatisch typisiertes Mitglied zu beschreiben, wodurch die Programmversion abwärtskompatibel gemacht werden kann //Mitglieder und ihre Instanzen in der ComObj-Einheit können keinen automatisierten Zugriffsspezifizierer verwenden. //In der nächsten Version des Programms wird Str geändert und wird zu typeTDemo = classautomatedStr: AnsiString;end//Die neue Version der Str-Variablen kann die alte Version der WideString-Typdaten akzeptieren. Und automatisch in AnsiString konvertiert. // Wenn in der tatsächlichen Entwicklung kein besonderer Bedarf besteht, wird das automatische Zugriffstrennzeichen im Allgemeinen nicht verwendet.
beginnen:
// Das Schlüsselwort begin wird verwendet, um den Anfang eines Programms oder einer Struktur anzuzeigen, und muss mit dem Schlüsselwort end beendet werden. Prozedur Sie müssen auch das Schlüsselwort begin verwenden, um den Startpunkt der Struktur für i:=1 zu markieren 100 dobeginsum := sum + i;if sum > 1000 then Break;end;
Fall:
//Case-Anweisung wird verwendet, um die bedingte Auswahl abzuschließen. Das ausgewählte Objekt der Case-Anweisung muss ein geordneter Typ sein, einschließlich Ganzzahltyp, Aufzählungstyp, Zeichentyp usw. //Case-Anweisung muss mit end beendet werden, wenn keine Übereinstimmung vorliegt Auswahlelement, sonst kann hinzugefügt werden, um eine allgemeine Auswahl zu treffen. Funktion GetDays(AYear,AMonth: Integer): Integer;begin case AMonth of 1,3,5,7,8,10,12: Ergebnis := 31; 4,6,9,11: Ergebnis := 30; begin if IsLeapYear(AYear) then Result:=29 else Result:=0;end;
cdecl:
//Cdecl ist eine Art Funktionsaufrufvereinbarung, die die Regeln festlegt, die beim Aufrufen von Funktionen aus einer in C oder C++ geschriebenen DLL befolgt werden müssen. //Es kann Datentypen in C oder C++ in Delphi konvertieren.//Zum Beispielcode in C++: int X(int i){ return i*2;}//Diese Funktion wird in Demo.dll kompiliert. Beim Aufruf mit Delphi müssen Sie verwenden: function 'Demo.dll';Klasse:
//Das Schlüsselwort Class wird zum Deklarieren oder Erben einer Klasse verwendet, oder die Klasse und die Schnittstelle können gleichzeitig geerbt werden //Darüber hinaus kann das Schlüsselwort Class auch zum Deklarieren allgemeiner Methoden einer Klasse verwendet werden, sodass die Die übergeordnete Klasse kann innerhalb der Klasse auf die Methoden der Unterklasse zugreifen. .type ClassDemo = class(TObject) private public constructiontor;//Wenn eine Methode mit der Klasse deklariert wird, kann die Methode sowohl in der Klasse als auch in der zugehörigen Klasse verwendet werden Klassen, zum Beispiel: typeClassA = classprivatepublicprocedure Y;end;typeClassB = class(ClassA)privatepublicclass aufzurufende Prozedurmethode.
const:
//Das Schlüsselwort Const wird zum Deklarieren von Konstanten verwendet. //Es kann auch zum Deklarieren von Funktionsparametern verwendet werden, die in der Funktion nicht geändert werden dürfen = 'Delphi ';const MyInteger = 100;//Wenn Sie eine Konstante mit Const deklarieren, müssen Sie ihren Datentyp nicht angeben. Das System ermittelt automatisch den Typ und nimmt automatische Anpassungen vor.//Sie können const verwenden, um unveränderlich zu deklarieren Parameter in einer Funktion Funktion X(const i: Integer): string;//Zu diesem Zeitpunkt kann der Wert von i während der Funktionsoperation nicht geändert werden.
Konstruktor:
//Das Schlüsselwort „constructor“ wird verwendet, um den Konstruktor einer Klasse zu deklarieren. //Der Konstruktor wird im Allgemeinen durch die CreateWnd-Methode dargestellt the class.type ClassDemo = class( TObject) private fValue: Integer; public Konstruktor Create;beginfValue := 0;end;
enthält:
// Das Schlüsselwort „Contains“ gibt an, ob ein Paket (Package) eine bestimmte Datei enthält. // Mit „Contains“ eingeführte Dateien müssen zur Paketdatei hinzugefügt werden, um den Verlust von Verweisen auf Schlüsseldateien zu vermeiden. enthält Db, DBLocal, DBXpress;end.
Standard:
//Das Schlüsselwort „Default“ wird verwendet, um den Standardwert einer Eigenschaft anzugeben. //Nur geordnete Typeigenschaften erlauben die Existenz von Standardwerten, andernfalls muss der Eigenschaftswert im Konstruktor initialisiert werden. Typ „ClassDemo = class private fValue: Integer; : Integer read fValue write fValue default 0; end;//Es kann auch auf die Standardeigenschaft einer Klasse verwiesen werden. Eigenschaft strings[Index: Integer]: string read GetString write PutString;
Destruktor:
//Destruktor wird verwendet, um den Destruktor zu identifizieren, der automatisch aufgerufen wird, wenn die Klasse freigegeben wird, und es ist keine Überladung zulässig. Der Destruktor verwendet normalerweise Destroy als Funktionsnamen class( TComponent) public destructor Destroy;override; end;//Da es auch eine Destroy-Methode in der TComponent-Klasse gibt, muss diese neu geschrieben werden//Wenn Sie den Destruktor jedoch überladen möchten, ist dies nicht zulässig ist falsch: Destruktor Zerstören; Überlastung;
dispid:
//Das Schlüsselwort DispId wird in der DispInterface-Schnittstelle verwendet, um eine bestimmte Adaptionsseriennummer anzugeben. //In der DispInterface-Schnittstelle muss die Adaptionsseriennummer eindeutig sein. //Wenn DispId nicht angegeben ist, weist das System die Adaption automatisch zu Jede Methode in der Schnittstelle erhält eine Seriennummer. //Sie können auf die Methoden in der DispInterface-Schnittstelle über den Anpassungsserientyp IStringsDisp = dispinterface zugreifen ['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}'] property ControlDefault[Index: Integer]: Olevariant dispid 0; default; function Count: Integer; property Item[Index: Integer]: Olevariant dispid 2; Remove(Index: Integer); procedure Clear; 4; function Add(Item: Olevariant): Integer; function _NewEnum: IUnknown;Dispatcherschnittstelle:
//DispInterface wird verwendet, um eine bestimmte Adapterschnittstelle zu deklarieren. //Die mit DispInterface deklarierte Schnittstelle kann nicht vererbt werden. //Die Methoden in DispInterface können nicht vererbt werden Wird aufgerufen und muss dynamisch gebunden werden. //Mit DispId können Sie der Schnittstelle eine Adaptionsseriennummer zuweisen. //DispInterface kann nur auf der Windows-Plattform verwendet werden. Dann wird dieses Schlüsselwort automatisch vom System blockiert. //Normalerweise wird DispInterface nicht verwendet. //Beispiele finden Sie unter DispId
div:
//Div wird verwendet, um den ganzzahligen Quotienten zweier Zahlen zu ermitteln. Die beiden in der Div-Operation verwendeten Werte müssen beide Ganzzahlen sein, var a, b, c: Integer; := 20; b := 3; c := a div b;
Tun:
//Das Schlüsselwort Do wird in For-, While-, On- und With-Anweisungen verwendet, um eine bestimmte Struktur zu bilden //For-Anweisung: for i := 1 bis 100 do sum:=sum+i;//While-Anweisung: while i < 100 dobegin sum := sum + i; Inc(i);end;//On-Anweisung (Ausnahmebehandlung):try i := StrToInt(s);außer bei Ausnahme do ShowMessage('Error!');end;//With Aussage :mit Memo1.Lines dobegin Clear; Append('abc');end;bis:
//Das Schlüsselwort DownTo wird in der For-Anweisung verwendet, um anzugeben, dass die Schleifenvariable for i := 100 auf 1 dekrementiert wird doListBox1.Items.Add(IntToStr(i));//In der For-Anweisung wird das Schlüsselwort To verwendet Um die Schleifenvariable zu erhöhen, verwenden Sie zum Dekrementieren das Schlüsselwort DownTo.
dynamisch:
//Dynamic wird verwendet, um eine dynamische Methode zu deklarieren. //Dynamische Methoden können überschrieben werden und die Codegröße so weit wie möglich reduzieren (im Gegensatz zu Virtual).procedure X(i: Integer);
anders:
//else wird verwendet, um die Laufrichtung des Programms zu steuern. Es kann in Verbindung mit If-, Case- und On-Anweisungen verwendet werden. Wenn die Bedingung nicht erfüllt ist, gehen Sie zur //If-Anweisung (in der If-Anweisung). , vor else sind keine Punkte erlaubt.):if a > b thenc := aelsec:=b;//Case-Anweisung: case-Tag Of1:Result:=1;2:Result:=2;3:Result:=3;elseResult:=0;end;//On-Anweisung (Ausnahmebehandlung):tryi := StrToInt(s);Excpeton EZeroDivide do Ergebnis: = 1;on EOverflow do Result := 2;elseResult := 0;end;
Ende:
//End wird verwendet, um einen Anweisungsblock oder eine Einheit zu beenden. //Es kann mit Anfang, Fall, Klasse, Schnittstelle, Asm, Einheit, Paket usw. übereinstimmen. //Bei Anweisungsblöcken (lokales Ende) muss End hinzugefügt werden Semikolon.//Für Einheiten oder Pakete (globales Ende) muss nach dem Ende ein Punkt hinzugefügt werden, bevor das Schlüsselwort else in der If-Anweisung beginnt Dann Button1.Caption := 'Hinted' else Button1.Caption := 'Not Hinted'; end;end;//Verwenden Sie End im Paket, um zu beenden: package DATAX;requiresrtl,clx;contains Db, DBLocal, DBXpress;end.
außer:
//Das Schlüsselwort „exclusive“ wird für die Ausnahmebehandlung verwendet und muss innerhalb der try-Anweisung verwendet werden. Wenn eine Ausnahme auftritt, wird die Anweisung nach „exclusive“ ausgeführt try i := StrToInt(s);exclusive ShowMessage('Error!');end;Export:
//Export gibt das Funktionsaufrufprotokoll an und gibt an, dass die exportierte Funktion lokal oder remote aufgerufen werden kann. //Andere Programme können Funktionen im Programm in Form einer DLL aufrufen Add( a,b: Integer): Integer; export;//Wenn dieses Programm als Demo.exe kompiliert ist und ein anderes Programm diese Funktion aufrufen muss, können Sie die folgende Anweisungsfunktion Add(a,b: Integer) verwenden: Ganzzahl; stdcall; extern 'Demo.exe';
Exporte:
//exports wird zur Ausgabe von Objekten verwendet. Es können mehrere Elemente gleichzeitig ausgegeben werden, getrennt durch Kommas :=IntToStr(i);end;exports X(i: Integer): string; overload; stdcall;begin Result := IntToStr(i);end;function X(s: string): Integer;end;exportsX (i: Integer) name 'x1',X(s: string) name 'x2';beginend.
extern:
//Das Schlüsselwort „External“ wird verwendet, um auf eine externe Methode oder Methode innerhalb von OBJ zu verweisen.{$L Demo.OBJ}procedure X(i:Integer);external;//Wenn von einer DLL oder einem externen Programm darauf verwiesen wird, kann es verwendet werden Der folgende Code: function A(FileName: string): string; external 'Demo.dll';//Wenn die referenzierte Funktion überladen ist, muss zusätzlich der referenzierte Name angegeben werden function A(Name: string): string; stdcall; external 'Demo.dll' name 'A1'; function A(Code: Integer): external 'Demo.dll' name 'A2';//Bei Verwendung des External-Schlüsselworts müssen Sie darauf achten auf den Fall achten, sonst kommt es zu einem Fehler.weit:
//Far gibt das Funktionsaufrufprotokoll an und gibt an, dass die Funktion remote aufgerufen werden kann. //Andere Programme können Funktionen im Programm in Form von DLL aufrufen. Es ist abwärtskompatibel. Far ;//Wenn dieses Programm in Demo.exe kompiliert wird und ein anderes Programm auf einem anderen Computer diese Funktion aufrufen muss, können Sie die folgende Anweisung verwenden: function Add(a,b: Integer): Integer external 'Demo.exe';
Datei:
//Das Schlüsselwort „File“ gibt den Dateioperationstyp an. Die Datei muss als „File“ deklariert werden. //Wenn Of und der Dateityp nach „File“ angehängt werden, kann die Datei so definiert werden, dass sie den angegebenen Datentyp liest und schreibt PName: string[ 32]; PAge: Integer;var PFile: Datei von TPerson;
Finalisierung:
//Das Schlüsselwort „finalization“ gibt die Methode an, die beim Freigeben der Einheit aufgerufen werden soll. //Es gibt normalerweise Objekte in der Einheit frei, die nicht automatisch freigegeben werden können. //Der am häufigsten verwendete Fall der Finalisierung ist „de“. -initialize OLE-Objekte. initialization ActiveX.OleInitialize(nil);finalization ActiveX.OleUninitialize;
Endlich:
// Das Schlüsselwort „final“ gibt die letzte Methode an, die bei der Ausnahmebehandlung aufgerufen werden muss. // Unabhängig davon, ob eine Ausnahme auftritt, wird die Anweisung nach „final“ immer am Ende der try-Anweisung ausgeführt .Text := Node.Text;finally Node := nil;end;
für:
//Das Schlüsselwort For führt zur For-Schleifenstruktur, die verwendet wird, um eine bestimmte Anzahl von Schleifen auszuführen for i := 1 bis 100 dosum := sum + i;//Wenn die Schleifenvariable dekrementiert wird, können Sie die verwenden DownTo-Schlüsselwort für i: = 100 downto 1 do Inc(sum);
nach vorne:
//Das Schlüsselwort Forward wird für die Vorwärtsdefinition von Methoden verwendet und die Methode später im Programm implementiert. //Dies ist für die Lesbarkeit des Codes von Vorteil, und alle Deklarationen können dann zusammengestellt werden Fügen Sie alle Implementierungen zusammen. Funktion X(i: Integer): Integer; forward;procedure Y(s: string forward;...function Y;beginWriteLn(s);end;// Vorab deklarierte Methoden weiterleiten, müssen bei der Implementierung nicht die Parameter und Rückgabewerte der Methode eingeben, sondern verwenden einfach den Methodennamen direkt.
Funktion:
//Funktion wird zum Deklarieren von Funktionen verwendet. function Für den Funktionsnamen müssen Sie nur die Parameter und den Rückgabetyp angeben. Der spezifische Funktionsname kann später gebunden werden.
gehe zu:
//Die Goto-Anweisung wird verwendet, um zu einer Zeilennummer zu springen, die zu jeder Position innerhalb der aktuellen Strukturebene springen kann. //Die Zeilennummer muss mit dem Schlüsselwort label bei der Deklaration angegeben werden. //Da die Goto-Anweisung zerstört wird Aufgrund der Struktur des Programms wird dies nicht empfohlen. .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;Wenn:
//Das Schlüsselwort If führt zur Bedingungsanweisung If, die zur Beurteilung der Bedingung verwendet wird.var a,b: Integer;begin a := 2; if a>b then WriteLn('a=' + IntToStr( a )) else WriteLn('b=' + IntToStr(b));end;//Die übliche Struktur der If-Anweisung ist If...Then...else, die else-Anweisung ist optional.//Wenn ja beliebig in der If-Anweisung Mehrere Unteranweisungen, Dann müssen Sie die begin...End-Struktur verwenden, um zu unterscheiden, ob a > b thenbegin WriteLn('a=' + IntToStr(a)); b) );Endelse WriteLn('b>a');Durchführung:
//Implementierung identifiziert den Implementierungsteil in der Einheit. Die Grundstruktur der Einheit ist ://Unit...Interface...implementation...end.//Der Funktionskörper, der Prozesskörper usw. müssen danach geschrieben werden das Implementierungsschlüsselwort./ /Wenn auf das Objekt nach der Implementierung verwiesen wird, ist das Objekt nicht öffentlich und kann nur von der Einheit selbst verwendet werden. Die Implementierung verwendet frmAbout;begin FormAbout.Show;end;//Eine vollständige Einheit muss eine Implementierung haben Teil.
implementiert:
//Implementiert, dass eine Eigenschaft von der Schnittstelle geerbt wird. //Dynamische Bindung von Eigenschaften über die Schnittstelle und dynamische Einstellung von Eigenschaftswerten. procedure P2; end; TMyImplclass = class(TInterfacedObject, IMyInterface) FMyImplClass: TMyImplclass read; FMyImplclass implementiert IMyInterface; procedure IMyInterface.P1; procedure MyP1;//Nach der Deklaration durch „implements“ können Sie auf die Entität der Methode in der Schnittstelle hinweisen, wie im obigen Beispiel: procedure IMyInterface. P1 = MyP1;
In:
//In wird verwendet, um zu bestimmen, ob ein Set ein Element enthält. Der zu bestimmende Inhalt muss ein einzelnes Set-Element und eine Instanz eines Sets vom Typ TCol = (cA,cB,cC) sein Cols: TCols;begin Cols := [cA,cB]; if cA in Cols then ShowMessage('cA in Cols') else ShowMessage('cA not in Cols');end;//In wird auch in Projektdateien verwendet, Wird verwendet, um zu identifizieren, ob eine Datei vom Projekt referenziert wird. //In kann in der For-Anweisung verwendet werden, um Elemente in einer Sammlung auszuschleifen. .. for s In sl do begin ShowMessage(s);end;Index:
//Index wird verwendet, um die Seriennummer im Attribut zu identifizieren, sodass dieselbe Attributmethode (Get, Set) zum Bedienen verschiedener Attribute verwendet werden kann. Typ TForm1 = class(TForm) private Funktion GetInfo(const Index: Integer): Longint ; procedure SetInfo (const Index: Integer; const Value: Longint); öffentliche Eigenschaft iLeft:Longint index 0 read GetInfo write SetInfo property iTop:Longint index 1 read GetInfo write SetInfo; property iWidth:Longint index 2 read GetInfo write SetInfo; property iHeight:Longint index 3 read GetInfo write SetInfo;function TForm1.GetInfo(const Index: Integer): Longint;begin case Index of 0: result := self.Left; 1: Ergebnis := self.Top; 2: Ergebnis := self.Width; := self.Height; end;end;//Das Schlüsselwort Index wird auch verwendet, um mehrere Elemente in Eigenschaften anzugeben, zum Beispiel: property Selected[Index: Integer]: Boolean read GetSelected write SetSelected;
geerbt:
//Inherited wird verwendet, um die Methode der übergeordneten Klasse aufzurufen.type TDemo = class(TComponent) public constructiontor Create(AOwner: TComponent); override;constructor TDemo.Create(AOwner: TComponent);begin inherited Create(AOwner);end ; //Wenn Sie eine Methode mit demselben Namen wie sie selbst aufrufen, können Sie den Methodennamen und die Parameter auch weglassen, z. B. im obigen Beispiel Create(AOwner);//kann geändert werden in:Inherited;
Initialisierung:
//Das Initialisierungsschlüsselwort identifiziert die Methode, die beim Laden der Einheit aufgerufen werden soll. //Es wird normalerweise zum Initialisieren einiger Objekte verwendet, die nicht automatisch initialisiert werden können, es ist jedoch nicht erforderlich, //Der am häufigsten verwendete Fall von Bei der Initialisierung werden OLE-Objekte initialisiert. OleInitialize(nil);finalization ActiveX.OleUninitialize;
im Einklang:
//Das InLine-Schlüsselwort wird in der Asm- oder Assembler-Struktur verwendet. //Es wird verwendet, um anzugeben, dass die Assembly-Anweisung abwärtskompatibel ist. Es hat keinen Einfluss auf die Kompilierung des Programms. function 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 ADD ESP, 16 POP ESIend;
Schnittstelle:
//Interface identifiziert den Schnittstellenteil in der Unit. Die Grundstruktur der Unit ist: //Unit...Interface...implementation...end.//Deklarationen von Funktionen, Prozeduren usw. müssen nach dem geschrieben werden Schnittstellenschlüsselwort./ /Wenn das Objekt nach der Schnittstelle referenziert wird, hat das Objekt keine Instanz und muss bei Verwendung instanziiert werden. Schnittstelle verwendet frmAbout;var FAbout: TFormAbout;begin FAbout := TFormAbout.Create(Self); FAbout.Show;end;//Eine vollständige Einheit muss einen Schnittstellenteil haben.//Schnittstelle kann auch als Deklaration einer Schnittstelle verwendet werden.type IMalloc = interface(IInterface) ['{00000002-0000-0000-C000-000000000046 }'] function Alloc(Size: Integer): Pointer; stdcall; function Realloc(P: Pointer; Size: Integer: Pointer; stdcall; function GetSize(P: Pointer): Integer;Ist:
//Is-Schlüsselwort wird zur Objektbeurteilung verwendet. In einigen Fällen kann es auch als „As“ verwendet werden.var Comp: TComponent;begin ... if Comp Is TEdit then (Comp as TEdit).Text := 'Edit ' ;Ende;
Etikett:
Das Schlüsselwort //label wird verwendet, um die Zeilennummernbezeichnung zu deklarieren, damit Goto zur Steuerung verwendet werden kann. Es wird nicht empfohlen, zu verwenden.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;Bibliothek:
//Das Schlüsselwort „Library“ gibt an, dass es sich bei einem Projekt um eine Klassenbibliothek handelt, die von anderen Programmen aufgerufen werden kann Name erledigt, InsertText Name Insert , DeleteSelection Name Delete, FormatSelection, PrintSelection Name Print, SetErrorHandler;begin InitLibrary;end.
Nachricht:
//Das Schlüsselwort Message wird verwendet, um Nachrichtenmethoden zu deklarieren. //Die Methode mit Message muss den Typ der empfangenen Nachricht angeben und die Nachricht per Referenz an die Methode übergeben.procedure Refresh(var Msg: TMessageRecordtype); Refresh(var Msg: TMessageRecordtype);beginif Chr(Msg.Code) = #13 then...elseinherited;end;//Benutzer können Nachrichten anpassen, Benutzerdefinierte Nachrichten können auch über Nachrichten- und Triggerereignisse empfangen werden.
Mod:
//Mod wird verwendet, um den ganzzahligen Modulus zweier Zahlen zu ermitteln, d. h. den Rest. Die beiden in der Mod-Operation verwendeten Werte müssen ganze Zahlen sein, und die Ergebnisse der Operationen müssen ebenfalls ganze Zahlen sein , b, c: Integer; b := 3;
Name:
// Das Schlüsselwort „Name“ wird verwendet, um den Alias einer Methode anzugeben. // Damit eine Methode extern referenziert werden kann, wird empfohlen, „Name“ als Methodenalias zu verwenden, um zu verhindern, dass externe Programme den Entitätsinhalt der Methode ändern. //Wenn die Methode von außen referenziert wird, muss sie durch Name function MessageBox(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer; external identifiziert werden .dll' Name 'MessageBoxA';
nahe:
//Near markiert das Funktionsaufrufprotokoll und zeigt an, dass die Funktion lokal aufgerufen werden kann. //Andere Programme können Funktionen im Programm in Form von DLL aufrufen. Funktion Add(a,b:Integer):Integer ; near;//Wenn dieses Programm in Demo.exe kompiliert wird und ein anderes lokales Programm diese Funktion aufrufen muss, können Sie die folgende Anweisung verwenden: function Add(a,b: Integer): Integer; 'Demo.exe';
Null:
//Nil wird verwendet, um einen Nullzeiger oder ein Objekt ohne Instanz darzustellen, während Node <> nil dobegin ListBox1.Items.Add(Node.Text);
Knotenfehler:
//Das NoDefault-Schlüsselwort gibt an, dass eine Eigenschaft keinen Standardwert zulässt, der normalerweise bei der Vererbung verwendet wird. Typ TClassA = class private fValue: Integer read fValue default 0; TClassA) veröffentlichte Eigenschaft Value:Integer read fValue write fValue nodefault;//Wie aus dem obigen Beispiel ersichtlich ist, hat Value in TClassA den Standardwert 0, //TClassB erbt TClassA, also erbt es auch seinen Standardwert. Verwenden Sie NoDefault, um den Standardwert hier zu entfernen.
nicht:
//Not wird zum Negieren verwendet, es negiert das ursprüngliche Ergebnis. Zum Beispiel: if a > b then//Es kann geschrieben werden als: if not (a < b) then//Das Schlüsselwort Not wird normalerweise zum Wechseln des Booleschen Werts verwendet Attributprozedur Button1Click (Sender: TObject);begin StatusBar1.Visible := not StatusBar1.Visible;end;
Objekt:
//Objekt wird zum Deklarieren eines Objekts verwendet und ist nur abwärtskompatibel. Die Methode zum Deklarieren eines Objekts ist dieselbe wie die Methode zum Deklarieren eines Typs object end; ODemoB = object(ODemoA) end;//Das Schlüsselwort Object wird auch zum Deklarieren dynamischer Funktionen oder Prozeduren verwendet, zum Beispiel: type TMyFun = function(i: Integer): Integer of Object(s: string ) von object;//Die durch das Objekt deklarierte Funktion oder Prozedur kann dynamisch an den angegebenen Funktionskörper oder an das Steuerereignis gebunden werden.
von:
//Of-Schlüssel wird verwendet, um eine angegebene Struktur mit anderen Schlüsselwörtern zu bilden. //Case-Anweisung: case Tag Of 0: Ergebnis := 'a'; : Ergebnis := 'b';end;//Klassenanweisung: Typ TDemo = Klasse von TComponent;//Array-Struktur: var MyInt: Array von Integer;//Dateistruktur: var MyFile: Datei von Byte;//Set-Anweisung: Typ TCol = (cA,cB,cC); TColls = Menge von TCol;//Objektstruktur: Typ MyFun = function(I: Integer): Integer of Object;
An:
Das Schlüsselwort //On wird für die Ausnahmebehandlung verwendet, um auf die aufgetretene Ausnahme hinzuweisen und Ausnahmeinformationen abzurufen.
oder:
//1. Logisch ausdrücken oder wenn (a>0) oder (b>0), dann//2 Beim Ausdrücken von Logik müssen die Ausdrücke um Or in Klammern gesetzt werden, um Konflikte mit Bedingungen zu vermeiden. //Wenn Sie Or in einer bedingten Anweisung verwenden, weiß der Editor nicht, was der Benutzer mit Or macht. Beispiel: if a>0 or b>0 then//Der Compiler kann es so verstehen: if a>(0 or b)>0 then//oder if (a>0) or (b>0) then//Aber beim tatsächlichen Kompilieren erzeugt der Compiler einen Konflikt , einen Fehler melden //Und der erste kann die Form a>b>c enthalten, die in Delphi nicht unterstützt wird //Sie müssen also Klammern verwenden, wenn Sie den Or-Operator verwenden, um die linken und rechten Bedingungen zu unterscheiden.//Gibt ein Bit an Operationen Klammern müssen auch hinzugefügt werden, wenn Schließen Sie Or und die linken und rechten Parameter ein.
aus:
//Das Schlüsselwort Out beschreibt die Ausgabemethode von Methodenparametern. //Verwenden Sie Out, um mehrere Ergebnisse in einer Funktion zurückzugeben. //Out gibt einen Wert zurück gibt Parameter zurück und var ist die Adresse eines Parameters, der direkt in die Prozedur eingegeben wird TForm1.Button1Click(Sender: TObject);var i: Integer; s: string;begin i := 20;end;
Überlast:
//Das Schlüsselwort Overload gibt die Methode zum Überladen an. //Aber die Anzahl, der Typ oder die Reihenfolge der Parameter sind unterschiedlich. Wenn diese Bedingung erfüllt ist, handelt es sich um eine Überladungsfunktion : Ganzzahl): string; Überladung;Funktion Die Anforderungen für die Überladung müssen erfüllt sein.Typ TDemo = class(TComponent) public procedure CreateWnd(AOwner: TWinControl); {Unterklassendeklaration}//Es gibt zwei CreateWnd-Methoden.//Wenn keine Überladung verwendet wird, kann die Methode der übergeordneten Klasse in der Unterklasse überschrieben werden.überschreiben:
//Override wird verwendet, um eine Methode in Form von Virtual oder Dynamic zu überschreiben. //Beim Überschreiben muss die Deklaration der überschriebenen Methode verwendet werden und die Parameter und der Rückgabetyp der ursprünglichen Methode dürfen nicht geändert werden Create(AOwner: TComponent);/Override wird hauptsächlich zur Vererbung verwendet, um die Methoden der übergeordneten Klasse zu überschreiben. //Wie im obigen Beispiel, Die der Unterklasse gehörenden Methoden sind: procedure Schlüsselwort wieder einführen.
Paket:
//Das Schlüsselwort Paket wird verwendet, um anzugeben, dass es sich bei einem Projekt um eine Steuerelementbibliothek handelt. //Die Steuerelementbibliothek generiert nach der Kompilierung eine BPL-Datei, die in der Delphi-Steuerelementbibliothek installiert werden kann, damit das Steuerelement in der zukünftigen Entwicklung des Pakets DATAX verwendet werden kann ; erfordert rtl, clx ; enthält MyUnit in 'C:/MyProject/MyUnit.pas';end.
verpackt:
//Packed-Schlüsselwort wird zum Packen von Strukturdatensätzen oder Arrays verwendet. Typ TPerson = gepackter Datensatz PName: Integer; PChar;
Pascal:
//Pascal markiert das Funktionsaufrufprotokoll, //weist darauf hin, dass die Funktion beim Aufruf Pascal folgt, d. h. alle Variablen zuerst initialisiert, //vermeidet Fehler, die durch asynchrone Thread-Aufrufe verursacht werden. Es ist abwärtskompatibel ): Integer; Pascal;begin Ergebnis := i * 2;end;
Privat:
//Private gibt die Zugriffsdifferenzierungsberechtigungen von Elementen innerhalb der Klasse an. Auf Elemente, die durch „Private“ gekennzeichnet sind, kann nur innerhalb dieser Klasse zugegriffen werden.
Verfahren:
//Prozedur wird verwendet, um eine Prozedur zu deklarieren procedure. Geben Sie einfach die Parameter an, und der spezifische Prozedurname kann später gebunden werden.
Programm:
// Das Schlüsselwort „Programm“ wird verwendet, um anzugeben, dass es sich bei einem Projekt um eine Anwendung handelt. Die EXE-Datei wird nach dem Kompilieren der Steuerbibliothek generiert und das Programm kann direkt ausgeführt werden. Project1;uses Forms, Unit1 in „Unit1.pas“;{$R *.res} begin application.initialize;Eigentum:
// Das Grundstückswort wird verwendet, um Eigenschaften zu deklarieren. : Integriert; (Absender: Tobject) des Objekts;
geschützt:
// Protected gibt die Zugriffsberechtigungen von Elementen innerhalb der Klasse an.
öffentlich:
// Public gibt die Zugriffsdifferenzierungsberechtigungen von Elementen innerhalb der Klasse an.
veröffentlicht:
// Veröffentlicht zeigt die Zugriffsberechtigungen von Elementen innerhalb der Klasse. Objektbieter.
erheben:
// Die Erhöhung der Erhöhung wird verwendet, um Ausnahmen zu veröffentlichen. : String; Beginnen Sie, wenn ich <0 dann ausnahme erhöht. Strtoint (s); außer bei e: Ausnahme erhöhen Ausnahme.Create (E.Message); Ende;
lesen:
// Read wird verwendet, um das Mitglied oder die Methode zu identifizieren, um die Eigenschaft zu lesen.
Readonly:
// Das Schlüsselwort Readonly wird verwendet, um festzustellen, ob ein Objekt nur schreibgeschützt ist.
aufzeichnen:
// Das Schlüsselwort Datensatz wird verwendet, um einen Strukturdatensatz zu deklarieren ; Ende ;
registrieren:
// Registrieren Sie die Funktionsaufrufe, in der die Funktion in der Registrierung aufgerufen wird, wenn sie aufgerufen wird. Registrieren Sie Kontrollen oder Experten -Tools in der Kontrollbibliothek oder IDE.Procedure Register;
Wiedereinführung:
// Wiedereinführung wird verwendet, um Methoden erneut zu veröffentlichen, normalerweise beim Erben. // für virtuelle oder dynamische Methoden können Sie überschreiben. Ganzzahl);
wiederholen:
// Das Wiederholungsschlüsselwort wird verwendet, um die Struktur der Wiederholungsschleife einzuführen sum: = sum + i;
erfordert:
// Erforderliche Schlüsselwort auf die erforderlichen Bedingungen für die Erstellung des Pakets.
Resourcestring:
// Resourcestring wird verwendet, um Ressourcen zu deklarieren, die in der deklarierten Struktur verwendet werden können 'Borland Rocks';
SafeCall:
// SafeCall ist eine Art von Funktionsanrufvereinbarung, die die von COM genannten Regeln festlegt. ;
Satz:
// Set -Keyword wird verwendet, um eine Sammelklasse zu deklarieren, die die Verwendung von Set -Operatoren wie in usw. ermöglicht. Typ TCOL = (CA, CB, CC); während des Betriebs ein Sammlungselement var cols hinzufügen oder löschen: tcols; beginnen cols: = cols + [ca, cb]; Ende;
SHL:
// SHL bedeutet nach links.
SHR:
// SHN bedeutet, nach rechts zu wechseln.
stdcall:
// stdcall ist eine Art von Funktionsanrufvereinbarung, die die Regeln festlegt, die von einem Programm aufgerufen werden können Callee -Aufruffunktion: Bibliotheksfunktion X (I: Ganzzahl): Integer; Ganzzahl): Integer;
gelagert:
// gespeichert wird verwendet, um anzugeben, ob der Wert einer Eigenschaft beibehalten werden kann.
String:
// String ist ein Datentyp, der eine Zeichenfolge darstellt.
Dann:
// dann wird das Schlüsselwort in der IF -Anweisung verwendet. ); Ende;
Threadvar:
// Threadvar identifiziert eine Variable, die beim Starten des Threads erstellt wurde. ''; // s: = '';
Zu:
// zu Schlüsselwort wird in der Anweisung verwendet, um anzuzeigen, dass die Schleifenvariable inkrementiert ist. Verwendet, um die Wörter der Schleifenvariablen zu erhöhen, verwenden Sie das Down -to -Keyword, um abzubauen.
versuchen:
// Die Ausnahmeanweisung wird für Ausnahmeberechnungen verwendet.
Typ:
// Schlüsselwort verwendet, um verschiedene Objekte zu deklarieren. CA, CB, CC);
Einheit:
// Einheit identifiziert den Beginn der Einheit. Anfang.
bis:
// Das Schlüsselwort wird verwendet, um die Schleifenbedingung der Struktur der Wiederholungsschleife zu bestimmen. = sum + i;
Verwendungen:
// verwendet eine externe Einheit und kann die öffentlichen Teile der Einheit verwenden.
var:
// Das VAR -Schlüsselwort wird verwendet, um eine Variable oder ein Objekt zu deklarieren, und die mit VAR deklarierte Variable wird von Wert übergeben. (VAR I: Ganzzahl): Ganzzahl; // Der Parameter I in der obigen Funktion wird mit Referenz übergeben, sein Wert kann geändert werden, wenn die Funktion ausgeführt wird, und zur Aufruffunktion zurückgegeben werden.
Varargs:
// Varargs identifiziert den Referenzparameter, der in Verbindung mit dem CDEC -Schlüsselwort verwendet werden muss, was angibt, dass die aufgerufene Funktion mit Referenz übergeben werden darf Der Code stammt aus der C ++ - Klassenbibliothek Die Printf -Funktion wird referenziert und die Parameter dürfen durch Referenz übergeben werden.
virtuell:
// Virtual wird verwendet, um eine virtuelle Methode zu deklarieren.
während:
// Das Schlüsselwort wird zur Einführung der Schleife vor der Schleife verwendet. Inc (i); Ende;
mit:
// mit dem Schlüsselwort verwendet, um die gleichen Objekte für die Verarbeitung zu sammeln. Append ('def'); Es erscheint sehr überflüssig, den Inhalt in den Zwischenablementcode zu kopieren: Form1.Memo1.lines.clear; Form1.Memo1.lines.Append ('ABC'); Form1.Memo1.lines.Append ('def'); Form1.Memo1. Line.savetofile ('c: /demo.txt');schreiben:
// Schreiben wird verwendet, um das Mitglied oder die Methode zu identifizieren, die in der Eigenschaft geschrieben wurde.
writeonly:
// Das Schlüsselwort WriteOnly wird verwendet, um festzustellen, ob ein Objekt nur schriftlich geschrieben ist.
xor:
// XOR wird für exklusive ORE verwendet A XOR B WRITELN ('A XOR B') ENDE SCHREIBEN ('A NOT XOR B');