บทความนี้จะแนะนำรายละเอียดเกี่ยวกับชื่อและการใช้คำหลักต่างๆ ที่ใช้กันทั่วไปใน Delphi สำหรับการอ้างอิงในกระบวนการเขียนโปรแกรม รายละเอียดมีดังนี้:
แน่นอน：
//มันช่วยให้คุณสร้างตัวแปรใหม่และที่อยู่เริ่มต้นของตัวแปรจะเหมือนกับตัวแปรอื่นvar Str: string[32]; StrLen: Byte AbsoluteStr;//การประกาศนี้ระบุที่อยู่เริ่มต้นของตัวแปร StrLen และ Str Same.//เนื่องจากตำแหน่งที่ 0 ของสตริงเก็บความยาวของสตริง ค่าของ StrLen คือความยาวของ string.beginStr := 'abc';Edit1.Text := IntToStr(StrLen);end;
เชิงนามธรรม:
// อนุญาตให้คุณสร้างเมธอดนามธรรม รวมถึงคลาสที่มีเมธอดนามธรรมที่เรียกว่าคลาสนามธรรม // คีย์เวิร์ดเชิงนามธรรมจะต้องใช้ร่วมกับคีย์เวิร์ดเสมือนหรือไดนามิก เนื่องจากเมธอดนามธรรมจะต้องถูกแทนที่ // คลาสนามธรรมไม่สามารถสร้างอินสแตนซ์ได้ แต่เมธอดนามธรรมไม่สามารถทำได้ มีเนื้อหาวิธี TDemo = คลาสตัวสร้างแบบส่วนตัวทำลาย;
และ:
//1. แสดงตรรกะ AND ถ้า (a>0) และ (b>0) แล้ว//2. แสดงการดำเนินการบิต vara,b,c: Integer;beginc := (a และ b);end;//Use And ในการแสดงตรรกะ นิพจน์ที่อยู่รอบๆ และ ต้องอยู่ในวงเล็บเพื่อหลีกเลี่ยงความขัดแย้งของเงื่อนไข//ตัวอย่าง: ถ้า a>0 และ b>0 แล้ว//คอมไพเลอร์อาจเข้าใจว่าเป็น: ถ้า a>( 0 และ b) >0 แล้ว//หรือ:ถ้า (a>0) และ (b>0) แล้ว//แต่เมื่อทำการคอมไพล์จริง ๆ คอมไพลเลอร์จะสร้างข้อขัดแย้งและรายงานข้อผิดพลาด//และอันแรกอาจมีรูปแบบ a>b>c ซึ่งอยู่ใน ไม่รองรับ Delphi//ต้องใช้วงเล็บเมื่อใช้ตัวดำเนินการ And เพื่อแยกเงื่อนไขซ้ายและขวา//เมื่อแสดงการดำเนินการบิต จะต้องเพิ่มวงเล็บเพื่อล้อมรอบพารามิเตอร์ And และพารามิเตอร์ซ้ายและขวาด้วย
อาร์เรย์:
//อาร์เรย์ถูกใช้เพื่อแสดงอาร์เรย์ และวัตถุใดๆ ก็สามารถประกาศเป็นอาร์เรย์ได้ อาร์เรย์แบ่งออกเป็นสองประเภท: คงที่และไดนามิก //อาร์เรย์แบบคงที่ varArr1: อาร์เรย์ [1..10] ของจำนวนเต็ม//อาร์เรย์แบบไดนามิก เนื่องจากไม่ทราบจำนวนองค์ประกอบ ณ เวลาที่ประกาศ ดังนั้นจึงต้องตั้งค่าขนาดของอาร์เรย์ในภายหลังโดยใช้วิธี SetLength varArr2: อาร์เรย์ของจำนวนเต็ม // เมื่อใช้อาร์เรย์เป็นพารามิเตอร์ ขนาดของ ไม่สามารถส่งผ่านอาร์เรย์ได้ คุณสามารถส่งผ่านชื่ออาร์เรย์ได้เท่านั้น จากนั้นใช้วิธีความยาวเพื่อรับจำนวนองค์ประกอบในฟังก์ชันอาร์เรย์ X(A: array of Integer): Integer;vari: Integer;beginResult := 0;for i := 0 ถึงความยาว(A)-1 doResult := ผลลัพธ์ + A[i];end;
เช่น:
//ตามที่ใช้ในการแปลงวัตถุหนึ่งเป็นขั้นตอนวัตถุอื่น BtnClick(Sender:TObject);begin (Sender as TButton).Caption := 'Clicked';end;//สำหรับการแปลงอินเทอร์เฟซการเติมวัตถุ ตามที่ต้องเป็น ใช้ (HTTPRIO เป็น IExp).GetConnection;//เนื่องจากไม่สามารถใช้สำหรับการแปลงชนิดข้อมูล รหัสต่อไปนี้จึงผิด: vari: Integer;s: string;begins := (i as string);end;//วิธีเขียนที่ถูกต้องคือ: s := string(i);
asm:
//คีย์เวิร์ด Asm ใช้เพื่อแทรกโค้ดแอสเซมบลี เมื่อใช้โค้ดแอสเซมบลี คุณต้องใช้โครงสร้าง asm...end; แทน beginning...end;function IntToHex(Value: Integer; Digits: Integer): string; asm CMP EDX, 32 JBE @A1 xor EDX, EDX @A1: PUSH ESI MOV ESI, ESP SUB ESP, 32 PUSH ECX MOV ECX, 16 CALL CvtInt MOV EDX, ESI POP EAX CALL System.@LStrFromPCharLen เพิ่ม ESP, 32 POP ESIend;
ผู้ประกอบ:
//คำสำคัญ Assembler ใช้เพื่อรองรับการประกอบในยุคแรกๆ เช่น 80386 เป็นต้น //ความแตกต่างระหว่างมันกับ Asm: Asm อนุญาตการประกอบ Win32 ในขณะที่ Assembler อนุญาตเฉพาะการประกอบ 80x86 และไม่อนุญาตให้ใช้คำสั่ง IntToHex (AValue: Int64): แอสเซมเบลอร์;
อัตโนมัติ:
//ตัวระบุการเข้าถึงอัตโนมัติใช้เพื่ออธิบายสมาชิกที่พิมพ์โดยอัตโนมัติ ซึ่งสามารถทำให้เวอร์ชันของโปรแกรมเข้ากันได้แบบย้อนหลัง //สมาชิกและอินสแตนซ์ในหน่วย ComObj ไม่สามารถใช้ Automated access specifier.type TDemo = คลาสอัตโนมัติ Str:WideString end; //ในเวอร์ชันถัดไปของโปรแกรม Str ได้รับการแก้ไขและกลายเป็น typeTDemo = classautomatedStr: AnsiString;end//ตัวแปร Str เวอร์ชันใหม่สามารถรับข้อมูลประเภท WideString เวอร์ชันเก่าได้ และแปลงเป็น AnsiString โดยอัตโนมัติ//ในการพัฒนาจริง หากไม่มีความจำเป็นพิเศษ โดยทั่วไปจะไม่ใช้ตัวแยกการเข้าถึงอัตโนมัติ
เริ่ม:
//คีย์เวิร์ด start ใช้เพื่อระบุจุดเริ่มต้นของโปรแกรมหรือโครงสร้าง และต้องลงท้ายด้วยคีย์เวิร์ด end ขั้นตอน คุณต้องใช้คีย์เวิร์ด start เพื่อทำเครื่องหมายจุดเริ่มต้นของโครงสร้างสำหรับ i:=1 ถึง 100 dobeginsum := sum + i;if sum > 1,000 แล้ว Break;end;
กรณี:
//คำสั่ง Case ใช้ในการเลือกเงื่อนไขให้เสร็จสิ้น ออบเจ็กต์ที่เลือกของคำสั่ง Case จะต้องเป็นประเภทที่เรียงลำดับ รวมถึงประเภทจำนวนเต็ม ประเภทการแจงนับ ประเภทอักขระ ฯลฯ //คำสั่ง Case จะต้องลงท้ายด้วยจุดสิ้นสุด หากไม่มีการจับคู่ รายการที่เลือก สามารถเพิ่มตัวเลือกทั่วไปได้ ฟังก์ชัน GetDays(AYear,AMonth: Integer): Integer;begin case AMonth of 1,3,5,7,8,10,12: Result := 31; 4,6,9,11: ผลลัพธ์ := 30; 2: เริ่มต้น ถ้า IsLeapYear(AEar) แล้ว ผลลัพธ์:=29 อื่น ๆ :=28; สิ้นสุด;
คำสั่ง:
//Cdecl เป็นข้อตกลงการเรียกใช้ฟังก์ชันประเภทหนึ่ง ซึ่งกำหนดกฎที่ต้องปฏิบัติตามเมื่อเรียกใช้ฟังก์ชันจาก DLL ที่เขียนด้วยภาษา C หรือ C++ //สามารถแปลงประเภทข้อมูลใน C หรือ C++ เป็น Delphi//สำหรับโค้ดตัวอย่าง ใน C++: int X(int i){ return i*2;}//ฟังก์ชันนี้ถูกคอมไพล์ใน Demo.dll เมื่อโทรด้วย Delphi คุณต้องใช้: function 'Demo.dll';ระดับ:
//คีย์เวิร์ด Class ใช้ในการประกาศหรือสืบทอดคลาส หรือคลาสและอินเทอร์เฟซสามารถสืบทอดพร้อมกันได้ // นอกจากนี้ คีย์เวิร์ด Class ยังสามารถใช้เพื่อประกาศวิธีการทั่วไปของคลาสเพื่อให้ คลาสพาเรนต์สามารถเข้าถึงเมธอดของคลาสย่อยจากภายในคลาส .type ClassDemo = class(TObject) ตัวสร้างสาธารณะส่วนตัว Create; end;//หากมีการประกาศเมธอดด้วยคลาส เมธอดนั้นสามารถใช้ได้ในคลาสและคลาสที่เกี่ยวข้อง ตัวอย่างเช่น: typeClassA = classprivatepublicprocedure Y;end;typeClassB = คลาส (ClassA) วิธีการเรียกขั้นตอนคลาสส่วนตัว
ค่าคอนสตรัค:
//คีย์เวิร์ด Const ใช้เพื่อประกาศค่าคงที่ ข้อมูลที่ประกาศโดยใช้ const ไม่สามารถเปลี่ยนแปลงได้ในโปรแกรม // นอกจากนี้ยังสามารถใช้เพื่อประกาศพารามิเตอร์ของฟังก์ชันได้ด้วย = 'Delphi ';const MyInteger = 100;//เมื่อประกาศค่าคงที่ด้วย Const คุณไม่จำเป็นต้องระบุประเภทข้อมูลโดยอัตโนมัติ ระบบจะกำหนดประเภทโดยอัตโนมัติและทำการปรับเปลี่ยนอัตโนมัติ//คุณสามารถใช้ const เพื่อประกาศว่าไม่สามารถเปลี่ยนแปลงได้ พารามิเตอร์ในฟังก์ชัน ฟังก์ชัน X(const i: จำนวนเต็ม): string;//ในขณะนี้ ค่า i ไม่สามารถเปลี่ยนแปลงได้ในระหว่างการทำงานของฟังก์ชัน
ตัวสร้าง:
// คีย์เวิร์ด Constructor ใช้เพื่อประกาศ Constructor ของคลาส เมื่อคลาสถูกสร้างอินสแตนซ์ ฟังก์ชันนี้จะถูกเรียกใช้ในครั้งแรก // โดยทั่วไป Constructor จะถูกแสดงโดยวิธี Create สามารถเชื่อมโยงกับเมธอด CreateWnd ที่มีอยู่ class.type ClassDemo = class( TObject) ส่วนตัว fValue: Integer; public Constructor Create; end;constructor ClassDemo.Create;beginfValue := 0;end;
ประกอบด้วย:
// คำสำคัญประกอบด้วยระบุว่าแพ็คเกจ (แพ็คเกจ) มีไฟล์บางไฟล์หรือไม่ // ต้องเพิ่มไฟล์ที่แนะนำไปยังไฟล์แพ็คเกจซึ่งสามารถหลีกเลี่ยงการสูญเสียการอ้างอิงไปยังไฟล์สำคัญ DATAX; มี Db, DBLocal, DBXpress;end
ค่าเริ่มต้น:
// คำหลักเริ่มต้นใช้เพื่อระบุค่าเริ่มต้นของคุณสมบัติ // เฉพาะคุณสมบัติประเภทที่สั่งเท่านั้นที่อนุญาตให้มีค่าเริ่มต้นได้ มิฉะนั้น ค่าคุณสมบัติจะต้องเริ่มต้นในตัวสร้างประเภท ClassDemo = คลาสส่วนตัว fValue: จำนวนเต็มคุณสมบัติที่เผยแพร่ : จำนวนเต็มอ่าน fValue เขียน fValue เริ่มต้น 0; // นอกจากนี้ยังสามารถชี้ให้เห็นคุณสมบัติเริ่มต้นของคุณสมบัติคลาส สตริง [ดัชนี: จำนวนเต็ม]: สตริงอ่าน GetString เขียน PutString ค่าเริ่มต้น;
ผู้ทำลายล้าง:
// Destructor ใช้เพื่อระบุ destructor ซึ่งจะถูกเรียกโดยอัตโนมัติเมื่อคลาสถูกปล่อยออกมา // Destructor ได้รับอนุญาตให้เขียนทับเท่านั้น และไม่อนุญาตให้มีการโอเวอร์โหลด โดยปกติแล้ว destructor จะใช้ Destroy เป็นชื่อฟังก์ชัน class( TComponent) public destructor Destroy;override; end;//เนื่องจากคลาส TComponent มีเมธอด Destroy จึงต้องเขียนใหม่//แต่ถ้าคุณต้องการโอเวอร์โหลด destructor จะไม่ได้รับอนุญาต รหัสต่อไปนี้ไม่ถูกต้อง : ตัวทำลาย ทำลาย;
เปิดเผย:
//คำสำคัญ DispId ถูกใช้ในอินเทอร์เฟซ DispInterface เพื่อระบุหมายเลขซีเรียลของการปรับเปลี่ยนเฉพาะ //ในอินเทอร์เฟซ DispInterface หมายเลขซีเรียลของการปรับเปลี่ยนจะต้องไม่ซ้ำกัน // หากไม่ได้ระบุ DispId ระบบจะกำหนดการปรับเปลี่ยนโดยอัตโนมัติ หมายเลขซีเรียลถูกกำหนดให้กับแต่ละวิธีในอินเทอร์เฟซ // คุณสามารถเข้าถึงวิธีการในอินเทอร์เฟซ DispInterface ผ่านหมายเลขซีเรียลการปรับตัว IStringsDisp = dispinterface ['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}'] คุณสมบัติ ControlDefault[Index: Integer]: Olevariant dispid 2; ลบ (ดัชนี: จำนวนเต็ม); dispid 4; ฟังก์ชั่น เพิ่ม (รายการ: Olevariant): จำนวนเต็ม dispid;อินเทอร์เฟซที่แตกต่าง:
//DispInterface ใช้เพื่อประกาศอินเทอร์เฟซของอะแดปเตอร์เฉพาะ อะแดปเตอร์นี้สามารถรับข้อมูลขาเข้าและขาออกในอินเทอร์เฟซระบบมาตรฐาน // อินเทอร์เฟซที่ประกาศด้วย DispInterface ไม่สามารถสืบทอดได้และสามารถอ้างอิงได้เท่านั้น // วิธีการใน DispInterface สามารถทำได้เท่านั้น เรียกว่าและต้องถูกผูกไว้แบบไดนามิก //คุณสามารถใช้ DispId เพื่อกำหนดหมายเลขซีเรียลการปรับตัวให้กับอินเทอร์เฟซ //DispInterface สามารถใช้ได้บนแพลตฟอร์ม Windows เท่านั้น จากนั้นคีย์เวิร์ดนี้จะถูกบล็อกโดยอัตโนมัติโดยระบบ //โดยปกติแล้ว DispInterface จะไม่ถูกใช้ //สำหรับตัวอย่าง โปรดดูที่ DispId
div:
//Div ใช้เพื่อค้นหาผลหารจำนวนเต็มของตัวเลขสองตัวที่ใช้ในการดำเนินการ Div ต้องเป็นจำนวนเต็มทั้งคู่ และผลลัพธ์ของการดำเนินการก็เป็นจำนวนเต็มด้วย var a, b, c: Integer; := 20; b := 3; c := div b;
ทำ:
//คีย์เวิร์ด Do ใช้ในคำสั่ง For, While, On, With เพื่อสร้างโครงสร้างเฉพาะ //สำหรับคำสั่ง: for i := 1 ถึง 100 do sum:=sum+i;//คำสั่ง While: while i < 100 dobegin sum := sum + i; Inc(i);end;//On คำสั่ง (การจัดการข้อยกเว้น):try i := StrToInt(s);ยกเว้นข้อยกเว้น ทำ ShowMessage('Error!');end;//With ข้อความ :กับ Memo1.Lines dobegin Clear; Append('abc'); ผนวก('123');end;ลงไป:
//คีย์เวิร์ด DownTo ถูกใช้ในคำสั่ง For เพื่อระบุว่าตัวแปรลูปลดลง for i := 100 เหลือ 1 doListBox1.Items.Add(IntToStr(i));//ในคำสั่ง For คีย์เวิร์ด To จะถูกใช้ ในการเพิ่มตัวแปรลูป ให้ใช้คีย์เวิร์ด DownTo เพื่อลดค่า
พลวัต:
//ไดนามิกใช้ในการประกาศวิธีการแบบไดนามิก //สามารถแทนที่วิธีการไดนามิกและสามารถลดขนาดโค้ดให้มากที่สุด (แตกต่างจากเสมือน) ขั้นตอน X(i: Integer);
อื่น:
//else ใช้เพื่อกำหนดทิศทางการทำงานของโปรแกรม โดยสามารถใช้ร่วมกับคำสั่ง If, Case และ On ได้ เมื่อไม่ตรงตามเงื่อนไข ให้ไปที่คำสั่ง else เพื่อรันคำสั่ง //If (ในคำสั่ง If ไม่อนุญาตให้ใช้คะแนนก่อนหน้า No.):if a > b thenc := aelsec:=b;//Case Statement: case Tag Of1:Result:=1;2:Result:=2;3:Result:=3;elseResult:=0;end;//คำสั่ง On (การจัดการข้อยกเว้น):tryi := StrToInt(s);Excpeton EZeroDivide ทำผลลัพธ์: = 1;บน EOverflow ทำผลลัพธ์ := 2;elseResult := 0;end;
จบ:
//End ใช้เพื่อสิ้นสุดบล็อกคำสั่งหรือหน่วย //สามารถจับคู่ start, Case, Class, Interface, Asm, Unit, Package ฯลฯ //สำหรับบล็อกคำสั่ง (จุดสิ้นสุดในเครื่อง) จะต้องเพิ่ม End หลัง อัฒภาค//สำหรับหน่วยหรือแพ็คเกจ (จุดสิ้นสุดทั่วโลก) ต้องเพิ่มจุดหลังจุดสิ้นสุด//ไม่อนุญาตให้ใช้สัญลักษณ์หลังสิ้นสุดก่อนคีย์เวิร์ด else ในคำสั่ง If ขึ้นต้นด้วย Button1 จะเริ่มต้นหาก Button1 แล้ว Button1.Caption := 'Hinted' else Button1.Caption := 'Not Hinted'; end;end;//ใช้ End ในแพ็คเกจเพื่อสิ้นสุด: แพ็คเกจ DATAX;requiresrtl,clx;contains Db, DBLocal, DBXpress;end.
ยกเว้น:
//คีย์เวิร์ดยกเว้นใช้สำหรับการจัดการข้อยกเว้นและต้องใช้ในคำสั่ง try หากมีข้อยกเว้นเกิดขึ้น คำสั่งหลังจากยกเว้นจะถูกดำเนินการ try i := StrToInt(s);ยกเว้น ShowMessage('Error!');end;ส่งออก:
// ส่งออก ระบุโปรโตคอลการเรียกใช้ฟังก์ชัน ซึ่งระบุว่าสามารถส่งออกฟังก์ชันได้ และฟังก์ชันที่ส่งออกสามารถเรียกใช้ในเครื่องหรือจากระยะไกลได้ // โปรแกรมอื่น ๆ สามารถเรียกใช้ฟังก์ชันในโปรแกรมในรูปแบบ dll ได้ เพิ่ม( a,b: จำนวนเต็ม): จำนวนเต็ม; ส่งออก;//หากโปรแกรมนี้ถูกคอมไพล์เป็น Demo.exe และโปรแกรมอื่นจำเป็นต้องเรียกใช้ฟังก์ชันนี้ คุณสามารถใช้ฟังก์ชันคำสั่งต่อไปนี้ เพิ่ม(a,b: จำนวนเต็ม): จำนวนเต็ม; stdcall ภายนอก 'Demo.exe';
การส่งออก:
//exports ถูกใช้เพื่อส่งออกวัตถุ ต้องใช้ระหว่างอินเทอร์เฟซและการใช้งาน สามารถส่งออกหลายรายการได้ในเวลาเดียวกัน โดยคั่นด้วยเครื่องหมายจุลภาค LibraryDemo;function X(i: Integer): string; :=IntToStr(i);end;ส่งออก X(i: Integer): string; overload; stdcall;begin Result := IntToStr(i);end;function X(s: string): โอเวอร์โหลด; (i: จำนวนเต็ม) ชื่อ 'x1',X(s: string) ชื่อ 'x2';beginend.
ภายนอก:
//คีย์เวิร์ดภายนอกใช้เพื่ออ้างอิงถึงภายนอกหรือวิธีการภายใน OBJ {$L Demo.OBJ}ขั้นตอน X(i:Integer);ภายนอก;//หากอ้างอิงจาก dll หรือโปรแกรมภายนอก ก็สามารถใช้ได้ รหัสต่อไปนี้: ฟังก์ชัน A(FileName: string): string; external 'Demo.dll';//หากฟังก์ชันที่อ้างอิงถูกโอเวอร์โหลด จะต้องระบุชื่อที่อ้างอิงเพิ่มเติม stdcall; ภายนอก 'Demo.dll' ชื่อ 'A1'; ฟังก์ชั่น A(รหัส: Integer): string; stdcall; ภายนอก 'Demo.dll' ชื่อ 'A2';//เมื่อใช้คำหลักภายนอก, คุณต้องใส่ใจ ในกรณีนี้ มิฉะนั้นจะเกิดข้อผิดพลาดขึ้นไกล:
//Far ระบุถึงโปรโตคอลการเรียกใช้ฟังก์ชัน ซึ่งระบุว่าสามารถเรียกใช้ฟังก์ชันจากระยะไกลได้ //โปรแกรมอื่นๆ สามารถเรียกใช้ฟังก์ชันในโปรแกรมในรูปแบบ dll ได้ ไกล ;//หากโปรแกรมนี้ถูกคอมไพล์ลงใน Demo.exe และโปรแกรมอื่นบนคอมพิวเตอร์เครื่องอื่นจำเป็นต้องเรียกใช้ฟังก์ชันนี้ คุณสามารถใช้คำสั่งต่อไปนี้: function Add(a,b: Integer): Integer; external 'Demo.exe';
ไฟล์:
//คีย์เวิร์ด File ระบุประเภทการทำงานของไฟล์ ต้องประกาศไฟล์เป็น File //หากเป็น Of และประเภทไฟล์ต่อท้าย File ไฟล์นั้นสามารถกำหนดให้อ่านและเขียนข้อมูลประเภทที่ระบุได้ ประเภท TPerson = record PName: สตริง [32]; PAge: จำนวนเต็ม; var PFile: ไฟล์ของ TPerson;
การสรุป:
//คีย์เวิร์ดการสรุปจะระบุวิธีการที่จะเรียกใช้เมื่อยูนิตถูกปล่อยออกมา //โดยปกติแล้วจะปล่อยออบเจ็กต์ในยูนิตที่ไม่สามารถรีลีสได้โดยอัตโนมัติ // กรณีที่ใช้บ่อยที่สุดของการสรุปคือ de -เตรียมใช้งานวัตถุ OLE การเริ่มต้น ActiveX.OleInitialize (ไม่มี); การสิ้นสุด ActiveX.OleUninitialize;
ในที่สุด:
// คีย์เวิร์ดสุดท้ายระบุวิธีการสุดท้ายที่ต้องถูกเรียกใช้ในการจัดการข้อยกเว้น // ไม่ว่าจะมีข้อยกเว้นเกิดขึ้นหรือไม่ก็ตาม คำสั่งหลังจากนั้นจะถูกดำเนินการที่ส่วนท้ายของคำสั่ง try เสมอ .Text := Node.Text;สุดท้าย Node := nil;end;
สำหรับ:
//คีย์เวิร์ด For นำไปสู่โครงสร้าง For loop ซึ่งใช้เพื่อดำเนินการตามจำนวนลูปที่ระบุ for i := 1 ถึง 100 dosum := sum + i;//หากตัวแปร loop ลดลง คุณสามารถใช้ คำหลัก DownTo สำหรับ i: = 100 ลงไป 1 do Inc(sum);
ซึ่งไปข้างหน้า:
//คีย์เวิร์ด Forward ใช้สำหรับการกำหนดวิธีการส่งต่อเท่านั้น จากนั้นจึงนำเมธอดไปใช้ในภายหลังในโปรแกรม รวมการใช้งานทั้งหมดเข้าด้วยกัน function X(i: Integer): Integer; forward;procedure Y(s: string); forward;...function X;begin Result := i * 2;end;procedure Y;beginWriteLn(s);end;//Forward วิธีการประกาศล่วงหน้า ไม่จำเป็นต้องป้อนพารามิเตอร์และส่งคืนค่าของวิธีการเมื่อใช้งาน เพียงใช้ชื่อวิธีการโดยตรง
การทำงาน:
//ฟังก์ชั่นใช้ในการประกาศฟังก์ชั่น ฟังก์ชั่น สำหรับชื่อฟังก์ชั่น คุณจะต้องระบุพารามิเตอร์และประเภทการส่งคืน ชื่อฟังก์ชั่นเฉพาะสามารถผูกไว้ได้ในภายหลัง
ไปที่:
//คำสั่ง Goto ใช้เพื่อข้ามไปยังหมายเลขบรรทัด ซึ่งสามารถข้ามไปยังตำแหน่งใดๆ ในเลเยอร์โครงสร้างปัจจุบันได้ //หมายเลขบรรทัดจะต้องถูกประกาศพร้อมกับคีย์เวิร์ดป้ายกำกับในการประกาศ //เนื่องจากคำสั่ง Goto จะทำลาย โครงสร้างของโปรแกรม ไม่แนะนำให้ใช้ .var a,b: Integer;label X,Y;begin if a > b goto X else goto Y;X: WriteLn('a > b'); Y: WriteLn('b > a');สิ้นสุด;ถ้า:
//If คีย์เวิร์ดนำไปสู่ If คำสั่งแบบมีเงื่อนไข ซึ่งใช้ในการตัดสิน Condition.var a,b: Integer;begin a := 2; b := 3; if a>b แล้ว WriteLn('a=' + IntToStr( a )) else WriteLn('b=' + IntToStr(b));end;//โครงสร้างปกติของคำสั่ง If คือ If...Then...else และคำสั่ง else เป็นทางเลือก//ถ้ามี มีค่าใดๆ ในคำสั่ง If หลายคำสั่งย่อย จากนั้น คุณต้องใช้โครงสร้าง beginning...End เพื่อแยกแยะ ถ้า a > b แล้วเริ่มต้น WriteLn('a>b'); WriteLn('a=' + IntToStr(a)); b) );Endelse WriteLn('b>a');การดำเนินการ:
//การนำไปปฏิบัติระบุส่วนของการนำไปปฏิบัติของหน่วย โครงสร้างพื้นฐานของหน่วยคือ: //Unit...Interface...implementation...end.//ส่วนเนื้อความของฟังก์ชัน, เนื้อความของกระบวนการ ฯลฯ จะต้องถูกเขียนหลังจาก คีย์เวิร์ดการใช้งาน/ /หากอ็อบเจ็กต์ถูกอ้างอิงหลังจากการนำไปใช้ อ็อบเจ็กต์นั้นไม่เป็นสาธารณะและสามารถใช้งานได้โดยหน่วยเท่านั้น การใช้งานนั้นใช้ frmAbout;begin FormAbout.Show;end;//หน่วยที่สมบูรณ์ต้องมีการใช้งาน ส่วนหนึ่ง.
ดำเนินการ:
// การดำเนินการชี้ให้เห็นว่าคุณสมบัติได้รับการสืบทอดจากอินเทอร์เฟซและคุณสมบัติถูกแปลงเป็นวัตถุอินเทอร์เฟซ // เชื่อมโยงคุณสมบัติแบบไดนามิกผ่านอินเทอร์เฟซและตั้งค่าคุณสมบัติแบบไดนามิก IMyInterface = ขั้นตอนอินเทอร์เฟซ P1; สิ้นสุด; TMyImplclass = ขั้นตอนคลาส P1; ขั้นตอน P2; สิ้นสุด; FMyImplclass ดำเนินการ IMyInterface; โพรซีเดอร์ IMyInterface.P1 = MyP1; โพรซีเดอร์ MyP1; end;// หลังจากการประกาศผ่านการดำเนินการ คุณสามารถชี้ให้เห็นเอนทิตีของวิธีการในอินเทอร์เฟซเมื่อมีการประกาศคลาส ดังตัวอย่างข้างต้น: โพรซีเดอร์ IMyInterface P1 = มายพี1;
ใน:
//In ใช้เพื่อตรวจสอบว่าชุดประกอบด้วยองค์ประกอบหรือไม่ เนื้อหาที่จะกำหนดต้องเป็นองค์ประกอบชุดเดียวและอินสแตนซ์ของชุด Cols: TCols;begin Cols := [cA,cB]; ถ้า cA ใน Cols แล้ว ShowMessage('cA in Cols') else ShowMessage('cA not in Cols');end;//In ยังใช้ในไฟล์โครงการ ใช้เพื่อระบุว่าไฟล์ถูกอ้างอิงโดยโปรเจ็กต์หรือไม่ ใช้ Unit1 ใน 'Unit1.pas'; //In สามารถใช้ในคำสั่ง For เพื่อวนซ้ำองค์ประกอบในคอลเลกชัน var s: string; .. สำหรับ s In sl จะเริ่มต้น ShowMessage สิ้นสุด; สิ้นสุด;ดัชนี:
//ดัชนีใช้เพื่อระบุหมายเลขซีเรียลในแอตทริบิวต์เพื่อให้สามารถใช้วิธีการแอตทริบิวต์เดียวกัน (รับ, ตั้งค่า) เพื่อดำเนินการแอตทริบิวต์ที่แตกต่างกันได้ ประเภท TForm1 = คลาส (TForm) ฟังก์ชันส่วนตัว GetInfo (const Index: Integer): Longint ; ขั้นตอน SetInfo (ดัชนี const: จำนวนเต็ม; ค่า const: Longint); ทรัพย์สินสาธารณะ iLeft: Longint ดัชนี 0 อ่าน GetInfo เขียน SetInfo; คุณสมบัติ iTop: Longint ดัชนี 1 อ่าน GetInfo เขียน SetInfo; คุณสมบัติ iWidth:Longint ดัชนี 2 อ่าน GetInfo เขียน SetInfo; คุณสมบัติ iHeight: Longint ดัชนี 3 อ่าน GetInfo เขียน SetInfo; end;function TForm1.GetInfo(const Index: Integer): Longint;begin case Index of 0: result := self.Left; 1: ผลลัพธ์ := self.Top; 2: ผลลัพธ์ := self.Width; := self.Height; end;end;//คีย์เวิร์ด Index ยังใช้เพื่อระบุองค์ประกอบหลายรายการในคุณสมบัติ เช่น: คุณสมบัติ Selected[Index: Integer]: Boolean read GetSelected write SetSelected;
สืบทอดมา:
//สืบทอดมาใช้เพื่อเรียกเมธอดของคลาสพาเรนต์ ประเภท TDemo = class(TComponent) ตัวสร้างสาธารณะ Create(AOwner: TComponent); end;constructor TDemo.Create(AOwner: TComponent);begin inherited Create(AOwner);end ; //หากคุณเรียกใช้เมธอดที่มีชื่อเดียวกับตัวเอง คุณสามารถละเว้นชื่อเมธอดและพารามิเตอร์ได้ ตัวอย่างเช่น ที่สืบทอดมาจากตัวอย่างข้างต้น สร้าง(AOwner);//สามารถเปลี่ยนเป็น:สืบทอด;
การเริ่มต้น:
// คีย์เวิร์ดการเริ่มต้นระบุวิธีการที่จะเรียกใช้เมื่อโหลดหน่วย // โดยทั่วไปจะใช้เพื่อเริ่มต้นวัตถุบางอย่างที่ไม่สามารถเริ่มต้นได้โดยอัตโนมัติ แต่ไม่จำเป็นต้องใช้ // กรณีที่ใช้บ่อยที่สุดของ การเริ่มต้นคือการเริ่มต้นวัตถุ OLE
อินไลน์:
// คำหลัก InLine ใช้ในโครงสร้าง Asm หรือแอสเซมเบลอร์ // ใช้เพื่อระบุว่าคำสั่งแอสเซมบลีเข้ากันได้ในระดับล่าง ไม่มีผลกระทบต่อการคอมไพล์ของฟังก์ชัน IntToStr (ค่า: จำนวนเต็ม): string; asm อินไลน์; 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 เพิ่ม ESP, 16 POP ESIend;
อินเตอร์เฟซ:
//อินเทอร์เฟซระบุส่วนอินเทอร์เฟซในหน่วย โครงสร้างพื้นฐานของหน่วยคือ: //Unit...Interface...implementation...end.//การประกาศฟังก์ชัน ขั้นตอน ฯลฯ จะต้องเขียนหลังจาก Interface keyword./ /หากอ็อบเจ็กต์ถูกอ้างอิงหลังจากอินเทอร์เฟส อ็อบเจ็กต์จะไม่มีอินสแตนซ์ และจะต้องถูกสร้างอินสแตนซ์เมื่อใช้ FAbout.Show;end;//หน่วยที่สมบูรณ์ต้องมีส่วนอินเทอร์เฟซ//อินเทอร์เฟซยังสามารถใช้เป็นการประกาศอินเทอร์เฟซได้ ประเภท IMalloc = interface(IInterface) ['{00000002-0000-0000-C000-000000000046 }'] ฟังก์ชัน Alloc(ขนาด: จำนวนเต็ม): ตัวชี้; stdcall; ฟังก์ชัน Realloc(P: ตัวชี้; ขนาด: จำนวนเต็ม): ตัวชี้ stdcall; ฟังก์ชัน DidAlloc (P: ตัวชี้);เป็น:
//Is คำหลักถูกใช้สำหรับการตัดสินวัตถุ ในบางกรณี ยังสามารถใช้เป็น "As".var Comp: TComponent;begin ... ถ้า Comp เป็น TEdit (Comp เป็น TEdit).Text := 'Edit ' ;จบ;
ฉลาก:
//label คีย์เวิร์ดใช้เพื่อประกาศป้ายหมายเลขบรรทัดเพื่อให้ Goto สามารถใช้บังคับทิศทางได้ ไม่แนะนำให้ใช้.var a,b: Integer;label X,Y;begin if a > b แล้วก็ goto X else goto Y;X: WriteLn( 'a>b');Y: WriteLn('b>a');สิ้นสุด;ห้องสมุด:
//Library คีย์เวิร์ดใช้เพื่อระบุว่าโปรเจ็กต์เป็นไลบรารีคลาส ไลบรารีคลาสสร้างไฟล์ DLL หลังจากการคอมไพล์ ซึ่งสามารถเรียกใช้โดยโปรแกรมแก้ไขไลบรารีอื่นได้ ใช้ EdInit, EdInOut, EdFormat, EdPrint; ชื่อเสร็จแล้ว ใส่ชื่อข้อความ ใส่ , DeleteSelection ชื่อ Delete, FormatSelection, PrintSelection ชื่อ Print, SetErrorHandler;begin InitLibrary;end.
ข้อความ:
// คีย์เวิร์ด Message ใช้เพื่อประกาศวิธีการส่งข้อความ // วิธีการที่มีข้อความจะต้องระบุประเภทของข้อความที่ได้รับและส่งข้อความไปยังวิธีการอ้างอิงสำหรับการประมวลผลขั้นตอนการรีเฟรช (var Msg: TMessageRecordtype); Refresh(var Msg: TMessageRecordtype);beginif Chr(Msg.Code) = #13 แล้ว...elseinherited;end;//ผู้ใช้สามารถปรับแต่งข้อความ, ข้อความที่กำหนดเองยังสามารถรับได้ทางข้อความและทริกเกอร์เหตุการณ์
สมัย:
//Mod ใช้ในการค้นหาโมดูลัสจำนวนเต็มของตัวเลขสองตัว นั่นคือ ส่วนที่เหลือ ค่าสองค่าที่ใช้ในการดำเนินการ Mod ต้องเป็นจำนวนเต็มทั้งคู่ และผลลัพธ์ของการดำเนินการต้องเป็นจำนวนเต็มด้วย , b, c: จำนวนเต็ม; เริ่มต้น a := 20; b := 3; c := a mod b;
ชื่อ:
//คีย์เวิร์ดชื่อใช้เพื่อระบุนามแฝงของวิธีการ //สำหรับวิธีการที่จะอ้างอิงภายนอก ขอแนะนำให้ใช้ชื่อเพื่อใช้สำหรับนามแฝงของวิธีการเพื่อป้องกันไม่ให้โปรแกรมภายนอกเปลี่ยนเนื้อหาเอนทิตีของวิธีการ //เมื่ออ้างอิงถึงวิธีการจากภายนอก ถ้าวิธีการนั้นมีนามแฝง จะต้องระบุด้วยฟังก์ชัน Name.Box(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer; external 'user32 .dll' ชื่อ 'MessageBoxA';
ใกล้:
// Near ทำเครื่องหมายโปรโตคอลการเรียกใช้ฟังก์ชัน ซึ่งระบุว่าสามารถเรียกใช้ฟังก์ชันในเครื่องได้ // โปรแกรมอื่นสามารถเรียกใช้ฟังก์ชันในโปรแกรมในรูปแบบของ dll ซึ่งเข้ากันได้แบบย้อนหลัง เพิ่ม (a, b: Integer): Integer ; near;//หากโปรแกรมนี้ถูกคอมไพล์ลงใน Demo.exe และโปรแกรมอื่น ๆ จำเป็นต้องเรียกใช้ฟังก์ชันนี้ คุณสามารถใช้คำสั่งต่อไปนี้: function Add(a,b: Integer): Integer; 'Demo.exe';
ไม่มี:
//ไม่มีใช้เพื่อแสดงตัวชี้ null หรือวัตถุที่ไม่มีอินสแตนซ์ ในขณะที่ Node <> ไม่มี dobegin ListBox1.Items.Add(Node.Text);
โหนดเริ่มต้น:
// คีย์เวิร์ด NoDefault ระบุว่าคุณสมบัติไม่อนุญาตให้ใช้ค่าเริ่มต้นซึ่งมักจะใช้ในการสืบทอดประเภท TClassA = คลาสส่วนตัว fValue: จำนวนเต็ม; ค่าคุณสมบัติที่เผยแพร่: จำนวนเต็มอ่าน fValue ค่าเริ่มต้น 0; TClassA ) คุณสมบัติที่เผยแพร่ Value:Integer read fValue write fValue nodefault; //ดังที่เห็นได้จากตัวอย่างข้างต้น Value ใน TClassA มีค่าเริ่มต้นเป็น 0 //TClassB สืบทอด TClassA ดังนั้นจึงสืบทอดค่าเริ่มต้นด้วย ใช้ NoDefault เพื่อลบค่าเริ่มต้นที่นี่
ไม่:
//Not ใช้สำหรับการปฏิเสธ มันจะลบล้างผลลัพธ์ดั้งเดิม ตัวอย่างเช่น: ถ้า a > b แล้ว//สามารถเขียนเป็น: ถ้าไม่ใช่ (a < b) แล้ว//คีย์เวิร์ด Not มักจะใช้เพื่อสลับบูลีน ขั้นตอนแอตทริบิวต์ Button1Click (ผู้ส่ง: TObject); เริ่มต้น StatusBar1.Visible := ไม่ใช่ StatusBar1.Visible; end;
วัตถุ:
//Object ถูกใช้เพื่อประกาศ object นี้ โดยพลการและเข้ากันได้กับ Object เท่านั้น //วิธีการประกาศ object นั้นเหมือนกับวิธีการประกาศ class ODemoA = ปลายวัตถุ ODemoB = วัตถุ (ODemoA) ปลาย // คำหลักวัตถุยังใช้ในการประกาศฟังก์ชันหรือขั้นตอนแบบไดนามิกเช่น: พิมพ์ TMyFun = ฟังก์ชัน (i: จำนวนเต็ม): จำนวนเต็มของวัตถุ TMyProc = ขั้นตอน (s: string ) ของ วัตถุ;//ฟังก์ชันหรือขั้นตอนที่ประกาศโดยวัตถุสามารถผูกแบบไดนามิกกับเนื้อหาของฟังก์ชันที่ระบุหรือผูกไว้กับเหตุการณ์การควบคุม
ของ:
//Of key ใช้เพื่อสร้างโครงสร้างที่ระบุด้วยคีย์เวิร์ดอื่นๆ Of สามารถใช้กับ Case, Class, Array, File, Set, Object. //Case คำสั่ง: case Tag Of 0: Result := 'a'; : ผลลัพธ์ := 'b';end;//คำสั่งคลาส: พิมพ์ TDemo = คลาสของ TComponent;//โครงสร้างอาร์เรย์: var MyInt: อาร์เรย์ของจำนวนเต็ม;//โครงสร้างไฟล์: var MyFile: ไฟล์ของ Byte;//คำสั่ง Set: พิมพ์ TCol = (cA,cB,cC); Tcols = ชุดของ TCol;//โครงสร้างวัตถุ: พิมพ์ MyFun = function(I: Integer): จำนวนเต็มของ Object;
บน:
//On คีย์เวิร์ดใช้สำหรับการจัดการข้อยกเว้น โดยชี้ให้เห็นข้อยกเว้นที่เกิดขึ้น และรับข้อมูลข้อยกเว้น ลอง i := StrToInt(s);ยกเว้น E: ข้อยกเว้น ทำ ShowMessage(E.Message);end;
หรือ:
//1. แสดงตรรกะหรือถ้า (a>0) หรือ (b>0) แล้ว//2. แสดงการดำเนินการบิต vara,b,c: Integer;beginc := (a หรือ b);end;//Use Or ในการแสดงตรรกะ นิพจน์ที่อยู่รอบๆ Or จะต้องอยู่ในวงเล็บเพื่อหลีกเลี่ยงความขัดแย้งกับเงื่อนไข //หากคุณใช้ Or ในคำสั่งแบบมีเงื่อนไข ตัวแก้ไขจะไม่ทราบว่าผู้ใช้กำลังทำอะไรกับ Or ตัวอย่างเช่น ถ้า a>0 หรือ ข>0 แล้ว//คอมไพลเลอร์อาจเข้าใจได้ว่า ถ้า a>(0 หรือ b)>0 แล้ว//หรือ ถ้า (a>0) หรือ (b>0) แล้ว//แต่เมื่อทำการคอมไพล์จริง ๆ แล้ว คอมไพเลอร์จะสร้างข้อขัดแย้งขึ้นมา รายงานข้อผิดพลาด //และอันแรกอาจมีรูปแบบ a>b>c ซึ่งไม่รองรับใน Delphi //ดังนั้นคุณต้องใช้วงเล็บเมื่อใช้ตัวดำเนินการ Or เพื่อแยกเงื่อนไขซ้ายและขวา//ระบุบิต วงเล็บการดำเนินการจะต้องเพิ่มเมื่อ แนบหรือและพารามิเตอร์ด้านซ้ายและขวา
ออก:
//คีย์เวิร์ด Out อธิบายวิธีการส่งออกของพารามิเตอร์เมธอด ฟังก์ชันทั่วไปสามารถมีค่าส่งคืนได้เพียงค่าเดียวเท่านั้น //ใช้ Out เพื่อส่งคืนผลลัพธ์หลายรายการในฟังก์ชันหนึ่งๆ ส่งคืนพารามิเตอร์ และ var คือที่อยู่ของพารามิเตอร์ที่ป้อนโดยตรง TForm1.Button1Click (ผู้ส่ง: TObject);var i: Integer; s: string;begin i := 20; s := 'xxx';
โอเวอร์โหลด:
// คีย์เวิร์ด Overload ระบุวิธีการที่ใช้สำหรับการโอเวอร์โหลด หมายความว่าชื่อวิธีการเหมือนกัน // แต่จำนวน ประเภท หรือลำดับของพารามิเตอร์ต่างกัน หากตรงตามเงื่อนไขนี้จะถือเป็นฟังก์ชัน X ( i: Integer): string; overload;function ต้องเป็นไปตามข้อกำหนดสำหรับการโอเวอร์โหลด ประเภท TDemo = คลาส (TComponent) ขั้นตอนสาธารณะ CreateWnd (AOwner: TWinControl); โอเวอร์โหลด; // ดังตัวอย่างข้างต้น วิธีการที่เป็นของคลาสย่อยคือ: ขั้นตอน CreateWnd; {สืบทอดมาจากคลาสหลัก} ขั้นตอน CreateWnd (AOwner: TWinControl); {การประกาศคลาสย่อย }//มีสองวิธี CreateWnd//หากไม่ได้ใช้การโอเวอร์โหลด วิธีการของคลาสพาเรนต์สามารถแทนที่ในคลาสย่อยได้แทนที่:
//Override ใช้เพื่อแทนที่เมธอดในรูปแบบ Virtual หรือ Dynamic //เมื่อทำการแทนที่ ต้องใช้การประกาศเมธอดที่ถูกแทนที่ และไม่อนุญาตให้แก้ไขพารามิเตอร์และประเภทการส่งคืนของวิธีการดั้งเดิม สร้าง (AOwner: TComponent); / Override ส่วนใหญ่จะใช้สำหรับคลาสย่อยเพื่อแทนที่เมธอดคลาสหลัก; //ดังตัวอย่างข้างต้น เมธอดที่เป็นของคลาสย่อยคือ: ขั้นตอน X; {แทนที่จากคลาสพาเรนต์}// วิธีการที่เป็นของคลาสพาเรนต์คือ: คำสั่งโพรซีเดอร์ // หรือหากจำเป็นต้องแก้ไขพารามิเตอร์ ก็จะต้องถูกแทนที่ด้วย แนะนำคีย์เวิร์ดอีกครั้งบรรจุุภัณฑ์:
//คีย์เวิร์ดของแพ็คเกจใช้เพื่อระบุว่าโปรเจ็กต์เป็นไลบรารีควบคุม//ไลบรารีควบคุมจะสร้างไฟล์ BPL หลังจากการคอมไพล์ ซึ่งสามารถติดตั้งลงในไลบรารีควบคุม Delphi เพื่อให้สามารถใช้การควบคุมในการพัฒนาแพ็คเกจ DATAX ในอนาคต ; ต้องใช้ rtl, clx ; มี MyUnit ใน 'C:/MyProject/MyUnit.pas';end
บรรจุ:
//Packed คีย์เวิร์ดใช้ในการแพ็กโครงสร้างเรคคอร์ดหรืออาร์เรย์ หลังจากแพ็กเก็ต ขนาดของออบเจ็กต์ที่แพ็กจะลดลงอย่างมาก พชาร์;
ปาสคาล:
//Pascal ทำเครื่องหมายโปรโตคอลการเรียกใช้ฟังก์ชัน //ชี้ให้เห็นว่าฟังก์ชันจะตามหลัง Pascal เมื่อทำการเรียก นั่นคือเตรียมใช้งานตัวแปรทั้งหมดก่อน //หลีกเลี่ยงข้อผิดพลาดที่เกิดจากการเรียกเธรดแบบอะซิงโครนัส ซึ่งเข้ากันได้กับฟังก์ชัน X แบบย้อนหลัง (i: Integer ): จำนวนเต็ม; Pascal;เริ่มต้นผลลัพธ์ := i * 2;end;
ส่วนตัว:
//ส่วนตัว ระบุถึงสิทธิ์ในการแบ่งแยกการเข้าถึงขององค์ประกอบภายในคลาสเท่านั้น
ขั้นตอน:
//ขั้นตอนใช้ในการประกาศขั้นตอน ขั้นตอน เพียงชี้ให้เห็นพารามิเตอร์และชื่อขั้นตอนเฉพาะสามารถผูกไว้ได้ในภายหลัง
โปรแกรม:
//คีย์เวิร์ดของโปรแกรมใช้เพื่อระบุว่าโปรเจ็กต์เป็นแอปพลิเคชัน ไฟล์ exe ถูกสร้างขึ้นหลังจากคอมไพล์ไลบรารีควบคุม และโปรแกรมสามารถดำเนินการได้โดยตรง Project1;ใช้แบบฟอร์ม, Unit1 ใน 'Unit1.pas';{$R *.res} เริ่มต้นแอปพลิเคชัน. application.createform (tform1, form1);คุณสมบัติ:
// คำหลักที่ใช้ในการประกาศคุณสมบัติ : รวม; (ผู้ส่ง: tobject) ของวัตถุ;
ได้รับการคุ้มครอง:
// การป้องกันระบุการอนุญาตการเข้าถึงขององค์ประกอบภายในชั้นเรียน
สาธารณะ:
// สาธารณะระบุการอนุญาตการเข้าถึงองค์ประกอบขององค์ประกอบภายในชั้นเรียน
ที่ตีพิมพ์:
// ที่เผยแพร่ระบุสิทธิ์การเข้าถึงขององค์ประกอบภายในชั้นเรียน ผู้ชมวัตถุ
ยก:
// คำสั่ง Raise ถูกใช้เพื่อโยนข้อยกเว้น : String; เริ่มต้นถ้าฉัน <0 จากนั้นเพิ่มข้อยกเว้นสร้าง ('จำนวนเต็มไม่น้อยกว่า 0'); strtoint (s); ยกเว้นใน e: ข้อยกเว้นยกข้อยกเว้นสร้าง (e.message); สิ้นสุด;อ่าน:
// อ่านเพื่อระบุสมาชิกหรือวิธีการที่ใช้ในการอ่านคุณสมบัติ
อ่านอย่างเดียว:
// คำหลักแบบอ่านอย่างเดียวถูกใช้เพื่อระบุว่าวัตถุนั้นเป็นแบบอ่านอย่างเดียว propertyReadonly; // เมื่อถูกตั้งค่าอย่างแท้จริงเป็นจริงผู้ใช้จะไม่ได้รับอนุญาตให้แก้ไขคุณสมบัติด้วยตนเองและสามารถทำงานผ่านวัตถุอื่น ๆ เท่านั้น
บันทึก:
// คำหลักบันทึกถูกใช้เพื่อประกาศบันทึกโครงสร้าง ; จบ ;
ลงทะเบียน:
// การลงทะเบียนทำเครื่องหมายโปรโตคอลการเรียกใช้ฟังก์ชั่นว่าฟังก์ชั่นสามารถออกจากบันทึกในรีจิสทรีเมื่อเรียกได้ว่าเป็นไปได้ ลงทะเบียนการควบคุมหรือเครื่องมือผู้เชี่ยวชาญด้วยไลบรารีควบคุมหรือ IDE.Procedure Register; เริ่มลงทะเบียนคอมโพสิต ('ตัวอย่าง', [TDEMO]); สิ้นสุด;รื้อฟื้น:
// reintroduce ใช้ในการเผยแพร่วิธีการใหม่โดยปกติเมื่อสืบทอด . จำนวนเต็ม);
ทำซ้ำ:
// คำหลักซ้ำถูกใช้เพื่อแนะนำโครงสร้างการวนซ้ำซ้ำ ผลรวม: = sum + i;
กำหนดให้มี:
// ต้องการคำหลักชี้ให้เห็นเงื่อนไขที่จำเป็นสำหรับการรวบรวมแพ็คเกจ
ResourCestring:
// Resourcestring ถูกใช้เพื่อประกาศสตริงทรัพยากรซึ่งสามารถใช้งานได้ภายในโครงสร้างที่ประกาศไว้ 'Borland Rocks';
Safecall:
// Safecall เป็นประเภทของข้อตกลงการเรียกใช้ฟังก์ชันซึ่งกำหนดกฎที่ฟังก์ชั่นที่เรียกโดย COM จะต้องปฏิบัติตาม ;
ชุด:
// คำหลักที่ใช้เพื่อประกาศคลาสคอลเลกชันซึ่งอนุญาตให้ใช้ตัวดำเนินการที่ตั้งไว้เช่นใน ฯลฯ Type TCOL = (CA, CB, CC); ในระหว่างการดำเนินการเพื่อเพิ่มหรือลบองค์ประกอบการรวบรวม var cols: tcols; เริ่มต้น cols: = cols + [ca, cb]; สิ้นสุด;
shl:
// shl หมายถึงการเปลี่ยนไปทางซ้าย
SHR:
// SHR หมายถึงการเปลี่ยนไปทางขวา
stdcall:
// stdcall เป็นประเภทของข้อตกลงการเรียกใช้ฟังก์ชั่นซึ่งกำหนดกฎที่สามารถเรียกได้โดยโปรแกรมควรปฏิบัติตาม ฟังก์ชั่นการโทร Callee: Library Demo; จำนวนเต็ม): จำนวนเต็ม;
เก็บไว้:
// เก็บไว้เพื่อระบุว่าค่าของคุณสมบัติสามารถเก็บรักษาได้หรือไม่
สตริง：
// string เป็นชนิดข้อมูลซึ่งแสดงถึง string.var str: string;
แล้ว:
// จากนั้นคำหลักจะถูกใช้ในคำสั่ง IF ); จบ;
Threadvar:
// Threadvar ระบุตัวแปรที่สร้างขึ้นเมื่อเธรดเริ่มต้นขึ้น ''; // s: = '';
ถึง:
// ถึงคำหลักที่ใช้ในคำสั่งสำหรับระบุว่าตัวแปรลูปเพิ่มขึ้น ใช้เพื่อเพิ่มคำตัวแปรลูปใช้คำหลัก downto เพื่อลดลง
พยายาม:
// คำสั่งลองใช้สำหรับการจัดการข้อยกเว้น
พิมพ์:
// คำหลักที่ใช้ในการประกาศวัตถุต่าง ๆ CA, CB, CC);
หน่วย:
// หน่วยระบุจุดเริ่มต้นของหน่วย จุดเริ่มต้น.
จนกระทั่ง:
// คำหลักที่ใช้เพื่อกำหนดเงื่อนไขการวนซ้ำของโครงสร้างลูปซ้ำ = sum + i;
ใช้:
// ใช้เพื่ออ้างอิงหน่วยภายนอกและสามารถใช้ส่วนสาธารณะของหน่วย
var:
// คำหลัก VAR ใช้เพื่อประกาศตัวแปรหรือวัตถุและตัวแปรที่ประกาศด้วย VAR จะถูกส่งผ่านโดยค่า (var i: จำนวนเต็ม): จำนวนเต็ม; // พารามิเตอร์ i ในฟังก์ชันข้างต้นถูกส่งผ่านโดยการอ้างอิงค่าของมันสามารถเปลี่ยนแปลงได้เมื่อฟังก์ชั่นถูกเรียกใช้และส่งกลับไปยังฟังก์ชั่นการโทร
Varargs:
// varargs ระบุพารามิเตอร์อ้างอิงซึ่งจะต้องใช้ร่วมกับคำหลัก CDECL ซึ่งระบุว่าฟังก์ชั่นที่เรียกว่าจะถูกส่งผ่านโดยการอ้างอิง รหัสมาจากไลบรารีคลาส C ++ ฟังก์ชั่น PRINTF ถูกอ้างอิงและพารามิเตอร์ได้รับอนุญาตให้ส่งผ่านโดยการอ้างอิง
เสมือน:
// เสมือนถูกใช้เพื่อประกาศวิธีการเสมือนจริง
ในขณะที่:
// ในขณะที่คำหลักถูกใช้เพื่อแนะนำคำสั่งวนรอบ inc (i); สิ้นสุด;
กับ:
// ด้วยคำหลักที่ใช้ในการรวบรวมวัตถุเดียวกันสำหรับการประมวลผล ผนวก ('def'); ดูเหมือนว่าซ้ำซ้อนมากในการคัดลอกเนื้อหาไปยังรหัสคลิปบอร์ด: form1.memo1.lines.clear; form1.memo1.lines.append ('abc'); form1.memo1.lines.append ('def'); form1.memo1 lines.savetofile ('c: /demo.txt');เขียน:
// เขียนเพื่อระบุสมาชิกหรือวิธีการที่ใช้ในการเขียนในคุณสมบัติ
เขียนอย่างเดียว:
// คำหลัก WriteOnly ใช้เพื่อระบุว่าวัตถุเป็น write-only.property writeonly; // เมื่อ Writeonly ถูกตั้งค่าเป็นจริงผู้ใช้จะไม่ได้รับอนุญาตให้อ่านคุณสมบัติและสามารถทำงานผ่านวัตถุอื่น ๆ เท่านั้น
XOR:
// XOR ใช้สำหรับเอกสิทธิ์หรือ A XOR B จากนั้น writeln ('a xor b') อื่น ๆ writeln ('a not xor b'); end; // xor ยังใช้ในการคำนวณพิเศษหรือค่า writeln (inttoStr (3 xor 5));