การเปรียบเทียบภาษาโปรแกรม (คำสั่งพื้นฐาน)

Q: หลักเกณฑ์ของบทความนี้

โดยทั่วไป `var` , `var` หรือ `var` เป็นวิธีแสดงชื่อตัวแปรหรือค่าที่ไม่ใช่ค่าตัวอักษรที่ผู้อ่านต้องตีความ ส่วนที่เหลือเป็นโค้ดตัวอักษร เครื่องหมาย ` guillemets` ( « และ » ) ใช้สำหรับล้อมรอบส่วนที่ไม่จำเป็น ` ` Tab ↹ แสดงถึงการเยื้องที่จำเป็น (ช่องว่าง)

บทความนี้เปรียบเทียบ ภาษาโปรแกรมจำนวนมากโดยแสดงตารางประเภทข้อมูลไวยากรณ์การแสดง นิพจน์ คำสั่งและการประกาศ ตัวแปรรวมถึงส่วนต่อประสานระบบปฏิบัติการทั่วไปบางส่วน

หลักเกณฑ์ของบทความนี้

โดยทั่วไป`var` , `var`หรือ`var`เป็นวิธีแสดงชื่อตัวแปรหรือค่าที่ไม่ใช่ค่าตัวอักษรที่ผู้อ่านต้องตีความ ส่วนที่เหลือเป็นโค้ดตัวอักษร เครื่องหมาย ` guillemets` ( «และ») ใช้สำหรับล้อมรอบส่วนที่ไม่จำเป็น `<br>` Tab ↹แสดงถึงการเยื้องที่จำเป็น (ช่องว่าง)

โดยค่าเริ่มต้น ตารางไม่ได้เรียงลำดับตามชื่อภาษาโปรแกรมจากน้อยไปมาก และบางภาษามีรายการอยู่ในบางตารางแต่ไม่มีในตารางอื่น

ตัวระบุประเภท

จำนวนเต็ม

	8 บิต ( ไบต์ )		16 บิต ( จำนวนเต็มสั้น )		32 บิต		64 บิต ( จำนวนเต็มยาว )		ขนาดคำ		แม่นยำตามอำเภอใจ ( บิ๊กนัม )
	ลงชื่อ	ไม่มีลายเซ็น	ลงชื่อ	ไม่มีลายเซ็น	ลงชื่อ	ไม่มีลายเซ็น	ลงชื่อ	ไม่มีลายเซ็น	ลงชื่อ	ไม่มีลายเซ็น	แม่นยำตามอำเภอใจ ( บิ๊กนัม )
อาดา^{[ 1 ]}	`range-27..27-1`^[จ]	`range0..28-1`^[j]หรือ^[k]`mod28`	`range-215..215-1`^[จ]	`range0..216-1`^[j]หรือ^[k]`mod216`	`range-231..231-1`^[จ]	`range0..232-1`^[j]หรือ^[k]`mod232`	`range-263..263-1`^[จ]	`mod2**64`^[k]	`Integer`^[จ]	`range0..2**Integer'Size-1`^[j]หรือ^[k]`modInteger'Size`	ไม่มีข้อมูล
ALGOL 68 (ความกว้างแปรผันได้)	`short short int`^[ค]	ไม่มีข้อมูล	`short int`^[ค]	ไม่มีข้อมูล	`int`^[ค]	ไม่มีข้อมูล	`long int`^[ค]	ไม่มีข้อมูล	`int`^[ค]	ไม่มีข้อมูล	`long long int`^[ก]^[ก]
ALGOL 68 (ความกว้างแปรผันได้)	`short short int`^[ค]	ไม่มีข้อมูล	`short int`^[ค]	ไม่มีข้อมูล	`int`^[ค]	ไม่มีข้อมูล	`long int`^[ค]	ไม่มีข้อมูล	`bytes`และ`bits`		`long long int`^[ก]^[ก]
C ( C99ความกว้างคงที่)	`int8_t`	`uint8_t`	`int16_t`	`uint16_t`	`int32_t`	`uint32_t`	`int64_t`	`uint64_t`	`intptr_t`^[ค]	`size_t`^[ค]	ไม่มีข้อมูล
C++ ( C++11ความกว้างคงที่)	`int8_t`	`uint8_t`	`int16_t`	`uint16_t`	`int32_t`	`uint32_t`	`int64_t`	`uint64_t`	`intptr_t`^[ค]	`size_t`^[ค]
C ( C99ความกว้างแปรผัน)	`signed char`	`unsigned char`( C++`byte` 17 )	`short`^[ค]	`unsigned short`^[ค]	`long`^[ค]	`unsigned long`^[ค]	`long long`^[ค]	`unsigned long long`^[ค]	`int`^[ค]	`unsigned int`^[ค]
C++ ( C++11ความกว้างตัวแปร)	`signed char`	`unsigned char`( C++`byte` 17 )	`short`^[ค]	`unsigned short`^[ค]	`long`^[ค]	`unsigned long`^[ค]	`long long`^[ค]	`unsigned long long`^[ค]	`int`^[ค]	`unsigned int`^[ค]
ออบเจกทีฟซี ( โกโก้ )	`signed char`หรือ`int8_t`	`unsigned char`หรือ`uint8_t`	`short`หรือ`int16_t`	`unsigned short`หรือ`uint16_t`	`int`หรือ`int32_t`	`unsigned int`หรือ`uint32_t`	`long long`หรือ`int64_t`	`unsigned long long`หรือ`uint64_t`	`NSInteger`หรือ`long`	`NSUInteger`หรือ`unsigned long`
ซี#	`sbyte`	`byte`	`short`	`ushort`	`int`	`uint`	`long`	`ulong`	`IntPtr`	`UIntPtr`	`System.Numerics.BigInteger`(.NET 4.0)
คริสตัล	`Int8`	`UInt8`	`Int16`	`UInt16`	`Int32`	`UInt32`	`Int64`	`UInt64`	ไม่มีข้อมูล	ไม่มีข้อมูล	`BigInt`(ต้องระบุอย่างชัดเจน)
ชวา	`byte`	ไม่มีข้อมูล	`short`	`char`^[ข]	`int`	ไม่มีข้อมูล	`long`	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล	`java.math.BigInteger`
ไป	`int8`	`uint8`หรือ`byte`	`int16`	`uint16`	`int32`	`uint32`	`int64`	`uint64`	`int`	`uint`	`big.Int`
สนิม	`i8`	`u8`	`i16`	`u16`	`i32`	`u32`	`i64`	`u64`	`isize`	`usize`	ไม่มีข้อมูล
สวิฟต์	`Int8`	`UInt8`	`Int16`	`UInt16`	`Int32`	`UInt32`	`Int64`	`UInt64`	`Int`	`UInt`
ดี	`byte`	`ubyte`	`short`	`ushort`	`int`	`uint`	`long`	`ulong`	ไม่มีข้อมูล	ไม่มีข้อมูล	`BigInt`
ลิสป์สามัญ^{[ 2 ]}	`(signed-byte 8)`	`(unsigned-byte 8)`	`(signed-byte 16)`	`(unsigned-byte 16)`	`(signed-byte 32)`	`(unsigned-byte 32)`	`(signed-byte 64)`	`(unsigned-byte 64)`			`bignum`
โครงการ
ISLISP ^{[ 3 ]}											`bignum`
ปาสคาล ( FPC )	`shortint`	`byte`	`smallint`	`word`	`longint`	`longword`	`int64`	`qword`	`integer`	`cardinal`	ไม่มีข้อมูล
วิชวลเบส	ไม่มีข้อมูล	`Byte`	`Integer`	ไม่มีข้อมูล	`Long`	ไม่มีข้อมูล	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล
Visual Basic .NET	`SByte`	`Byte`	`Short`	`UShort`	`Integer`	`UInteger`	`Long`	`ULong`	ไม่มีข้อมูล		`System.Numerics.BigInteger`(.NET 4.0)
ฟรีเบสิก	`Byte`หรือ`Integer<8>`	`UByte`หรือ`UInteger<8>`	`Short`หรือ`Integer<16>`	`UShort`หรือ`UInteger<16>`	`Long`หรือ`Integer<32>`	`ULong`หรือ`UInteger<32>`	`LongInt`หรือ`Integer<64>`	`ULongInt`หรือ`UInteger<64>`	`Integer`	`UInteger`	ไม่มีข้อมูล
ไพธอน 2.x	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		`int`	ไม่มีข้อมูล	`long`
ไพธอน 3.x	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		`int`
เอส-ลัง	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล
ฟอร์ทราน	`INTEGER(KIND=n)`^[f]	ไม่มีข้อมูล	`INTEGER(KIND=n)`^[f]	ไม่มีข้อมูล	`INTEGER(KIND=n)`^[f]	ไม่มีข้อมูล	`INTEGER(KIND=n)`^[f]	ไม่มีข้อมูล
พีพี	ไม่มีข้อมูล		ไม่มีข้อมูล		`int`^[ม]	ไม่มีข้อมูล	`int`^[ม]	ไม่มีข้อมูล	ไม่มีข้อมูล		^[e]
เพิร์ล 5	ไม่มีข้อมูล^[d]		ไม่มีข้อมูล^[d]		ไม่มีข้อมูล^[d]		ไม่มีข้อมูล^[d]		ไม่มีข้อมูล^[d]		`Math::BigInt`
ราคุ	`int8`	`uint8`	`int16`	`uint16`	`int32`	`uint32`	`int64`	`uint64`	`Int`	ไม่มีข้อมูล
ทับทิม	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		`Fixnum`	ไม่มีข้อมูล	`Bignum`
เออร์ลัง^[น]	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		`integer()`	ไม่มีข้อมูล	`integer()`^[o]
สกาล่า	`Byte`	ไม่มีข้อมูล	`Short`	`Char`^[ล]	`Int`	ไม่มีข้อมูล	`Long`	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล	`scala.math.BigInt`
เมล็ดพันธุ์ 7	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล	`integer`	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล	`bigInteger`
การสนทนาเล็กๆ น้อยๆ	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		`SmallInteger`^[ฉัน]	ไม่มีข้อมูล	`LargeInteger`^[ฉัน]
วินโดวส์ พาวเวอร์เชลล์	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล
โอแคมล์	ไม่มีข้อมูล		ไม่มีข้อมูล		`int32`	ไม่มีข้อมูล	`int64`	ไม่มีข้อมูล	`int`หรือ`nativeint`		`open Big_int;;`หรือ`big_int`
เอฟ#	`sbyte`	`byte`	`int16`	`uint16`	`int32`หรือ`int`	`uint32`	`int64`	`uint64`	`nativeint`	`unativeint`	`bigint`
มาตรฐาน ML	ไม่มีข้อมูล	`Word8.word`	ไม่มีข้อมูล		`Int32.int`	`Word32.word`	`Int64.int`	`Word64.word`	`int`	`word`	`LargeInt.int`หรือ`IntInf.int`
ฮัสเคลล์ ( GHC )	`«import Int»`หรือ`Int8`	`«import Word»`หรือ`Word8`	`«import Int»`หรือ`Int16`	`«import Word»`หรือ`Word16`	`«import Int»`หรือ`Int32`	`«import Word»`หรือ`Word32`	`«import Int»`หรือ`Int64`	`«import Word»`หรือ`Word64`	`Int`	`«import Word»`หรือ`Word`	`Integer`
หอไอเฟล	`INTEGER_8`	`NATURAL_8`	`INTEGER_16`	`NATURAL_16`	`INTEGER_32`	`NATURAL_32`	`INTEGER_64`	`NATURAL_64`	`INTEGER`	`NATURAL`	ไม่มีข้อมูล
โคบอล^[h]	`BINARY-CHAR «SIGNED»`	`BINARY-CHAR UNSIGNED`	`BINARY-SHORT «SIGNED»`	`BINARY-SHORT UNSIGNED`	`BINARY-LONG «SIGNED»`	`BINARY-LONG UNSIGNED`	`BINARY-DOUBLE «SIGNED»`	`BINARY-DOUBLE UNSIGNED`	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
มาเทมาติกา	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		`Integer`
ภาษาวูลฟราม	ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		ไม่มีข้อมูล		`Integer`

ค่าคงที่มาตรฐานและint shortsสามารถint lengthsใช้เพื่อกำหนดจำนวนshorts และlongs ที่สามารถนำหน้าshort intและlong intขนาดจริงของshort int,int, และlong intมีให้ใช้งานในรูปของค่าคงที่short max int,max int, และlong max intเป็นต้น
^bมักใช้สำหรับตัวอักษร
ภาษา ALGOL 68, C และ C++ ไม่ได้ระบุความกว้างที่แน่นอนของชนิดข้อมูลจำนวนเต็มshort,int,long, และ (C99,C++11)long longดังนั้นจึงขึ้นอยู่กับการใช้งาน ในภาษา C และ C++short,long, และlong longต้องมีความกว้างอย่างน้อย 16, 32 และ 64 บิต ตามลำดับ แต่สามารถมากกว่านั้นได้ ชนิดข้อมูลintต้องมีความกว้างอย่างน้อยเท่ากับshortและอย่างมากเท่ากับlongและโดยทั่วไปจะมีขนาดเท่ากับขนาดของเวิร์ดบนโปรเซสเซอร์ของเครื่อง (เช่น บนเครื่อง 32 บิต มักจะมีความกว้าง 32 บิต บนเครื่อง 64 บิต บางครั้งอาจมีความกว้าง 64 บิต)C99และC++11ยังกำหนด[u]intN_tชนิดข้อมูลที่มีความกว้างที่แน่นอนไว้ในstdint.hดูC syntax#Integral typesสำหรับข้อมูลเพิ่มเติม นอกจากนี้ ชนิดข้อมูลsize_tและptrdiff_tยังถูกกำหนดโดยสัมพันธ์กับขนาดของแอดเดรสเพื่อเก็บจำนวนเต็มที่ไม่มีเครื่องหมายและมีเครื่องหมายที่มีขนาดใหญ่พอที่จะจัดการกับดัชนีอาร์เรย์และความแตกต่างระหว่างพอยเตอร์ได้
ภาษา Perl 5 ไม่มีการแบ่งประเภทข้อมูลอย่างชัดเจน จำนวนเต็ม จำนวนทศนิยม สตริง ฯลฯ ล้วนถูกพิจารณาว่าเป็น "สเกลาร์"
PHPมีไลบรารีสำหรับการคำนวณค่าที่มีความแม่นยำสูงอยู่สองไลบรารี ไลบรารี BCMath ใช้สตริงเป็นชนิดข้อมูล ส่วนไลบรารี GMP ใช้ชนิดข้อมูลภายในที่เรียกว่า "resource"
^fค่าของnถูกกำหนดโดยฟังก์ชันภายในSELECTED_INT_KIND^{[ 4 ]}
ตัวเลือก รันไทม์ ของ ALGOL 68G--precision "number"สามารถตั้งค่าความแม่นยำสำหรับlong long ints เป็นจำนวนหลักสำคัญที่ต้องการได้ ค่าคงที่มาตรฐานlong long int widthและlong long max intสามารถใช้เพื่อกำหนดความแม่นยำที่แท้จริงได้
ภาษา COBOLอนุญาตให้ระบุความแม่นยำที่ต้องการ และจะเลือกชนิดข้อมูลที่พร้อมใช้งานซึ่งสามารถแสดงความแม่นยำที่ระบุได้โดยอัตโนมัติPIC S9999ตัวอย่างเช่น จะต้องใช้ตัวแปรแบบมีเครื่องหมายที่มีความแม่นยำสี่หลักทศนิยม หากระบุเป็นฟิลด์ไบนารี ระบบจะเลือกชนิดข้อมูลแบบมีเครื่องหมาย 16 บิตบนแพลตฟอร์มส่วนใหญ่
Smalltalk จะเลือกวิธีการแสดงจำนวนเต็มที่เหมาะสมโดยอัตโนมัติ โดยทั่วไปจะมีสองรูปแบบ รูปแบบหนึ่งสำหรับจำนวนเต็มที่พอดีกับขนาดเวิร์ดดั้งเดิมลบด้วยบิตแท็ก (SmallInteger) และอีกรูปแบบหนึ่งสำหรับจำนวนเต็มที่มีขนาดตามต้องการ (LargeInteger)การดำเนินการทางคณิตศาสตร์รองรับอาร์กิวเมนต์แบบโพลีมอร์ฟิกและส่งคืนผลลัพธ์ในรูปแบบที่กระชับที่สุดที่เหมาะสมที่สุด
^j ประเภทช่วง ของ Adaจะถูกตรวจสอบการละเมิดขอบเขตในขณะรันไทม์ (รวมถึงในขณะคอมไพล์สำหรับนิพจน์แบบคงที่) การละเมิดขอบเขตในขณะรันไทม์จะทำให้เกิดข้อยกเว้น "ข้อผิดพลาดข้อจำกัด" ช่วงไม่ได้จำกัดเฉพาะกำลังของสอง ประเภทย่อยของจำนวนเต็มที่กำหนดไว้ล่วงหน้าโดยทั่วไป ได้แก่ จำนวนเต็มบวก () และจำนวนเต็มธรรมชาติ ()(8 บิต),(16 บิต) และ(64 บิต) ก็ถูกกำหนดไว้ล่วงหน้าโดยทั่วไปเช่นกัน แต่ไม่ได้เป็นข้อกำหนดตามมาตรฐาน Ada การตรวจสอบในขณะรันไทม์สามารถปิดใช้งานได้หากประสิทธิภาพมีความสำคัญมากกว่าการตรวจสอบความสมบูรณ์range1..Integer'Lastrange0..Integer'LastShort_Short_IntegerShort_IntegerLong_Integer
^k ประเภทโมดูลัส ของ Adaใช้การคำนวณโมดูลัสในทุกการดำเนินการ กล่าวคือ จะไม่มีการละเมิดช่วงเกิดขึ้น โมดูลัสไม่ได้จำกัดเฉพาะกำลังของสองเท่านั้น
^lมักใช้สำหรับอักขระเช่น char ในภาษา Java
^mintใน PHP มีความกว้างเท่ากับlongtype ใน C บนระบบนั้น^[c]
^n Erlangเป็นภาษาที่มีการกำหนดประเภทแบบไดนามิก ตัวระบุประเภทมักใช้เพื่อระบุประเภทของฟิลด์เรคอร์ดและประเภทของอาร์กิวเมนต์และค่าส่งคืนของฟังก์ชัน^{[ 5 ]}
^oเมื่อเกินหนึ่งคำ^{[ 6 ]}

จุดลอยตัว

	ความแม่นยำเดี่ยว	ความแม่นยำสองเท่า	ความแม่นยำอื่นๆ	ขึ้นอยู่กับโปรเซสเซอร์
อาดา^{[ 1 ]}	`Float`	`Long_Float`	ไม่มีข้อมูล
อัลโกล 68	`real`^[ก]	`long real`^[ก]	`short real`, `long long real`, เป็นต้น^[ง]
ซี	`float`^[ข]	`double`	`long double`^[f]
ซี++ (STL)
ออบเจกทีฟซี ( โกโก้ )				`CGFloat`
ซี#	`float`		ไม่มีข้อมูล
คริสตัล	`Float64`	`Float64`
ชวา	`float`	`double`
ไป	`float32`	`float64`	ไม่มีข้อมูล
สนิม	`f32`	`f64`	`f16, f128`
สวิฟต์	`Float`หรือ`Float32`	`Double`หรือ`Float64`	`Float80`^[ก]	`CGFloat`
ดี	`float`	`double`		`real`
ลิสปาร์กทั่วไป	`single-float`	`double-float`	`float, short-float, long-float`
โครงการ
ไอเอสลิสป์
ปาสคาล ( FPC )	`single`	`double`		`real`
วิชวลเบส	`Single`	`Double`	ไม่มีข้อมูล
Visual Basic .NET
โซโจ
ไพธอน	ไม่มีข้อมูล	`float`
โค้ด JavaScript	ไม่มีข้อมูล	`Number`^{[ 7 ]}	ไม่มีข้อมูล
เอส-ลัง
ฟอร์ทราน	`REAL(KIND = n)`^[ค]
พีพี		`float`
เพิร์ล
ราคุ	`num32`	`num64`		`Num`
ทับทิม	ไม่มีข้อมูล	`Float`	ไม่มีข้อมูล
สกาล่า	`Float`	`Double`
เมล็ดพันธุ์ 7	ไม่มีข้อมูล	`float`
การสนทนาเล็กๆ น้อยๆ	`Float`	`Double`
วินโดวส์ พาวเวอร์เชลล์
โอแคมล์	ไม่มีข้อมูล	`float`	ไม่มีข้อมูล
เอฟ#	`float32`	`float`
มาตรฐาน ML	ไม่มีข้อมูล			`real`
ฮัสเคลล์ ( GHC )	`Float`	`Double`
หอไอเฟล	`REAL_32`	`REAL_64`
โคบอล	`FLOAT-BINARY-7`^[e]	`FLOAT-BINARY-34`^[e]	`FLOAT-SHORT`, `FLOAT-LONG`,`FLOAT-EXTENDED`
มาเทมาติกา	ไม่มีข้อมูล	ไม่มีข้อมูล		`Real`

ค่าคงที่มาตรฐานและreal shortsสามารถreal lengthsใช้เพื่อกำหนดจำนวนshorts และlongs ที่สามารถนำหน้าshort realและได้long realขนาดจริงของshort real,real, และlong realมีให้ใช้งานในรูปของค่าคงที่short max real,max realและlong max realเป็นต้น โดยมีค่าคงที่short small real,small realและลอนเครื่องlong small realแต่ละประเภท
การประกาศ ค่าความแม่นยำเดี่ยว (single precision) มักจะไม่ได้รับการยอมรับ
^cค่าของnถูกกำหนดโดยฟังก์ชันภายในSELECTED_REAL_KIND^{[ 8 ]}
ตัวเลือกรันไทม์ของ ALGOL 68G--precision "number"สามารถตั้งค่าความแม่นยำสำหรับlong long reals ให้เป็นจำนวนหลักสำคัญที่ต้องการได้ ค่าคงที่มาตรฐานlong long real widthและlong long max realสามารถใช้เพื่อกำหนดความแม่นยำที่แท้จริงได้
^e ประเภทข้อมูลจุดลอยตัว ของ IEEEเหล่านี้จะถูกนำมาใช้ในมาตรฐาน COBOL รุ่นต่อไป
^fขนาดเท่ากับที่doubleใช้ในหลายๆ การใช้งาน
^g Swift รองรับชนิดข้อมูลจุดลอยตัว ความแม่นยำสูง80 บิตซึ่งเทียบเท่ากับlong doubleในภาษา C

จำนวนเชิงซ้อน

	จำนวนเต็ม	ความแม่นยำเดี่ยว	ความแม่นยำสองเท่า	ความแม่นยำครึ่งและสี่เท่า เป็นต้น
อาดา^{[ 1 ]}	ไม่มีข้อมูล	`Complex`^[ข]	`Complex`^[ข]	`Complex`^[ข]
อัลโกล 68	ไม่มีข้อมูล	`compl`	`long compl`เป็นต้น	`short compl`เป็นต้น และ`long long compl`อื่นๆ
C ( C99 ) ^{[ 9 ]}	ไม่มีข้อมูล	`float complex`	`double complex`	ไม่มีข้อมูล
ซี++ (STL)	ไม่มีข้อมูล	`std::complex<float>`	`std::complex<double>`
ซี#	ไม่มีข้อมูล	ไม่มีข้อมูล	`System.Numerics.Complex`(.NET 4.0)
ชวา	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
ไป	ไม่มีข้อมูล	`complex64`	`complex128`
ดี	ไม่มีข้อมูล	`cfloat`	`cdouble`
ออบเจกทีฟซี	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
ลิสปาร์กทั่วไป	(จำนวนเต็มเชิงซ้อน)	(ค่าลอยตัวเดี่ยวที่ซับซ้อน)	(ค่าลอยตัวคู่ที่ซับซ้อน)	ซับซ้อน
โครงการ				ไม่มีข้อมูล
ปาสคาล	ไม่มีข้อมูล	ไม่มีข้อมูล
วิชวลเบส	ไม่มีข้อมูล	ไม่มีข้อมูล
Visual Basic .NET	ไม่มีข้อมูล	ไม่มีข้อมูล	`System.Numerics.Complex`(.NET 4.0)
เพิร์ล			`Math::Complex`
ราคุ		`complex64`	`complex128`	`Complex`
ไพธอน			`complex`	ไม่มีข้อมูล
โค้ด JavaScript	ไม่มีข้อมูล	ไม่มีข้อมูล
เอส-ลัง	ไม่มีข้อมูล	ไม่มีข้อมูล
ฟอร์ทราน		`COMPLEX(KIND = n)`^[ก]
ทับทิม	`Complex`	ไม่มีข้อมูล	`Complex`
สกาล่า	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
เมล็ดพันธุ์ 7	ไม่มีข้อมูล	ไม่มีข้อมูล	`complex`
การสนทนาเล็กๆ น้อยๆ	`Complex`	`Complex`	`Complex`
วินโดวส์ พาวเวอร์เชลล์	ไม่มีข้อมูล	ไม่มีข้อมูล
โอแคมล์	ไม่มีข้อมูล	ไม่มีข้อมูล	`Complex.t`
เอฟ#			`System.Numerics.Complex`(.NET 4.0)
มาตรฐาน ML	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
ฮัสเคลล์ ( GHC )	ไม่มีข้อมูล	`Complex.Complex Float`	`Complex.Complex Double`
หอไอเฟล	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
โคบอล	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
มาเทมาติกา	`Complex`	ไม่มีข้อมูล	ไม่มีข้อมูล	`Complex`

^aค่าของnถูกกำหนดโดยฟังก์ชันภายในSELECTED_REAL_KIND^{[ 8 ]}
^bชนิดข้อมูลทั่วไปที่สามารถสร้างอินสแตนซ์ได้ด้วยชนิดข้อมูลจุดลอยตัวพื้นฐานใดๆ ก็ได้

ประเภทตัวแปรอื่นๆ

	ข้อความ		บูลีน	การนับจำนวน	วัตถุ / สากล
	อักขระ	สตริง^[a]	บูลีน	การนับจำนวน	วัตถุ / สากล
อาดา^{[ 1 ]}	`Character`	`String`, `Bounded_String`,`Unbounded_String`	`Boolean`	`(item₁, item₂, ...)`	`tagged null record`
อัลโกล 68	`char`	`string`,`bytes`	`bool`,`bits`	ไม่มีข้อมูล - กำหนดโดยผู้ใช้	ไม่มีข้อมูล
ซี ( ซี99 )	`char`,`wchar_t`	ไม่มีข้อมูล	`bool`^[ข]	`enum «name» { item₁, item₂, ... };`	`void*`
ซี++ (STL)	`char`,`wchar_t`	`«std::»string`	`bool`^[ข]		`void*`
ออบเจกทีฟซี	`unichar`	`NSString *`	`BOOL`		`id`
ซี#	`char`	`string`	`bool`	`enum name { item₁« = value», item₂« = value», ... }`	วัตถุ
คริสตัล	`Char`	`String`	`Bool`	`enum Name item₁item₂...end`	ไม่มีข้อมูล
ชวา	`char`	`String`	`boolean`	`enum name { item₁, item₂, ... }`	`Object`
ไป	`byte`,`rune`	`string`	`bool`	`const ( item₁ = iota item₂ ...)`	`interface{}`
สนิม	`char`	`String`	`bool`	`enum name { item₁« = value», item₂« = value», ... }`	`std::any::Any`
สวิฟต์	`Character`	`String`	`Bool`	`enum name { case item₁, item₂, ... }`	`Any`
ดี	`char`	`string`	`bool`	`enum name { item₁, item₂, ... }`	`std.variant.Variant`
ลิสปาร์กทั่วไป	`character`	`string`	`boolean`	`(member item₁item₂...)`	`t`
โครงการ
ไอเอสลิสป์
ปาสคาล (ISO)	`char`	ไม่มีข้อมูล	`boolean`	`( item₁, item₂, ... )`	ไม่มีข้อมูล
ออบเจ็กต์ปาสคาล ( เดลฟี )	`char`	`string`	`boolean`	`( item₁, item₂, ... )`	`variant`
วิชวลเบส	ไม่มีข้อมูล	`String`	`Boolean`	`Enum name item₁ «= value» item₂ «= value» ...End Enum`	`Variant`
Visual Basic .NET	`Char`				`Object`
โซโจ	ไม่มีข้อมูล				`Object`หรือ`Variant`
ไพธอน	ไม่มีข้อมูล^[d]	`str`	`bool`	`fromenumimportEnumclassName(Enum):`รายการที่₁ = มูลค่ารายการ_{ที่ 2} = มูลค่า...	`object`
โค้ด JavaScript	ไม่มีข้อมูล^[d]	`String`	`Boolean`		`Object`
เอส-ลัง
ฟอร์ทราน	`CHARACTER(LEN=*)`	`CHARACTER(LEN=:),allocatable`	`LOGICAL(KIND=n)`^[f]		`CLASS(*)`
พีพี	ไม่มีข้อมูล^[d]	`string`	`bool`		(ละการประกาศประเภท)
เพิร์ล	ไม่มีข้อมูล^[d]				`UNIVERSAL`
ราคุ	`Char`	`Str`	`Bool`	`enum name<item₁ item₂ ...>enum name «:item₁(value) :item₂(value) ..»`	`Mu`
ทับทิม	ไม่มีข้อมูล^[d]	`String`	`Object`^[ค]		`Object`
สกาล่า	`Char`	`String`	`Boolean`	`object name extends Enumeration { val item₁, item₂, ... = Value}`	`Any`
เมล็ดพันธุ์ 7	`char`	`string`	`boolean`	`const type: name is new enum item₁, item₂, ...end enum;`
วินโดวส์ พาวเวอร์เชลล์
โอแคมล์	`char`	`string`	`bool`	ไม่มีข้อมูล^[e]	ไม่มีข้อมูล
เอฟ#				`type name = item₁ = value \|item₂ = value \| ...`	`obj`
มาตรฐาน ML				ไม่มีข้อมูล^[e]	ไม่มีข้อมูล
ฮัสเคลล์ ( GHC )	`Char`	`String`	`Bool`	ไม่มีข้อมูล^[e]	ไม่มีข้อมูล
หอไอเฟล	`CHARACTER`	`STRING`	`BOOLEAN`	ไม่มีข้อมูล	`ANY`
โคบอล	`PIC X`	`PIC X(string length)`หรือ`PIC X«X...»`	`PIC 1«(number of digits)»`หรือ`PIC 1«1...»`	ไม่มีข้อมูล	`OBJECT REFERENCE`
มาเทมาติกา	ไม่มีข้อมูล^[d]	`String`			ไม่มีข้อมูล

โดยเฉพาะอย่างยิ่ง สตริงที่มีความยาวไม่จำกัดและได้รับการจัดการโดยอัตโนมัติ
^bภาษาโปรแกรมนี้แสดงค่าบูลีนเป็นจำนวนเต็ม โดยค่าเท็จแทนด้วยค่าศูนย์ และค่าจริงแทนด้วยค่าที่ไม่ใช่ศูนย์
ค่าทั้งหมดใน ^cจะประเมินได้เป็นจริงหรือเท็จ ทุกอย่างในTrueClassจะมีค่าเป็นจริง และทุกอย่างในFalseClassจะมีค่าเป็นเท็จ
ภาษานี้ไม่มีประเภทอักขระแยกต่างหาก อักขระจะถูกแทนด้วยสตริงที่มีความยาว 1
การ แจงนับในภาษานี้เป็นประเภทพีชคณิตที่มีตัวสร้างที่เป็นค่าว่างเท่านั้น
^fค่าของnถูกกำหนดโดยฟังก์ชันภายในSELECTED_INT_KIND^{[ 4 ]}

ประเภทที่ได้มา

อาร์เรย์

	อาร์เรย์ขนาดคงที่		อาร์เรย์ขนาดไดนามิก
	อาร์เรย์หนึ่งมิติ	อาร์เรย์หลายมิติ	อาร์เรย์หนึ่งมิติ	อาร์เรย์หลายมิติ
อาดา^{[ 1 ]}	`array (<first> .. <last>) of <type>`หรือ`array (<discrete_type>) of <type>`	`array (<first₁> .. <last₁>, <first₂> .. <last₂>, ...) of <type>`หรือ`array (<discrete_type₁>, <discrete_type₂>, ...) of <type>`	`array (<discrete_type> range <>) of <type>`	`array (<discrete_type₁> range <>, <discrete_type₂> range <>, ...) of <type>`
อัลโกล 68	`[first:last]«modename»`หรือพูดง่ายๆ ก็คือ:`[size]«modename»`	`[first₁:last₁, first₂:last₂]«modename»`หรืออื่นๆ `[first₁:last₁][first₂:last₂]«modename»`	`flex[first:last]«modename»`หรือพูดง่ายๆ ก็คือ:`flex[size]«modename»`	`flex[first₁:last₁, first₂:last₂]«modename»`หรือ`flex[first₁:last₁]flex[first₂:last₂]«modename» etc.`
ซี ( ซี99 )	`type name[size]`^[ก]	`type name[size₁][size₂]`^[ก]	`type *name`หรือภายในบล็อก:`int n = ...; type name[n]`
ซี++ (STL)	`«std::»array<type, size>`(ซี++11)		`«std::»vector<type>`
ซี#	`type[]`	`type[,,...]`	`System.Collections.ArrayList`หรือ`System.Collections.Generic.List<type>`
คริสตัล	`Array(type[s]).new(size)`^[ข]		`Array(type[s]).new`
ชวา	`type[]`^[ค]	`type[][]...`^[ค]	`ArrayList or ArrayList<type>`
ดี	`type[size]`	`type[size₁][size₂]`	`type[]`
ไป	`[size]type`	`[size₁][size₂]...type`	`[]type`	`[][]type`
สนิม	`[type; size]`	`[[type; size₁]; size₂]`	`Vec<type>`	`Vec<Vec<type>>`
สวิฟต์			`[type]`หรือ`Array<type>`	`[[type]]`หรือ`Array<Array<type>>`
ออบเจกทีฟซี	`NSArray`		`NSMutableArray`
โค้ด JavaScript	ไม่มีข้อมูล	ไม่มีข้อมูล	`Array`^[ง]
ลิสปาร์กทั่วไป	`(simple-arraytype(dimension))`	`(simple-arraytype(dimension1dimension2))`	`(arraytype(dimension))`	`(arraytype(dimension1dimension2))`
โครงการ
ไอเอสลิสป์
ปาสคาล	`array[first..last] of type`^[e]	`array[first₁..last₁] of array[first₂..last₂] ... of type`^[e]หรือ^[e] `array[first₁..last₁, first₂..last₂, ...] of type`	ไม่มีข้อมูล	ไม่มีข้อมูล
ออบเจ็กต์ปาสคาล ( เดลฟี )	`array[first..last] of type`^[e]		`array of type`	`array of array ... of type`
วิชวลเบส	`Dim x(last) As type`	`Dim x(last₁, last₂,...) As type`
Visual Basic .NET	`type()`	`type(,,...)`	`System.Collections.ArrayList`หรือ`System.Collections.Generic.List(Of type)`
ไพธอน			`list`
เอส-ลัง	`x = type[size];`	`x = type[size₁, size₂, ...];`
ฟอร์ทราน	`type :: name(size)`	`type :: name(size₁, size₂,...)`	`type, ALLOCATABLE :: name(:)`	`type, ALLOCATABLE :: name(:,:,...)`
พีพี			`array`
เพิร์ล
ราคุ			`Array[type] or Array of type`
ทับทิม		`x = Array.new(size₁){ Array.new(size₂) }`	`Array`
สกาล่า	`Array[type]`	`Array[...[Array[type]]...]`	`ArrayBuffer[type]`
เมล็ดพันธุ์ 7	`array type`หรือ`array [idxType] type`	`array array type`หรือ`array [idxType] array [idxType] type`	`array type`หรือ`array [idxType] type`	`array array type`หรือ`array [idxType] array [idxType] type`
การสนทนาเล็กๆ น้อยๆ	`Array`		`OrderedCollection`
วินโดวส์ พาวเวอร์เชลล์	`type[]`	`type[,,...]`
โอแคมล์	`type array`	`type array ... array`
เอฟ#	`type []`หรือ`type array`	`type [,,...]`	`System.Collections.ArrayList`หรือ`System.Collections.Generic.List<type>`
มาตรฐาน ML	`type vector or type array`
ฮัสเคลล์ ( GHC )	`x=Array.array(0,size-1) list_of_association_pairs`	`x=Array.array((0,0,...), (size₁-1, size₂-1,...)) list_of_association_pairs`
โคบอล	`level-number type OCCURS size «TIMES».`	นิยามของอาร์เรย์หนึ่งมิติ...	`level-number type OCCURS min-size TO max-size«TIMES»DEPENDING «ON»size.`^[f]	ไม่มีข้อมูล

^aในนิพจน์ส่วนใหญ่ (ยกเว้นsizeofand&) ค่าของชนิดอาร์เรย์ในภาษา C จะถูกแปลงเป็นตัวชี้ไปยังอาร์กิวเมนต์แรกโดยอัตโนมัติ ดูรายละเอียดเพิ่มเติมเกี่ยวกับไวยากรณ์และการดำเนินการกับตัวชี้ได้ที่ C syntax#Arrays
เนื่องจากชนิดข้อมูลทั้งหมดใน Crystal เป็นอ็อบเจ็กต์ ดังนั้นอาร์เรย์จึงสามารถบรรจุอาร์เรย์อื่นได้โดยธรรมชาติ โดยการระบุไว้ในค่าคงที่หรือการประกาศชนิดข้อมูล (เช่นArray(Array(Int32 | Float64))ระบุอาร์เรย์สองมิติที่ประกอบด้วยจำนวนเต็ม 32 บิตและจำนวนทศนิยมความแม่นยำสูง)
^c รูป แบบที่คล้ายกับภาษา Ctype x[]สามารถใช้งานได้ใน Java แต่type[] xเป็นรูปแบบการประกาศอาร์เรย์ที่นิยมมากกว่า
ช่วงย่อยใช้เพื่อกำหนดขอบเขตของอาร์เรย์
อาร์เรย์ใน JavaScriptเป็นวัตถุชนิดพิเศษ
^fเงื่อนไขDEPENDING ONใน COBOL ไม่ได้สร้างได้จริงและจะจัดสรรขนาดสูงสุดของอาร์เรย์เสมอ

ประเภทอื่นๆ

	ประเภทคอมโพสิตแบบง่าย		ประเภทข้อมูลเชิงพีชคณิต	สหภาพแรงงาน
	บันทึก	การแสดงออกของ ทูเพิล	ประเภทข้อมูลเชิงพีชคณิต	สหภาพแรงงาน
อาดา^{[ 1 ]}	`type name is «abstract» «tagged» «limited» [record field₁ : type; field₂ : type; ...end record \| null record]`	ไม่มีข้อมูล	การรวมกันใดๆ ของเรคอร์ด ยูเนียน และการแจงนับ (รวมถึงการอ้างอิงถึงสิ่งเหล่านั้น ซึ่งช่วยให้สามารถสร้างประเภทแบบเรียกซ้ำได้)	`type name (variation : discrete_type) is record case variation is when choice_list₁ => fieldname₁ : type; ... when choice_list₂ => fieldname₂ : type; ... ... end case;end record`
อัลโกล 68	`struct (modename «fieldname», ...);`	ประเภทและตัวดำเนินการที่จำเป็นสามารถกำหนดเองได้โดยผู้ใช้		`union (modename, ...);`
ซี ( ซี99 )	`struct «name» {type name;...};`	ไม่มีข้อมูล	ไม่มีข้อมูล	`union {type name;...};`
ออบเจกทีฟซี	`struct «name» {type name;...};`	ไม่มีข้อมูล
ซี++	`struct «name» {type name;...};`^[ข]	`«std::»tuple<type₁..type_n>`
ซี#	`struct name {type name;...}`	`(val₁, val₂, ... )`		ไม่มีข้อมูล
คริสตัล	`class Name def initialize(name : type) @name = name endend`	`{val₁, val₂, ...}`	`class`es และ`struct`s สามารถใช้เพื่อกำหนดการผสมผสานของประเภทต่างๆ และการดำเนินการใดๆ กับประเภทเหล่านั้นผ่านทางเมธอดของพวกมันได้
ชวา	ไม่มีข้อมูล^[ก]
โค้ด JavaScript		ไม่มีข้อมูล
ดี	`struct name {type name;...}`		`std.variant.Algebraic!(type,...)`	`union {type name;...}`
ไป	`struct { «name» type ...}`
สนิม	`struct name {name: type, ...}`	`(val₁, val₂, ... )`	`enum name { Foo(types), ...}`	`union name {name: type, ...}`
สวิฟต์	`struct name { var name «: type» ...}`	`(«name₁:» val₁, «name₂:» val₂, «name₃:» val₃, ... )`	`enum name { case Foo«(types)» case Bar «(types)» ... }`
ลิสปาร์กทั่วไป	`(defstructnameslot-name(slot-nameinitial-value)(slot-nameinitial-value:typetype)...)`	`(cons val₁ val₂)`^[ค]
โครงการ	ไม่มีข้อมูล
ไอเอสลิสป์
ปาสคาล	`record name: type; ...end`	ไม่มีข้อมูล	ไม่มีข้อมูล	`record case type of value: (types); ...end`
วิชวลเบส
Visual Basic .NET	`Structure name Dim name As type ...End Structure`	`(val₁, val₂, ... )`
ไพธอน	ไม่มีข้อมูล^[ก]	`«(»val₁, val₂, val₃, ... «)»`		ไม่มีข้อมูล
เอส-ลัง	`struct {name [=value], ...}`
ฟอร์ทราน	`TYPE name type :: name ...END TYPE`
พีพี	ไม่มีข้อมูล^[ก]
เพิร์ล	ไม่มีข้อมูล^[d]			ไม่มีข้อมูล
ราคุ	ไม่มีข้อมูล^[ก]
ทับทิม	`OpenStruct.new({:name=>value})`
สกาล่า	`case class name(«var» name: type, ...)`	`(val₁, val₂, val₃, ... )`	`abstract class name case class Foo(«parameters») extends name case class Bar(«parameters») extends name ...`หรือการผสมผสานระหว่างคลาสเคสและออบเจ็กต์เคส `abstract class name case object Foo extends name case object Bar extends name ...`
วินโดวส์ พาวเวอร์เชลล์
โอแคมล์	`type name = {«mutable» name : type;...}`	`«(»val₁, val₂, val₃, ... «)»`	`type name = Foo «of type» \| Bar «of type» \| ...`	ไม่มีข้อมูล
เอฟ#	`type name = {«mutable» name : type;...}`	`«(»val₁, val₂, val₃, ... «)»`	`type name = Foo «of type» \| Bar «of type» \| ...`
มาตรฐาน ML	`type name = {name : type,...}`	`(val₁, val₂, val₃, ... )`	`datatype name = Foo «of type» \| Bar «of type» \| ...`
ฮัสเคลล์	`data Name = Constr {name :: type,...}`	`(val₁, val₂, val₃, ... )`	`data Name = Foo «types» \| Bar «types» \| ...`
โคบอล	`level-numbernametypeclauses. level-number+nnametypeclauses. ...`	ไม่มีข้อมูล	ไม่มีข้อมูล	`name REDEFINES variable type.`

^aรองรับเฉพาะคลาสเท่านั้น
ใน C++ นั้น ^bstructก็คือคลาส แต่โดยค่าเริ่มต้นจะมีระดับการมองเห็นเป็น public และเป็นPODด้วยเช่นกันC++11 ได้ขยายขอบเขตนี้เพิ่มเติม ทำให้คลาสทำงานเหมือนกับอ็อบเจ็กต์ POD ในหลายกรณีมากขึ้น
คู่ ^cเท่านั้น
แม้ว่า Perl จะไม่มีเรคอร์ด แต่เนื่องจากระบบประเภทข้อมูลของ Perl อนุญาตให้มีข้อมูลประเภทต่างๆ อยู่ในอาร์เรย์ได้ ดังนั้น "แฮช" (อาร์เรย์แบบเชื่อมโยง) ที่ไม่มีดัชนีตัวแปรจึงมีผลเหมือนกับเรคอร์ด
การ แจงนับในภาษานี้เป็นประเภทพีชคณิตที่มีตัวสร้างที่เป็นค่าว่างเท่านั้น

การประกาศตัวแปรและค่าคงที่

	ตัวแปร	คงที่	ประเภทคำพ้องความหมาย
อาดา^{[ 1 ]}	`identifier : type« := initial_value»`^[e]	`identifier : constant type := final_value`	`subtype identifier is type`
อัลโกล 68	`modename name« := initial_value»;`	`modename name = value;`	`mode synonym = modename;`
ซี ( ซี99 )	`type name« = initial_value»;`	`enum{ name = value };`	`typedeftype synonym;`
ออบเจกทีฟซี		`enum{ name = value };`
ซี++		`const type name = value;`
ซี#	`type name₁« = initial_value», name₂« = initial_value», ...;`หรือ`var name = initial_value;`	`const type name = value, name = value, ...;`หรือ`readonly type name = value, name = value, ... ;`	`using synonym = type;`
คริสตัล	`name : type = initial_value`หรือ`name = initial_value`	`NAME = value`	`alias synonym = type`
ดี	`type name« = initial_value»;`หรือ`auto name = value;`	`const type name = value;`หรือ`immutable type name = value;`	`alias type synonym;`
ชวา	`type name« = initial_value»;`	`final type name = value;`	ไม่มีข้อมูล
โค้ด JavaScript	`var name« = initial_value»;`หรือ(ตั้งแต่ECMAScript 2015) `let name« = initial_value»;`	`const name = value;`(ตั้งแต่ECMAScript 2015)	ไม่มีข้อมูล
ไป	`var name type« = initial_value»`หรือ`name := initial_value`	`const name «type» = value`	`type synonym type`
แร็กเก็ต	`(define name expression)`
สนิม^[f]	`let mut name«: type»« = initial_value»;static mut NAME: type = value;`	`let name«: type»« = initial_value»;const NAME: type = value;static NAME: type = value;`	`type synonym = typename;`
สวิฟต์	`var name «: type»« = initial_value»`	`let name «: type» = value`	`typealias synonym = type`
ลิสปาร์กทั่วไป	`(defparameter name initial-value)`หรือ`(defvar name initial-value)`	`(defconstant name value)`	`(deftype synonym () 'type)`
โครงการ	`(define name initial_value)`
ไอเอสลิสป์	`(defglobal name initial_value)`หรือ`(defdynamic name initial_value)`	`(defconstant name value)`	ไม่มีข้อมูล
ปาสคาล^[a]	`name: type« = initial_value»`	`name = value`	`synonym = type`
วิชวลเบส	`Dim name «As type»`	ดูหมายเหตุทางด้านซ้าย ค่าคงที่ใช้ไวยากรณ์เดียวกัน และ: ใช้`Const`แทน`Dim` มีข้อจำกัดเฉพาะประเภทพื้นฐานบางประเภทเท่านั้น`Const name₁ «As type» = value, name₂ «As type» = value, ...`
Visual Basic .NET ^{[ 10 ]}	ไวยากรณ์การประกาศตัวแปรของ VB.NET นั้นยากที่จะอธิบายอย่างแม่นยำเป็นพิเศษ เนื่องจากมีคำต่อท้ายระบุตัวตน ("ตัวดัดแปลง") อยู่: `type_character`สามารถใช้เป็นทางเลือกแทน`As`ข้อกำหนดสำหรับชนิดข้อมูลพื้นฐานบางประเภทได้ `nullable_specifier`; และ `array_specifier`; และนั่น a `modified_identifier`มีรูปแบบดังนี้`identifier«type_character»«nullable_specifier»«array_specifier»`; a `modified_identifier_list`คือรายการที่คั่นด้วยเครื่องหมายจุลภาคซึ่งประกอบด้วยเครื่องหมาย ; สองตัวขึ้นไป`modified_identifier`และ a `declarator_list`คือรายการตัวประกาศที่คั่นด้วยเครื่องหมายจุลภาค ซึ่งอาจอยู่ในรูปแบบ `identifier As object_creation_expression`(ตัวประกาศเริ่มต้นวัตถุ ) `modified_identifier «As non_array_type«array_rank_specifier»»« = initial_value»`(ตัวประกาศเดียว)หรือ `modified_identifier_list «As «non_array_type««array_rank_specifier»»`(ตัวประกาศหลายตัว); ข้อความประกาศที่ถูกต้องจะมีรูปแบบ โดยที่ เพื่อวัตถุประสงค์ในการวิเคราะห์ความหมาย จะต้องแปลงให้เป็นรายการของผู้ประกาศเพียงรายเดียว: `Dim declarator_listdeclarator_list` ข้อความ`As`ของแต่ละผู้ประกาศหลายรายการจะถูกกระจายไปทั่วข้อความนั้น`modified_identifier_list` ตัวประกาศเริ่มต้น ของแต่ละอ็อบเจ็กต์จะถูกแทนที่ด้วย`As New type...As type = New type...` และสำหรับสิ่งเหล่านั้น สำหรับแต่ละ`identifier`สิ่ง a `type_character`และ`As`clause ไม่ปรากฏพร้อมกัน หาก`As`มีข้อความดังกล่าวอยู่ คำ ว่า "an" `array_rank_specifier`ไม่ปรากฏทั้งในรูปแบบการแก้ไขตัวระบุและในประเภทของ`As`ข้อความ สามารถกำหนด an `unmodified_type`ได้โดยใช้กฎที่ว่า หากมี เงื่อนไข `type_character`หรือ`As`ข้อความอยู่ `unmodified_type`คือสิ่งที่ระบุไว้โดยโครงสร้างดังกล่าว และมิเช่นนั้น `Option Infer`จะต้องเปิดใช้งานอย่างใดอย่างหนึ่ง และจะ `identifier`ต้องมีตัวเริ่มต้น ซึ่งในกรณีนี้`unmodified_type`จะเป็นตัวเริ่มต้น หรือ `Option Strict`จะต้องปิดอยู่ ซึ่งในกรณีนี้`unmodified_type`คือ`Object`; its `final_type`คือคำ`unmodified_type`ที่นำหน้าคำขยาย its เป็น`final_type`ประเภทที่ถูกต้อง และ หาก`initial_value`มีอยู่ อันใดอันหนึ่ง`Option Strict`เปิดอยู่และ`initial_value`มีการแปลงที่กว้างขึ้นเป็น`final_type`หรือ `Option Strict`ปิดอยู่และ`initial_value`มีการแปลงที่แคบลงเป็น`final_type`. หาก`Option Explicit`ปิดใช้งานอยู่ ตัวแปรไม่จำเป็นต้องประกาศอย่างชัดเจน ตัวแปรจะถูกประกาศโดยปริยายเมื่อถูกใช้งาน: `name=initial_value`		`Imports synonym = type`
โซโจ	`Dim name «As type»« = initial_value»`		ไม่มีข้อมูล
ไพธอน	`name«: type» = initial_value`	ไม่มีข้อมูล	`synonym = type`^[ข]
คอฟฟี่สคริปต์	`name = initial_value`	ไม่มีข้อมูล
เอส-ลัง	`name = initial_value;`		`typedef struct {...} typename`
ฟอร์ทราน	`type :: name`	`type, PARAMETER :: name = value`
พีพี	`$name = initial_value;`	`define("name", value);const name = value (5.3+)`	ไม่มีข้อมูล
เพิร์ล	`«my» $name« = initial_value»;`^[ค]	`use constant name => value;`	ไม่มีข้อมูล
ราคุ	`«my «type»» $name« = initial_value»;`^[ค]	`«my «type»» constant name = value;`	`::synonym ::= type`
ทับทิม	`name = initial_value`	`Name = value`	`synonym = type`^[ข]
สกาล่า	`var name«: type» = initial_value`	`val name«: type» = value`	`type synonym = type`
วินโดวส์ พาวเวอร์เชลล์	`«[type]» $name = initial_value`	ไม่มีข้อมูล	ไม่มีข้อมูล
เปลือกหอย	`name=initial_value`	ไม่มีข้อมูล	ไม่มีข้อมูล
โอแคมล์	`let name« : type ref» = ref value`^[ง]	`let name «: type» = value`	`type synonym = type`
เอฟ#	`let mutable name «: type» = value`	`let name «: type» = value`
มาตรฐาน ML	`val name «: type ref» = ref value`^[ง]	`val name «: type» = value`
ฮัสเคลล์		`«name::type;» name = value`	`type Synonym = type`
ไปข้างหน้า	`VARIABLE name`(ในบางระบบให้ใช้แทน) `value VARIABLE name`	`value CONSTANT name`
โคบอล	`level-number name type clauses.`	`«0»1 name CONSTANT «AS» value.`	`level-number name type clauses «IS» TYPEDEF.`
มาเทมาติกา	`name=initial_value`	ไม่มีข้อมูล	ไม่มีข้อมูล

ภาษาปาสคาลมีบล็อกการประกาศ ดูที่ฟังก์ชัน
^bประเภทต่างๆ ก็เป็นเพียงวัตถุทั่วไป ดังนั้นคุณสามารถกำหนดค่าให้กับมันได้เลย
ใน ภาษา Perl คำหลัก "my" จะกำหนดขอบเขตของตัวแปรให้อยู่ภายในบล็อก
ในทางเทคนิคแล้ว คำสั่งนี้ไม่ได้ประกาศnameเป็นตัวแปรที่เปลี่ยนแปลงได้—ใน ML นั้น name ทุกตัวสามารถผูกได้เพียงครั้งเดียวเท่านั้น—แต่เป็นการประกาศnameชี้ไปยังโครงสร้างข้อมูล "อ้างอิง" ซึ่งเป็นเซลล์ที่เปลี่ยนแปลงได้ง่ายๆ โครงสร้างข้อมูลนี้สามารถอ่านและเขียนได้โดยใช้!และ:=ตามลำดับ
^eหากไม่ได้ระบุค่าเริ่มต้น ระบบจะกำหนดค่าที่ไม่ถูกต้องให้โดยอัตโนมัติ (ซึ่งจะทำให้เกิดข้อผิดพลาดขณะรันไทม์หากใช้ก่อนที่จะมีการกำหนดค่าที่ถูกต้อง) แม้ว่าพฤติกรรมนี้จะสามารถระงับได้ แต่ขอแนะนำให้ระงับเพื่อความคาดเดาได้ หากไม่พบค่าที่ไม่ถูกต้องสำหรับประเภทข้อมูล (เช่น ในกรณีของประเภทจำนวนเต็มที่ไม่จำกัด) ระบบจะเลือกค่าที่ถูกต้องแต่คาดเดาได้แทน
ใน Rustหากไม่มีการกำหนดค่าเริ่มต้นให้กับletหรือ `let mutglobal` และไม่เคยมีการกำหนดค่าให้กับตัวแปรนั้นในภายหลัง จะมีคำเตือน "ตัวแปรไม่ได้ใช้งาน"หากไม่มีการระบุค่าให้กับconstหรือstaticหรือ `static mutglobal` จะเกิดข้อผิดพลาด นอกจากนี้ยังมี"ตัวแปรส่วนกลางที่ไม่ใช่ตัวพิมพ์ใหญ่"สำหรับตัวแปรที่ไม่ใช่ตัวพิมพ์ใหญ่constหลังจากที่กำหนดตัวแปรแล้วstatic mutจะสามารถกำหนดค่าให้กับตัวแปรได้เฉพาะในunsafeบล็อกหรือฟังก์ชัน

การควบคุมการไหล

ประโยคเงื่อนไข

	ถ้า	มิฉะนั้นถ้า	เลือกกรณี	นิพจน์เงื่อนไข
อาดา^{[ 1 ]}	`if condition then statements«else statements»end if`	`if condition₁ then statementselsif condition₂ then statements...«else statements»end if`	`case expression is when value_list₁ => statements when value_list₂ => statements ... «when others => statements»end case`	`(if condition₁ then expression₁«elsif condition₂ then expression₂»...else expression_n)`หรือ`(case expression is when value_list₁ => expression₁ when value_list₂ => expression₂ ... «when others => expression_n»)`
เมล็ดพันธุ์ 7	`if condition then statements«else statements»end if`	`if condition₁ then statementselsif condition₂ then statements...«else statements»end if`	`case expression of when set1 : statements ... «otherwise: statements»end case`
โมดูลา-2	`if condition then statements«else statements»end`	`if condition₁ then statementselsif condition₂ then statements...«else statements»end`	`case expression of caseLabelList : statements \| ... «else statements»end`
อัลโกล 68	`if condition then statements «else statements» fi`	`if condition then statements elif condition then statements fi`	`case switch in statements, statements«,... out statements» esac`	`( condition \| valueIfTrue \| valueIfFalse )`
ALGOL 68 (ฉบับย่อ)	`( condition \| statements «\| statements» )`	`( condition \| statements \|: condition \| statements )`	`( variable \| statements,... «\| statements» )`
เอพีแอล	`:If condition instructions«:Else instructions»:EndIf`	`:If condition instructions:ElseIf condition instructions...«:Else instructions»:EndIf`	`:Select expression :Case case1 instructions ... «:Else instructions»:EndSelect`	`{condition:valueIfTrue ⋄ valueIfFalse}`
ซี ( ซี99 )	`if (condition) instructions«else instructions»instructions`อาจเป็นข้อความเดียวหรือเป็นกลุ่มข้อความในรูปแบบ:`{ statements }`	`if (condition) instructionselse if (condition) instructions...«else instructions»`หรือ`if (condition) instructionselse { if (condition) instructions }`	`switch (variable) { case case1: instructions «; break;» ... «default: instructions»}`	`condition?valueIfTrue:valueIfFalse`
ออบเจกทีฟซี
ซี++ (STL)
ดี
ชวา
โค้ด JavaScript
พีพี
ซี#	`if (condition) instructions«else instructions»` `instructions`อาจเป็นข้อความเดียวหรือเป็นกลุ่มข้อความในรูปแบบ:`{ statements }`	`if (condition) instructionselse if (condition) instructions...«else instructions»`	`switch (variable){ case case₁: instructions «break_or_jump_statement» ... «default: instructions break_or_jump_statement»}` กรณีที่ไม่ว่างเปล่าทั้งหมดต้องลงท้ายด้วย คำสั่ง " `break`หรือ" `goto case`(กล่าวคือ ไม่อนุญาตให้ข้ามไปยังกรณีถัดไป) `default`กรณีดังกล่าวไม่จำเป็นต้องอยู่เป็นกรณีสุดท้าย	`condition?valueIfTrue:valueIfFalse`
คริสตัล	`if condition statementselse statementsend`	`if condition₁ statementselsif condition₂ statements...else statementsend`	`case valuewhen case₁instructionswhen case₂` `instructions...elseinstructionsend`	`condition ? true_val : false_val`
วินโดวส์ พาวเวอร์เชลล์	`if (condition) instruction«else instructions»`	`if (condition) { instructions }elseif (condition) { instructions }...«else { instructions }»`	`switch (variable) { case1{instructions «break;» } ... «default { instructions }»}`
ไป	`if condition {instructions}«else {instructions}»`	`if condition {instructions}else if condition {instructions}...«else {instructions}»`หรือ`switch { case condition: instructions ... «default: instructions»}`	`switch variable { case case₁: instructions ... «default: instructions»}`
สวิฟต์	`if condition {instructions}«else {instructions}»`	`if condition {instructions}else if condition {instructions}...«else {instructions}»`	`switch variable { case case₁: instructions ... «default: instructions»}`
เพิร์ล	`if (condition) {instructions}«else {instructions}»`หรือ`unless (notcondition) {instructions}«else {instructions}»`	`if (condition) {instructions}elsif (condition) {instructions}...«else {instructions}»`หรือ`unless (notcondition) {instructions}elsif (condition) {instructions}...«else {instructions}»`	`use feature "switch";...given (variable) { when (case₁) { instructions } ... «default { instructions }»}`	`condition?valueIfTrue:valueIfFalse`
แร็กเก็ต	`(when testexpression expressions)`หรือ`(unless condition expressions)`	`(cond` `[testexpression expressions]` `[testexpression expressions]...` `[else expressions])`	`(case expression [(case1) expressions]` `[(case2) expressions]...` `[else expressions])`	`(if testexpression expressioniftrue expressioniffalse)`
ราคุ	`if condition {instructions}«else {instructions}»`หรือ`unless notcondition {instructions}`	`if condition {instructions}elsif condition {instructions}...«else {instructions}`	`given variable { when case₁ { instructions } ... «default { instructions }»}`	`condition??valueIfTrue !! valueIfFalse`
ทับทิม	`if condition instructions«else instructions»`	`if condition instructionselsif condition instructions...«else instructions»end`	`case variable when case₁ instructions ... «else instructions»end`	`condition?valueIfTrue:valueIfFalse`
สกาล่า	`if (condition) {instructions}«else {instructions}»`	`if (condition) {instructions}else if (condition) {instructions}...«else {instructions}»`	`expression match { case pattern1 => expression case pattern2 => expression ... «case _ => expression»}`^[ข]	`if (condition) valueIfTrue else valueIfFalse`
การสนทนาเล็กๆ น้อยๆ	`condition ifTrue: trueBlock«ifFalse: falseBlock»end`			`condition ifTrue: trueBlock ifFalse: falseBlock`
ลิสปาร์กทั่วไป	`(when condition instructions)`หรือหรือ`(unless condition instructions)(if condition (progn instructions) «(progn instructions)»)`	`(cond (condition1 instructions) (condition2 instructions) ... «(t instructions)»)`	`(case expression (case1 instructions) (case2 instructions) ... «(otherwise instructions)»)`	`(if test then else)`หรือ`(cond (test1 value1) (test2 value2) ...))`
โครงการ	`(when condition instructions)`หรือ`(if condition (begin instructions) «(begin instructions)»)`	`(cond (condition1 instructions) (condition2 instructions) ... «(else instructions)»)`	`(case (variable) ((case1) instructions) ((case2) instructions) ... «(else instructions)»)`	`(if condition valueIfTrue valueIfFalse)`
ไอเอสลิสป์	`(if condition (progn instructions) «(progn instructions)»)`	`(cond (condition1 instructions) (condition2 instructions) ... «(t instructions)»)`	`(case expression (case1 instructions) (case2 instructions) ... «(t instructions)»)`	`(if condition valueIfTrue valueIfFalse)`
ปาสคาล	`if condition then begin instructionsend«else begin instructionsend»'`^[ค]	`if condition then begin instructionsendelse if condition then begin instructionsend...«else begin instructionsend»`^[ค]	`case variable of case1: instructions ... «else: instructions»end`^[ค]
วิชวลเบส	`If condition Then instructions«Else instructions»End If`บรรทัดเดียว เมื่อใดจึง`instructions`ใช้:`instruction₁ : instruction₂ : ...If condition Then instructions «Else instructions»`	`If condition Then instructionsElseIf condition Then instructions...«Else instructions»End If`บรรทัดเดียว: โปรดดูหมายเหตุเกี่ยวกับภาษาที่คล้าย C; `Else`ส่วนของคำสั่งบรรทัดเดียว สามารถมี คำสั่ง `If`บรรทัดเดียวอื่นอยู่ภายในได้`If`	`Select« Case» variable Case case_pattern₁ instructions ... «Case Else instructions»End Select`	`IIf(condition, valueIfTrue, valueIfFalse)`
Visual Basic .NET				`If(condition, valueIfTrue, valueIfFalse)`
โซโจ				`If(condition, valueIfTrue, valueIfFalse)`
ไพธอน^[a]	`if condition :Tab ↹instructions«else:Tab ↹instructions»`	`if condition :Tab ↹instructionselif condition :Tab ↹instructions...«else:Tab ↹instructions»`	Python 3.10 ขึ้นไป:`match variable:Tab ↹case case1:Tab ↹Tab ↹instructionsTab ↹case case2:Tab ↹Tab ↹instructions`	Python 2.5 ขึ้นไป:`valueIfTrue if condition else valueIfFalse`
เอส-ลัง	`if (condition) { instructions } «else { instructions }»`	`if (condition) { instructions } else if (condition) { instructions } ... «else { instructions }»`	`switch (variable) { case case1: instructions } { case case2: instructions } ...`
ฟอร์ทราน	`IF (condition) THEN instructionsELSE instructionsENDIF`	`IF (condition) THEN instructionsELSEIF (condition) THEN instructions...ELSE instructionsENDIF`	`SELECT CASE(variable) CASE (case1) instructions ... CASE DEFAULT instructionsEND SELECT`
ไปข้างหน้า	`condition IF instructions « ELSE instructions» THEN`	`condition IF instructions ELSE condition IF instructions THEN THEN`	`value CASE case OF instructions ENDOF case OF instructions ENDOF default instructionsENDCASE`	`condition IF valueIfTrue ELSE valueIfFalse THEN`
โอแคมล์	`if condition then begin instructions end «else begin instructions end»`	`if condition then begin instructions end else if condition then begin instructions end ... «else begin instructions end»`	`match value with pattern1 -> expression \| pattern2 -> expression ... «\| _ -> expression»`^[ข]	`if condition then valueIfTrue else valueIfFalse`
เอฟ#	โหมดไวยากรณ์แบบเบา: สามารถเขียนได้ทั้งแบบบรรทัดเดียวหรือแบบเว้นวรรคตามที่แสดงด้านล่าง: โหมดไวยากรณ์แบบละเอียด: เหมือนกับ ML มาตรฐาน `if condition thenTab ↹instructions«elseTab ↹instructions»`	โหมดไวยากรณ์แบบเบา: เขียนได้ทั้งแบบบรรทัดเดียวหรือแบบมีเยื้องตามที่แสดงด้านล่างโหมดไวยากรณ์แบบละเอียด: เหมือนกับ ML มาตรฐาน `if condition thenTab ↹instructionselif condition thenTab ↹instructions...«elseTab ↹instructions»`
มาตรฐาน ML	`if condition then «(»instructions «)»else «(» instructions «)»`	`if condition then «(»instructions «)»else if condition then «(» instructions «)»...else «(» instructions «)»`	`case value of pattern1 => expression \| pattern2 => expression ... «\| _ => expression»`^[ข]
ฮัสเคลล์ ( GHC )	`if condition then expression else expression`หรือหรือ`when condition (do instructions)unless notcondition (do instructions)`	`result \| condition = expression \| condition = expression \| otherwise = expression`	`case value of { pattern1 -> expression; pattern2 -> expression; ... «_ -> expression»}`^[ข]
เปลือกหอย	`if condition-command; then expression«else expression»fi`	`if condition-command; then expressionelif condition-command; then expression«else expression»fi`	`case "$variable" in "$condition1" ) command... "$condition2" ) command...esac`
คอฟฟี่สคริปต์	`if condition then expression «else expression»`หรือหรือหรือหรือ`if condition expression«else expression»expression if conditionunless condition expression«else expression»expression unless condition`	`if condition then expression else if condition then expression «else expression»`หรือหรือ`if condition expressionelse if condition expression«else expression»unless condition expressionelse unless condition expression«else expression»`	`switch expression when condition then expression else expression`หรือ`switch expression when condition expression «else expression»`	เงื่อนไขทั้งหมดเป็นนิพจน์
โคบอล	`IF condition «THEN» expression«ELSE expression».`^[ง]		`EVALUATE expression «ALSO expression...» WHEN case-or-condition «ALSO case-or-condition...» expression ... «WHEN OTHER expression»END-EVALUATE`
สนิม	`if condition { expression}« else { expression}»`	`if condition { expression} else if condition { expression}« else { expression}»`	`match variable { pattern1 => expression, pattern2 => expression, pattern3 => expression, «_ => expression»}`^{[เป็น}^]	เงื่อนไขทั้งหมดเป็นนิพจน์
	ถ้า	มิฉะนั้นถ้า	เลือกกรณี	นิพจน์เงื่อนไข

^aคำสั่งเดียวสามารถเขียนได้ในบรรทัดเดียวกันหลังเครื่องหมายโคลอน คำสั่งหลายคำสั่งจะถูกจัดกลุ่มไว้ด้วยกันในบล็อกซึ่งขึ้นบรรทัดใหม่ (จำเป็นต้องมีการเว้นวรรค) ไวยากรณ์ของนิพจน์เงื่อนไขไม่เป็นไปตามกฎนี้
^bนี่คือการจับคู่รูปแบบซึ่งคล้ายกับ select case แต่ไม่เหมือนกันเสียทีเดียว โดยปกติแล้วจะใช้ในการแยกส่วนข้อมูลเชิงพีชคณิต
^cในภาษาตระกูลปาสคาล เครื่องหมายเซมิโคลอนไม่ได้เป็นส่วนหนึ่งของประโยค แต่เป็นตัวคั่นระหว่างประโยค ไม่ใช่ตัวจบประโยค
สามารถใช้ ^dEND-IFแทนจุดท้ายประโยคได้
ใน Rust สามารถละเว้น เครื่องหมายจุลภาค (,) ที่ส่วนท้ายของเงื่อนไขการจับคู่ได้หลังจากเงื่อนไขการจับคู่สุดท้าย หรือหลังจากเงื่อนไขการจับคู่ใดๆ ที่นิพจน์เป็นบล็อก (ลงท้ายด้วยวงเล็บที่อาจว่างเปล่า{})

คำสั่งวนซ้ำ

	ลูป while	วนลูป do while	ลูป (ควบคุมการนับ)	สำหรับแต่ละ
อาดา^{[ 1 ]}	`while condition loop statementsend loop`	`loop statements exit when not conditionend loop`	`for index in «reverse» [first .. last \| discrete_type] loop statementsend loop`	`for item of «reverse» iterator loop statementsend loop`หรือ^[b]`(for [all \| some] [in \| of] [first .. last \| discrete_type \| iterator] => predicate)`
อัลโกล 68	`«for index» «from first» «by increment» «to last» «while condition» do statements od`			`for key «to upb list» do «typename val=list[key];» statements od`
อัลโกล 68	`«while condition» do statements od`	`«while statements; condition» do statements od`	`«for index» «from first» «by increment» «to last» do statements od`
เอพีแอล	`:While condition statements:EndWhile`	`:Repeat statements:Until condition`	`:For var«s» :In list statements:EndFor`	`:For var«s» :InEach list statements:EndFor`
ซี ( ซี99 )	`instructions`อาจเป็นข้อความเดียวหรือเป็นกลุ่มข้อความในรูปแบบ:`{ statements }while (condition) instructions`	`do instructions while (condition);`	`for («type» i = first; i <= last; i++) instructions`	ไม่มีข้อมูล
ออบเจกทีฟซี				`for (type item in set) instructions`
ซี++ (STL)				`«std::»for_each(start, end, function)`ตั้งแต่C++11 เป็นต้นมา :`for (type item : set) instructions`
ซี#				`foreach (type item in set) instructions`
ชวา				`for (type item : set) instructions`
โค้ด JavaScript			`for (var i = first; i <= last; i++) instructions`	ตั้งแต่EcmaScript 2015: ^{[ 11 ]} `for (var item of set) instructions`
พีพี			`foreach (range(first, last) as $i) instructions`หรือ`for ($i = first; $i <= last; $i++) instructions`	`foreach (set as item) instructions`หรือ`foreach (set as key => item) instructions`
วินโดวส์ พาวเวอร์เชลล์			`for ($i = first; $i -le last; $i++) instructions`	`foreach (item in set) instructions`
ดี			`foreach (i; first ... last) instructions`	`foreach («type» item; set) instructions`
ไป	`for condition { instructions }`		`for i := first; i <= last; i++ { instructions }`	`for key, item := range set { instructions }`
สวิฟต์	`while condition { instructions }`	2.x: 1.x:`repeat { instructions } while conditiondo { instructions } while condition`	`for i = first ... last { instructions }`หรือหรือ`for i = first ..< last+1 { instructions }for var i = first; i <= last; i++ { instructions }`	`for item in set { instructions }`
เพิร์ล	`while (condition) { instructions }`หรือ`until (notcondition) { instructions }`	`do { instructions } while (condition)`หรือ`do { instructions } until (notcondition)`	`for«each» «$i» (first .. last) { instructions }`หรือ`for ($i = first; $i <= last; $i++) { instructions }`	`for«each» «$item» (set) { instructions }`
ราคุ	`while condition { instructions }`หรือ`until notcondition { instructions }`	`repeat { instructions } while condition`หรือ`repeat { instructions } until notcondition`	`for first..last -> $i { instructions }`หรือ`loop ($i = first; $i <=last; $i++) { instructions }`	`for set« -> $item» { instructions }`
ทับทิม	`while condition instructionsend`หรือ`until notcondition instructionsend`	`begin instructionsend while condition`หรือ`begin instructionsend until notcondition`	`for i in first..last instructionsend`หรือหรือ`for i in first...last+1 instructionsendfirst.upto(last) { \|i\| instructions }`	`for item in set instructionsend`หรือ`set.each { \|item\| instructions }`
เปลือกหอย	`while condition ;do instructionsdone`หรือ`until notcondition ;do instructionsdone`	ไม่มีข้อมูล	`for ((i = first; i <= last; ++i)) ; do instructionsdone`	`for item in set ;do instructionsdone`
สกาล่า	`while (condition) { instructions }`	`do { instructions } while (condition)`	`for (i <- first to last «by 1») { instructions }`หรือ`first to last «by 1» foreach (i => { instructions })`	`for (item <- set) { instructions }`หรือ`set foreach (item => { instructions })`
การสนทนาเล็กๆ น้อยๆ	`conditionBlock whileTrue: loopBlock`	`loopBlock doWhile: conditionBlock`	`first to: last do: loopBlock`	`collection do: loopBlock`
ลิสปาร์กทั่วไป	`(loop while condition do instructions)`หรือ`(do () (notcondition) instructions)`	`(loop do instructions while condition)`	`(loop for i from first to last «by 1» do instructions)`หรือหรือ`(dotimes (i N) instructions)(do ((i first(1+i)))((>=ilast)) instructions)`	`(loop for item in list do instructions)`หรือหรือหรือหรือ`(loop for item across vector do instructions)(dolist (item list) instructions)(mapc function list)(map type function sequence)`
โครงการ	`(do () (notcondition) instructions)`หรือ`(letloop()(ifcondition (begin instructions (loop))))`	`(letloop()(instructions (if condition (loop))))`	`(do ((i first(+i1)))((>=ilast)) instructions)`หรือ`(letloop((ifirst1))(if(<ilast) (begin instructions(loop(+i1)))))`	`(for-each(lambda(item) instructions) list)`
ไอเอสลิสป์	`(while condition instructions)`	`(tagbodyloopinstructions (if condition(goloop))`	`(for((ifirst(+i1)))((>=ilast)) instructions)`	`(mapc(lambda(item) instructions) list)`
ปาสคาล	`while condition do begin instructionsend`	`repeat instructionsuntil notcondition;`	`for i := first «step 1» to last do begin instructionsend;`^[ก]	`for item in set do instructions`
วิชวลเบส	`Do While condition instructionsLoop`หรือหรือ(Visual Basic .NET ใช้แทน) `Do Until notcondition instructionsLoopWhile condition instructionsWendEnd While`	`Do instructionsLoop While condition`หรือ`Do instructionsLoop Until notcondition`	`i`ต้องแจ้งให้ทราบล่วงหน้า `For i = first To last «Step 1» instructionsNext i`	`For Each item In set instructionsNext item`
Visual Basic .NET			`For i« As type» = first To last« Step 1» instructionsNext« i»`^[ก]	`For Each item« As type» In set instructionsNext« item»`
โซโจ	`While condition instructionsWend`	`Do Until notcondition instructionsLoop`หรือ`Do instructionsLoop Until notcondition`		`For Each item« As type» In set instructionsNext« item»`
ไพธอน	`while condition :Tab ↹instructions«else:Tab ↹instructions»`	ไม่มีข้อมูล	Python 3.x: Python 2.x:`foriinrange(first, last+1):Tab ↹instructions«else:Tab ↹instructions»foriinxrange(first, last+1):Tab ↹instructions«else:Tab ↹instructions»`	`for item in set:Tab ↹instructions«else:Tab ↹instructions»`
เอส-ลัง	`while (condition) { instructions } «then optional-block»`	`do { instructions } while (condition) «then optional-block»`	`for (i = first; i <= last; i++) { instructions } «then optional-block»`	`foreach item(set) «using (what)» { instructions } «then optional-block»`
ฟอร์ทราน	`DO WHILE (condition) instructionsENDDO`	`DO instructions IF (condition) EXITENDDO`	`DO I = first,last instructionsENDDO`	ไม่มีข้อมูล
ไปข้างหน้า	`BEGIN «instructions» condition WHILE instructions REPEAT`	`BEGIN instructions condition UNTIL`	`limit start DO instructions LOOP`	ไม่มีข้อมูล
โอแคมล์	`while condition do instructions done`	ไม่มีข้อมูล	`for i = first to last do instructions done`	`Array.iter (fun item -> instructions) array`หรือ`List.iter (fun item -> instructions) list`
เอฟ#	`while condition doTab ↹instructions`	ไม่มีข้อมูล	`for i = first to last doTab ↹instructions`	`for item in set doTab ↹instructions`หรือ`Seq.iter (fun item -> instructions) set`
มาตรฐาน ML	`while condition do ( instructions )`	ไม่มีข้อมูล		`Array.app (fn item => instructions) array`หรือ`app (fn item => instructions) list`
ฮัสเคลล์ ( GHC )	ไม่มีข้อมูล		`Control.Monad.forM_ [first..last] (\i -> do instructions)`	`Control.Monad.forM_list (\item -> do instructions)`
หอไอเฟล	`from setupuntil conditionloop instructionsend`
คอฟฟี่สคริปต์	`while condition expression`หรือหรือหรือหรือหรือ`expression while conditionwhile condition then expressionuntil condition expressionexpression until conditionuntil expression then condition`	ไม่มีข้อมูล	`for i in [first..last] expression`หรือหรือ`for i in [first..last] then expressionexpression for i in [first..last]`	`for item in set expression`หรือหรือ`for item in set then expressionexpression for item in set`
โคบอล	`PERFORM procedure-1 «THROUGH procedure-2» ««WITH»TESTBEFORE»UNTILcondition`^[ค]หรือ`PERFORM ««WITH»TESTBEFORE»UNTILcondition expressionEND-PERFORM`	`PERFORM procedure-1 «THROUGH procedure-2» «WITH»TESTAFTERUNTILcondition`^[ค]หรือ`PERFORM «WITH»TESTAFTERUNTILcondition expressionEND-PERFORM`	`PERFORM procedure-1 «THROUGH procedure-2» VARYING i FROM first BY increment UNTIL i > last`^[d]หรือ^[d]`PERFORM VARYING i FROM first BY increment UNTIL i > last expressionEND-PERFORM`	ไม่มีข้อมูล
สนิม	`while condition { expression}`	`loop { expression if condition { break; }}`	`for i in first..last+1 { expression}`หรือ`for i in first..=last { expression}`	`for item in set { expression}`^[e]หรือ^[e]`set.into_iter().for_each(\|item\| expression);`

^a "stepn" ใช้สำหรับเปลี่ยนช่วงเวลาการวนซ้ำ หากstepละเว้น " " ช่วงเวลาการวนซ้ำจะเป็น 1
^bนี่เป็นการนำตัวบ่งปริมาณสากล("สำหรับทั้งหมด" หรือ $\forall$ ) และตัวบ่งปริมาณเชิงการมีอยู่ ("มีอยู่" หรือ $\exists$ )
THRUสามารถใช้ ^cTHROUGH แทน .
สามารถใช้ ^d แทน .«IS»GREATER «THAN»>
^eประเภทของนิพจน์เซตต้องใช้งาน traitstd::iter::IntoIterator.

ข้อยกเว้น

	โยน	แฮนด์เลอร์	การยืนยัน
อาดา^{[ 1 ]}	`raise exception_name «with string_expression»`	`begin statementsexception when exception_list₁ => statements; when exception_list₂ => statements;... «when others => statements;»end`^[ข]	`pragmaAssert («Check =>» boolean_expression ««Message =>» string_expression»)[function \| procedure \| entry] with Pre => boolean_expression Post => boolean_expressionany_type with Type_Invariant => boolean_expression`
เอพีแอล	`«string_expression» ⎕SIGNAL number_expression`	`:Trap number«s»_expression statements«:Case number«s»_expression statements»...«:Else number«s»_expression statements»:EndTrap`	`«string_expression»⎕SIGNAL98/⍨~condition`
ซี ( ซี99 )	`longjmp(state, exception);`	`switch (setjmp(state)) { case 0: instructions break; case exception: instructions ... }`	`assert(condition);`
ซี++	`throw exception;`	`try { instructions } catch «(exception)» { instructions } ...`	`assert(condition);`
ซี#		`try { instructions } catch «(exception« name»)» { instructions } ... «finally { instructions }»`	`System.Diagnostics.Debug.Assert(condition);`หรือ`System.Diagnostics.Trace.Assert(condition);`
ชวา		`try { instructions } catch (exception) { instructions } ... «finally { instructions }»`	`assert condition «: description»;`
โค้ด JavaScript		`try { instructions } catch (exception) { instructions} «finally { instructions }»`	?
ดี		`try { instructions } catch (exception) { instructions } ... «finally { instructions }»`	`assert(condition);`
พีพี		`try { instructions } catch (exception) { instructions } ... «finally { instructions }»`	`assert(condition);`
เอส-ลัง		`try { instructions } catch «exception» { instructions } ... «finally { instructions }»`	?
วินโดวส์ พาวเวอร์เชลล์		`trap «[exception]» { instructions } ... instructions`หรือ`try { instructions } catch «[exception]» { instructions } ... «finally { instructions }»`	`[Debug]::Assert(condition)`
ออบเจกทีฟซี	`@throw exception;`	`@try { instructions } @catch (exception) { instructions } ... «@finally { instructions }»`	`NSAssert(condition, description);`
คริสตัล	`raise exception.new`	`begin` `instructionsrescue exceptioninstructions...elseinstructionsensureinstructionsend`
สวิฟต์	`throw exception`(2.x)	`do { try expression ... instructions } catch exception { instructions } ...`(2.x)	`assert(condition«, description»)`
เพิร์ล	`die exception;`	`eval { instructions};if($@){instructions }`	?
ราคุ	`die exception;`	`try { instructions CATCH { when exception { instructions } ...}}`	?
ทับทิม	`raise exception`	`begin instructionsrescue exception instructions...«else instructions»«ensure instructions»end`
การสนทนาเล็กๆ น้อยๆ	`exception raise`	`instructionBlock on: exception do: handlerBlock`	`assert: conditionBlock`
ลิสปาร์กทั่วไป	`(error "exception")`หรือหรือ`(error type arguments)(error (make-condition type arguments))`	`(handler-case (progn instructions) (exception instructions) ...)`หรือ^[ก]`(handler-bind (condition (lambda instructions «invoke-restart restart args»))...)`	`(assert condition)`หรือหรือ`(assert condition «(place) «error»»)(check-type var type)`
โครงการ ( R ⁶ RS )	`(raise exception)`	`(guard (con (condition instructions) ...) instructions)`	?
ไอเอสลิสป์	`(error "error-string" objects)`หรือ`(signal-condition condition continuable)`	`(with-handler handler form*)`	?
ปาสคาล	`raise Exception.Create()`	`try Except on E: exception do begin instructions end; end;`	?
วิชวลเบส	`Err.Raise ERRORNUMBER`	`WithNewTry:OnErrorResumeNext OneInstruction.Catch:OnErrorGoTo0:SelectCase.Number Case SOME_ERRORNUMBER instructionsEndSelect:EndWith` '* คลาส Try * Private mstrDescription As String Private mlngNumber As LongPublic Sub Catch () mstrDescription = Err . Description mlngNumber = Err . Number End Subคุณสมบัติสาธารณะรับหมายเลข() เป็นหมายเลขยาว= mlngNumber สิ้นสุดคุณสมบัติคุณสมบัติสาธารณะรับคำอธิบาย() เป็นสตริงคำอธิบาย= mstrDescription สิ้นสุดคุณสมบัติ ^{[ 12 ]}	`Debug.Assert condition`
Visual Basic .NET	`Throw exception`หรือ`Error errorcode`	`Try instructionsCatch« name As exception»« When condition» instructions...«Finally instructions»End Try`	`System.Diagnostics.Debug.Assert(condition)`หรือ`System.Diagnostics.Trace.Assert(condition)`
โซโจ	`Raise exception`	`Try instructionsCatch «exception» instructions...«Finally instructions»End Try`	ไม่มีข้อมูล
ไพธอน	`raise exception`	`try:Tab ↹instructionsexcept «exception»:Tab ↹instructions...«else:Tab ↹instructions»«finally:Tab ↹instructions»`	`assert condition`
ฟอร์ทราน	ไม่มีข้อมูล
ไปข้างหน้า	`code THROW`	`xt CATCH ( code or 0 )`	ไม่มีข้อมูล
โอแคมล์	`raise exception`	`try expression with pattern -> expression ...`	`assert condition`
เอฟ#	`raise exception`	`try expression with pattern -> expression ...`หรือ`try expression finally expression`	`assert condition`
มาตรฐาน ML	`raise exception «arg»`	`expression handle pattern => expression ...`
ฮัสเคลล์ ( GHC )	`throw exception`หรือ`throwError expression`	`catch tryExpression catchExpression`หรือ`catchError tryExpression catchExpression`	`assert condition expression`
โคบอล	`RAISE «EXCEPTION»exception`	`USE «AFTER»EXCEPTIONOBJECTclass-name.`หรือหรือหรือ`USE «AFTER»EOclass-name.USE «AFTER»EXCEPTIONCONDITIONexception-name «FILE file-name».USE «AFTER»ECexception-name «FILE file-name».`	ไม่มีข้อมูล
สนิม	หมายเลข^{[ 13 ]}		`assert!(condition)`

ภาษา Common Lisp อนุญาตให้with-simple-restartกำหนดการเริ่มต้นใหม่เพื่อใช้กับเงื่อนไขที่ไม่ได้รับการจัดการอาจทำให้การใช้งานแสดงเมนูการเริ่มต้นใหม่แก่ผู้ใช้ก่อนที่จะคลายสแต็กrestart-caserestart-bindinvoke-restart
^bข้อผิดพลาดที่ไม่ได้รับการจัดการจะถูกส่งต่อไปยังการดำเนินการแบบไดนามิกที่อยู่ภายในสุด ข้อผิดพลาดจะไม่ถูกส่งต่อระหว่างงานต่างๆ (เว้นแต่ว่างานเหล่านั้นจะถูกซิงโครไนซ์ในการนัดพบกันอยู่แล้ว)

คำสั่งควบคุมการไหลอื่นๆ

	บล็อกทางออก (เบรก)	ดำเนินการต่อ	ฉลาก	สาขา ( goto )	ค่าส่งคืนจากตัวสร้าง
อาดา^{[ 1 ]}	`exit «loop_name» «when condition»`	ไม่มีข้อมูล	`label:`	`goto label`	ไม่มีข้อมูล
อัลโกล 68	`value exit;`...	`do statements; skip exit; label: statements od`	`label:`...	`go to label; ...goto label; ...label; ...`	`yield(value)` ( การเรียกกลับ ) ^{[ 14 ]}
เอพีแอล	`:Leave`	`:Continue`	`label:`	`→label`หรือ`:GoTo label`	ไม่มีข้อมูล
ซี ( ซี99 )	`break;`	`continue;`	`label:`	`goto label;`	ไม่มีข้อมูล
ออบเจกทีฟซี
ซี++ (STL)
ดี
ซี#					`yield return value;`
ชวา	`break «label»;`	`continue «label»;`		ไม่มีข้อมูล
โค้ด JavaScript	`break «label»;`	`continue «label»;`		ไม่มีข้อมูล	`yield value«;»`
พีพี	`break «levels»;`	`continue «levels»;`		`goto label;`	`yield «key =>» value;`
เพิร์ล	`last «label»;`	`next «label»;`
ราคุ	`last «label»;`	`next «label»;`
ไป	`break «label»`	`continue «label»`		`goto label`
สวิฟต์	`break «label»`	`continue «label»`		ไม่มีข้อมูล
เปลือกหอย	`break «levels»`	`continue «levels»`	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
ลิสปาร์กทั่วไป	`(return)`หรือหรือ`(return-from block)(loop-finish)`		`(tagbody tag ... tag...)`	`(go tag)`
คริสตัล	`break`	`next`	ค่าการเรียงลำดับข้อมูล="" สไตล์="พื้นหลัง: var(--background-color-interactive, #ececec); สี: var(--color-base, inherit); จัดแนวตั้ง: ตรงกลาง; จัดแนวข้อความ: ตรงกลาง; " คลาส="table-na" \| ไม่มีข้อมูล		`yield value`
โครงการ
ไอเอสลิสป์	`(return-from block)`		`(tagbody tag ... tag...)`	`(go tag)`
ปาสคาล (ISO)	ไม่มีข้อมูล		`label:`^[ก]	`goto label;`	ไม่มีข้อมูล
ปาสคาล ( FPC )	`break;`	`continue;`	`label:`^[ก]	`goto label;`
วิชวลเบส	`Exit block`หรืออีกทางเลือกหนึ่ง สำหรับวิธีการต่างๆ`Return`	ไม่มีข้อมูล	`label:`	`GoTo label`
โซโจ		`Continue block`
Visual Basic .NET		`Continue block`			`Yield value`
ไพธอน	`break`	`continue`	ไม่มีข้อมูล		`yield value`
RPG IV	`LEAVE;`	`ITER;`
เอส-ลัง	`break;`	`continue;`
ฟอร์ทราน	`EXIT`	`CYCLE`	`label`^[ข]	`GOTO label`	ไม่มีข้อมูล
ทับทิม	`break`	`next`
วินโดวส์ พาวเวอร์เชลล์	`break «label»`	`continue`
โอแคมล์	ไม่มีข้อมูล
เอฟ#
มาตรฐาน ML
ฮัสเคลล์ ( GHC )
โคบอล	`EXIT PERFORM`หรือ`EXIT PARAGRAPH`หรือ`EXIT SECTION`หรือ`EXIT.`	`EXIT PERFORM CYCLE`	`label «SECTION».`	`GO TO label`	ไม่มีข้อมูล

ภาษาปาสคาลมีบล็อกการประกาศ ดูที่ฟังก์ชัน
^b label ต้องเป็นตัวเลขระหว่าง 1 ถึง 99999

ฟังก์ชัน

ดูการเขียนโปรแกรมแบบสะท้อนกลับ (reflective programming)สำหรับการเรียกและการประกาศฟังก์ชันโดยใช้สตริง

	การเรียกใช้ฟังก์ชัน	ฟังก์ชันพื้นฐาน/ว่างเปล่า	ฟังก์ชันส่งคืนค่า	ฟังก์ชันหลักที่จำเป็น
อาดา^{[ 1 ]}	`foo «(parameters)»`	`procedure foo «(parameters)» is begin statements end foo`	`function foo «(parameters)» return type is begin statements end foo`	ไม่มีข้อมูล
อัลโกล 68	`foo «(parameters)»;`	`proc foo = «(parameters)»void: ( instructions );`	`proc foo = «(parameters)» rettype: ( instructions ...; retvalue );`	ไม่มีข้อมูล
เอพีแอล	`«parameters» foo parameters`	`foo←{ statements }`	`foo←{ statements }`	ไม่มีข้อมูล
ซี ( ซี99 )	`foo(«parameters»)`	`voidfoo(«parameters») { instructions }`	`typefoo(«parameters») { instructions ... return value; }`	`«global declarations»intmain(«intargc,char*argv[]») { instructions}`
ออบเจกทีฟซี
ซี++ (STL)
ชวา				`publicstaticvoidmain(String[]args) { instructions }`หรือ`publicstaticvoidmain(String... args) { instructions }`
ดี				`intmain(«char[][]args») { instructions}`หรือหรือหรือ`intmain(«string[]args») { instructions}voidmain(«char[][]args») { instructions}voidmain(«string[]args») { instructions}`
ซี#		เช่นเดียวกับข้างต้น หรือหากต้องการข้อความเพียงข้อเดียว: `void foo(«parameters») => statement;`	เช่นเดียวกับข้างต้น หรืออีกทางเลือกหนึ่ง หากง่ายพอที่จะเป็นการแสดงออก: `void foo(«parameters») => expression;`	`staticvoidMain(«string[]args»)method_body`อาจส่งคืนค่าอื่นแทน`int`( เริ่มตั้งแต่ C# 7.1:) อาจส่งคืนค่า`Task`หรือและถ้าเป็นเช่นนั้น อาจเป็น `Task<int>async`
โค้ด JavaScript		`function foo(«parameters») { instructions }`หรือหรือ`varfoo=function(«parameters») { instructions }varfoo=newFunction("«parameter»", ..., "«last parameter»" "instructions");`	`function foo(«parameters») { instructions ... return value; }`	ไม่มีข้อมูล
ไป		`func foo(«parameters») { instructions }`	`funcfoo(«parameters») type { instructions ... return value }`	`funcmain(){\|goinstructions }`
สวิฟต์		`funcfoo(«parameters») { instructions }`	`funcfoo(«parameters») -> type { instructions ... return value }`	ไม่มีข้อมูล
คริสตัล	`foo(parameters)` หรือ `foo parameters`^[f]	`def foo(parameters)` `instructionsend`	`def foo(parameters) : type` `instructionsreturn_valueend`^[e]	ไม่มีข้อมูล
ลิสปาร์กทั่วไป	`(foo «parameters»)`	`(defun foo («parameters») instructions)`หรือ`(setf(symbol-function'symbol) function)`	`(defun foo («parameters») ... value)`	ไม่มีข้อมูล
โครงการ		`(define (foo parameters) instructions)`หรือ`(define foo (lambda (parameters) instructions))`	`(define (foo parameters) instructions... return_value)`หรือ`(define foo (lambda (parameters) instructions... return_value))`
ไอเอสลิสป์		`(defun foo («parameters») instructions)`	`(defun foo («parameters») ... value)`
ปาสคาล	`foo«(parameters)»`	`procedure foo«(parameters)»; «forward;»^[a]«label label declarations»«const constant declarations»«type type declarations»«var variable declarations»«local function declarations»begin instructionsend;`	`function foo«(parameters)»: type; «forward;»^[a]«label label declarations»«const constant declarations»«type type declarations»«var variable declarations»«local function declarations»begin instructions; foo := valueend;`	`program name;«label label declarations»«const constant declarations»«type type declarations»«var variable declarations»«function declarations»begin instructionsend.`
วิชวลเบส	`Foo(«parameters»)`	`Sub Foo«(parameters)» instructionsEnd Sub`	`Function Foo«(parameters)»« As type» instructions Foo = valueEnd Function`	`Sub Main() instructionsEnd Sub`
Visual Basic .NET			เช่นเดียวกับข้างต้น หรืออีกทางเลือกหนึ่ง: `Function Foo«(parameters)»« As type» instructions Return valueEnd FunctionAs`ไม่จำเป็นต้องใช้ข้อความนี้ หาก `Option Strict`ปิดอยู่ สามารถใช้ตัวอักขระระบุประเภทแทน`As`ข้อความ นี้ได้ หากการควบคุมออกจากฟังก์ชันโดยไม่ได้ระบุค่าส่งคืนอย่างชัดเจน ฟังก์ชันจะส่งคืนค่าเริ่มต้นสำหรับประเภทการส่งคืน	`SubMain(««ByVal»args()AsString») instructionsEnd Sub`หรือ`FunctionMain(««ByVal»args()AsString»)AsInteger instructionsEnd Function`
โซโจ
ไพธอน	`foo(«parameters»)`	`def foo(«parameters»):Tab ↹instructions`	`def foo(«parameters»):Tab ↹instructionsTab ↹return value`	ไม่มีข้อมูล
เอส-ลัง	`foo(«parameters» «;qualifiers»)`	`define foo («parameters») { instructions }`	`define foo («parameters») { instructions ... return value; }`	`public define slsh_main () { instructions }`
ฟอร์ทราน	`foo («arguments»)CALL sub_foo («arguments»)`^[ค]	`SUBROUTINE sub_foo («arguments») instructionsEND SUBROUTINE`^[ค]	`type FUNCTION foo («arguments») instructions ... foo = valueEND FUNCTION`^[ค]	`PROGRAM main instructionsEND PROGRAM`
ไปข้างหน้า	`«parameters» FOO`	`:FOO«stackeffectcomment: ( before -- ) » instructions;`	`:FOO«stackeffectcomment: ( before -- after ) » instructions;`	ไม่มีข้อมูล
พีพี	`foo(«parameters»)`	`function foo(«parameters») { instructions }`	`function foo(«parameters») { instructions ... return value; }`	ไม่มีข้อมูล
เพิร์ล	`foo(«parameters»)`หรือ`&foo«(parameters)»`	`subfoo{«my(parameters) = @_;» instructions }`	`subfoo{«my(parameters) = @_;» instructions... «return» value; }`
ราคุ	`foo(«parameters»)`หรือ`&foo«(parameters)»`	`«multi »subfoo(parameters) { instructions }`	`«our «type» »«multi »subfoo(parameters) { instructions ... «return» value; }`
ทับทิม	`foo«(parameters)»`	`def foo«(parameters)» instructionsend`	`def foo«(parameters)» instructions «return» valueend`
สนิม	`foo(«parameters»)`	`fn foo(«parameters») { instructions }`	`fn foo(«parameters») -> type { instructions }`	`fn main() { instructions }`
สกาล่า	`foo«(parameters)»`	`def foo«(parameters)»«: Unit =» { instructions }`	`def foo«(parameters)»«: type» = { instructions ... «return» value }`	`defmain(args:Array[String]) { instructions }`
วินโดวส์ พาวเวอร์เชลล์	`foo «parameters»`	`function foo { instructions };`หรือ`function foo { «param(parameters)» instructions }`	`function foo «(parameters)» { instructions ... return value };`หรือ`function foo { «param(parameters)» instructions ... return value }`	ไม่มีข้อมูล
เปลือกหอย	`foo «parameters»`	`function foo { instructions}`หรือ`foo () { instructions}`	`function foo { instructions return «exit_code»}`หรือ`foo () { instructions return «exit_code»}`
เปลือกหอย	`foo «parameters»`	พารามิเตอร์ `$n`( 1 ดอลลาร์ , 2 ดอลลาร์ , 3 ดอลลาร์ , ... ) `$@`(พารามิเตอร์ทั้งหมด) `$#`(จำนวนพารามิเตอร์) `$0`(ชื่อฟังก์ชันนี้)
โอแคมล์	`foo parameters`	`let «rec» foo parameters = instructions`	`let «rec» foo parameters = instructions... return_value`
เอฟ#		`let «rec» foo parameters = instructions`	`let «rec» foo parameters = instructions... return_value`	`[<EntryPoint>]letmainargs = instructions`
มาตรฐาน ML		`fun foo parameters = ( instructions )`	`fun foo parameters = ( instructions... return_value )`
ฮัสเคลล์		`foo parameters = doTab ↹instructions`	`foo parameters = return_value`หรือ`foo parameters = doTab ↹instructionsTab ↹return value`	`«main::IO()»main = do instructions`
หอไอเฟล	`foo («parameters»)`	`foo («parameters») require preconditions do instructions ensure postconditions end`	`foo («parameters»): type require preconditions do instructions Result := value ensure postconditions end`	^[ข]
คอฟฟี่สคริปต์	`foo()`	`foo=->`	`foo=->value`	ไม่มีข้อมูล
คอฟฟี่สคริปต์	`foo parameters`	`foo=() ->`	`foo = ( parameters ) -> value`	ไม่มีข้อมูล
โคบอล	`CALL "foo" «USING parameters» «exception-handling»«END-CALL»`^[ง]	`«IDENTIFICATION DIVISION.»PROGRAM-ID. foo.«other divisions...»PROCEDURE DIVISION «USING parameters». instructions.`	`«IDENTIFICATION DIVISION.»PROGRAM-ID/FUNCTION-ID. foo.«other divisions...»DATA DIVISION.«other sections...»LINKAGE SECTION.«parameter definitions...»variable-to-return definition«other sections...»PROCEDURE DIVISION «USING parameters» RETURNING variable-to-return. instructions.`	ไม่มีข้อมูล
โคบอล	`«FUNCTION» foo«(«parameters»)»`	ไม่มีข้อมูล		ไม่มีข้อมูล

ภาษาปาสคาลต้องการ "forward;" สำหรับประกาศล่วงหน้า
^b Eiffel อนุญาตให้ระบุคลาสหลักและฟีเจอร์ของแอปพลิเคชันได้
ใน ภาษา Fortran พารามิเตอร์ของฟังก์ชัน/ซับรูทีนเรียกว่า อาร์กิวเมนต์ (เนื่องจากPARAMETERเป็นคำสำคัญของภาษา) และCALLคำสำคัญนี้จำเป็นสำหรับซับรูทีน
^dแทนที่จะใช้"foo"สามารถใช้ตัวแปรสตริงที่มีค่าเดียวกันแทนได้
ใน Crystal คำหลักนี้ไม่returnจำเป็น แต่คำสั่งสุดท้ายในลำดับการควบคุมของฟังก์ชันจะถูกพิจารณาว่าเป็นค่าส่งคืน
^fการเรียกใช้ฟังก์ชันใน Crystal จำเป็นต้องมีวงเล็บครอบพารามิเตอร์เฉพาะในกรณีที่มีความกำกวมทางไวยากรณ์ (ตัวอย่างเช่น เมื่อฟังก์ชันที่รับพารามิเตอร์หลายตัวถูกส่งเป็นพารามิเตอร์ไปยังฟังก์ชันอื่น) หรือเมื่อประกาศฟังก์ชัน

การแปลงประเภท

โดยที่stringเป็นตัวเลขทศนิยมที่มีเครื่องหมาย:

	แปลงสตริงเป็นจำนวนเต็ม	แปลงสตริงเป็นจำนวนเต็มยาว	แปลงสตริงเป็นเลขทศนิยม	แปลงจำนวนเต็มเป็นสตริง	แปลงค่าทศนิยมเป็นสตริง
อาดา^{[ 1 ]}	`Integer'Value (string_expression)`	`Long_Integer'Value (string_expression)`	`Float'Value (string_expression)`	`Integer'Image (integer_expression)`	`Float'Image (float_expression)`
ALGOL 68พร้อมรูปแบบทั่วไปและรูปแบบเฉพาะ	โดยได้แจ้งและตกลงร่วมกับบุคคลดังต่อไปนี้:`string buf := "12345678.9012e34 "; file proxy; associate(proxy, buf);`
	`get(proxy, ivar);`	`get(proxy, livar);`	`get(proxy, rvar);`	`put(proxy, ival);`	`put(proxy, rval);`
	`getf(proxy, ($g$, ivar));`หรือ`getf(proxy, ($dddd$, ivar));`	`getf(proxy, ($g$, livar));`หรือ`getf(proxy, ($8d$, livar));`	`getf(proxy, ($g$, rvar));`หรือ`getf(proxy, ($8d.4dE2d$, rvar));`	`putf(proxy, ($g$, ival));`หรือ`putf(proxy, ($4d$, ival));`	`putf(proxy, ($g(width, places, exp)$, rval));`หรือ`putf(proxy, ($8d.4dE2d$, rval));`
เอพีแอล	`⍎string_expression`	`⍎string_expression`	`⍎string_expression`	`⍕integer_expression`	`⍕float_expression`
ซี ( ซี99 )	`integer = atoi(string);`	`long = atol(string);`	`float = atof(string);`	`sprintf(string, "%i", integer);`	`sprintf(string, "%f", float);`
ออบเจกทีฟซี	`integer = [string intValue];`	`long = [string longLongValue];`	`float = [string doubleValue];`	`string = [NSStringstringWithFormat:@"%i",integer];`	`string = [NSStringstringWithFormat:@"%f",float];`
ซี++ (STL)	`«std::»istringstream(string) >> number;`			`«std::»ostringstream o; o << number; string = o.str();`
ซี++11	`integer = «std::»stoi(string);`	`long = «std::»stol(string);`	`float = «std::»stof(string); double = «std::»stod(string);`	`string = «std::»to_string(number);`
ซี#	`integer = int.Parse(string);`	`long = long.Parse(string);`	`float = float.Parse(string);double = double.Parse(string);`	`string = number.ToString();`
คริสตัล	`int32 = string.to_i32`	`int64 = string.to_i64`	`float32 = string.to_f32` `float64 = string.to_f64`	`string = number.to_s`	`string = float.to_s`
ดี	`integer = std.conv.to!int(string)`	`long = std.conv.to!long(string)`	`float = std.conv.to!float(string)double = std.conv.to!double(string)`	`string = std.conv.to!string(number)`
ชวา	`integer = Integer.parseInt(string);`	`long = Long.parseLong(string);`	`float = Float.parseFloat(string);double = Double.parseDouble(string);`	`string = Integer.toString(integer);string = String.valueOf(integer);`	`string = Float.toString(float);string = Double.toString(double);`
JavaScript ^[a]	`integer = parseInt(string);`		`float = parseFloat(string);float = new Number (string);float = Number (string);float = +string;`	`string = number.toString ();string = String (number);string = number+"";`string = `${number}`
ไป	`integer, error = strconv.Atoi(string)integer, error = strconv.ParseInt(string, 10, 0)`	`long, error = strconv.ParseInt(string, 10, 64)`	`float, error = strconv.ParseFloat(string, 64)`	`string = strconv.Itoa(integer)string = strconv.FormatInt(integer, 10)string = fmt.Sprint(integer)`	`string = strconv.FormatFloat(float)string = fmt.Sprint(float)`
สนิม^[d]	`string.parse::<i32>()i32::from_str(string)`	`string.parse::<i64>()i64::from_str(string)`	`string.parse::<f64>()f64::from_str(string)`	`integer.to_string()`	`float.to_string()`
ลิสปาร์กทั่วไป	`(setf integer (parse-integer string))`		`(setf float (read-from-string string))`	`(setf string (princ-to-string number))`
โครงการ	`(define number (string->number string))`			`(define string (number->string number))`
ไอเอสลิสป์	`(setf integer (convert string <integer>))`		`(setf float (convert string <float>))`	`(setf string (convert number <string>))`
ปาสคาล	`integer := StrToInt(string);`		`float := StrToFloat(string);`	`string := IntToStr(integer);`	`string := FloatToStr(float);`
วิชวลเบส	`integer = CInt(string)`	`long = CLng(string)`	`float = CSng(string)double = CDbl(string)`	`string = CStr(number)`
Visual Basic .NET (สามารถใช้ได้ทั้งไวยากรณ์ VB ด้านบนและวิธีการ .NET ที่แสดงทางด้านขวา)	`integer = Integer.Parse(string)`	`long = Long.Parse(string)`	`float = Single.Parse(string)double = Double.Parse(string)`	`string = number.ToString()`
โซโจ	`integer = Val(string)`	`long = Val(string)`	`double = Val(string)double = CDbl(string)`	`string = CStr(number)`หรือ`string = Str(number)`
ไพธอน	`integer = int(string)`	`long = long(string)`	`float = float(string)`	`string = str(number)`
เอส-ลัง	`integer = atoi(string);`	`long = atol(string);`	`float = atof(string);`	`string = string(number);`
ฟอร์ทราน	`READ(string,format) number`			`WRITE(string,format) number`
พีพี	`integer = intval(string);`หรือ`integer = (int)string;`		`float = floatval(string);float = (float)string;`	`string = "$number";`หรือหรือ`string = strval(number);string = (string)number;`
เพิร์ล^[b]	`number = 0 + string;`			`string = "number";`
ราคุ	`number = +string;`			`string = ~number;`
ทับทิม	`integer = string.to_i`หรือ`integer = Integer(string)`		`float = string.to_ffloat = Float(string)`	`string = number.to_s`
สกาล่า	`integer = string.toInt`	`long = string.toLong`	`float = string.toFloatdouble = string.toDouble`	`string = number.toString`
การสนทนาเล็กๆ น้อยๆ	`integer := Integer readFrom: string`		`float := Float readFrom: string`	`string := number asString`
วินโดวส์ พาวเวอร์เชลล์	`integer = [int]string`	`long = [long]string`	`float = [float]string`	`string = [string]number;`หรือหรือ`string = "number";string = (number).ToString()`
โอแคมล์	`let integer = int_of_string string`		`let float = float_of_string string`	`let string = string_of_int integer`	`let string = string_of_float float`
เอฟ#	`let integer = int string`	`let integer = int64 string`	`let float = float string`	`let string = string number`
มาตรฐาน ML	`val integer = Int.fromString string`		`val float = Real.fromString string`	`val string = Int.toString integer`	`val string = Real.toString float`
ฮัสเคลล์ ( GHC )	`number = read string`			`string = show number`
โคบอล	`MOVE «FUNCTION»NUMVAL(string)^[c] TO number`			`MOVE number TO numeric-edited`

JavaScriptใช้เฉพาะตัวเลขทศนิยมเท่านั้น ดังนั้นจึงมีรายละเอียดทางเทคนิคบางอย่าง^{[ 7 ]}
^bภาษา Perl ไม่มีการแบ่งประเภทข้อมูล สตริงและตัวเลขสามารถใช้แทนกันได้
^cNUMVAL-CหรือNUMVAL-Fอาจใช้แทนNUMVAL.
^str::parseสามารถใช้แปลงประเภทใดก็ได้ที่มีการใช้งานstd::str::FromStrtrait ทั้งสองแบบstr::parseจะFromStr::from_strส่งคืนค่าResultที่มีประเภทที่ระบุหากไม่มีข้อผิดพลาดสามารถละเว้นturbofish()::<_>str::parse

การรับส่งข้อมูลสตรีมมาตรฐาน

	อ่านจาก	เขียนถึง
	stdin	stdout	stderr
อาดา^{[ 1 ]}	`Get (x)`	`Put (x)`	`Put (Standard_Error, x)`
อัลโกล 68	`readf(($format$, x));`หรือ`getf(stand in, ($format$, x));`	`printf(($format$, x));`หรือ`putf(stand out, ($format$, x));`	`putf(stand error, ($format$, x));`^[ก]
เอพีแอล	`x←⎕`	`⎕←x`	`⍞←x`
ซี ( ซี99 )	`scanf(format, &x);`หรือ^[b]`fscanf(stdin, format, &x);`	`printf(format, x);`หรือ^[ค]`fprintf(stdout, format, x);`	`fprintf(stderr, format, x);`^[ง]
ออบเจกทีฟซี	`data=[[NSFileHandlefileHandleWithStandardInput]readDataToEndOfFile];`	`[[NSFileHandlefileHandleWithStandardOutput]writeData:data];`	`[[NSFileHandlefileHandleWithStandardError]writeData:data];`
ซี++	`«std::»cin >> x;`หรือ`«std::»getline(«std::»cin, str);`	`«std::»cout << x;`	`«std::»cerr << x;`หรือ`«std::»clog << x;`
ซี#	`x = Console.Read();`หรือ`x = Console.ReadLine();`	`Console.Write(«format, »x);`หรือ`Console.WriteLine(«format, »x);`	`Console.Error.Write(«format, »x);`หรือ`Console.Error.WriteLine(«format, »x);`
คริสตัล	`x = gets`	`puts x` หรือ หรือ หรือ `puts(x)printf $format$, xprintf($format$, x)`	`STDERR.puts x` หรือ `STDERR.puts(x)` หรือ หรือ `STDERR.printf $format$, x` `STDERR.printf($format$, x)`
ดี	`x = std.stdio.readln()`	`std.stdio.write(x)`หรือหรือหรือ`std.stdio.writeln(x)std.stdio.writef(format, x)std.stdio.writefln(format, x)`	`stderr.write(x)`หรือหรือหรือ`stderr.writeln(x)std.stdio.writef(stderr, format, x)std.stdio.writefln(stderr, format, x)`
ชวา	`x=System.in.read();`หรือหรือ`x=newScanner(System.in).nextInt();x=newScanner(System.in).nextLine();`	`System.out.print(x);`หรือหรือ`System.out.printf(format, x);System.out.println(x);`	`System.err.print(x);`หรือหรือ`System.err.printf(format, x);System.err.println(x);`
ไป	`fmt.Scan(&x)`หรือหรือ`fmt.Scanf(format, &x)x=bufio.NewReader(os.Stdin).ReadString('\n')`	`fmt.Println(x)`หรือ`fmt.Printf(format, x)`	`fmt.Fprintln(os.Stderr, x)`หรือ`fmt.Fprintf(os.Stderr, format, x)`
สวิฟต์	`x = readLine()`(2.x)	`print(x)`(2.x) (1.x) `println(x)`
การใช้งาน JavaScript ในเว็บเบราว์เซอร์		`document.write(x)`
JavaScript Active Server Pages		`Response.Write(x)`
JavaScript Windows Script Host	`x = WScript.StdIn.Read(chars)`หรือ`x = WScript.StdIn.ReadLine()`	`WScript.Echo(x)`หรือหรือ`WScript.StdOut.Write(x)WScript.StdOut.WriteLine(x)`	`WScript.StdErr.Write(x)`หรือ`WScript.StdErr.WriteLine(x)`
ลิสปาร์กทั่วไป	`(setfx(read-line))`	`(princ x)`หรือ`(format t format x)`	`(princxerror-output)`หรือ`(formaterror-outputformat x)`
โครงการ ( R ⁶ RS )	`(definex(read-line))`	`(display x)`หรือ`(format#tformat x)`	`(displayx(current-error-port))`หรือ`(format(current-error-port)format x)`
ไอเอสลิสป์	`(setf x (read-line))`	`(format(standard-output)format x)`	`(format(error-output)format x)`
ปาสคาล	`read(x);`หรือ`readln(x);`	`write(x);`หรือ`writeln(x);`	`write(stderr, x);`หรือ`writeln(stderr, x);`
วิชวลเบส	`Input« prompt,» x`	`Print x`หรือ`? x`	ไม่มีข้อมูล
Visual Basic .NET	`x = Console.Read()`หรือ`x = Console.ReadLine()`	`Console.Write(«format,»x)`หรือ`Console.WriteLine(«format, »x)`	`Console.Error.Write(«format, »x)`หรือ`Console.Error.WriteLine(«format, »x)`
โซโจ	`x = StandardInputStream.Read()`หรือ`x = StandardInputStreame.ReadLine()`	`StandardOutputStream.Write(x)`หรือ`StandardOutputStream.WriteLine(x)`	`StdErr.Write(x)`หรือ`StdErr.WriteLine(x)`
ไพธอน 2.x	`x = raw_input(«prompt»)`	`print x`หรือ`sys.stdout.write(x)`	`print>>sys.stderr,x`หรือ`sys.stderr.write(x)`
ไพธอน 3.x	`x = input(«prompt»)`	`print(x«, end=""»)`	`print(x«, end=""», file=sys.stderr)`
เอส-ลัง	`fgets (&x, stdin)`	`fputs (x, stdout)`	`fputs (x, stderr)`
ฟอร์ทราน	`READ(*,format) variable names`หรือ^[e]`READ(INPUT_UNIT,format) variable names`	`WRITE(*,format) expressions`หรือ^[e]`WRITE(OUTPUT_UNIT,format) expressions`	`WRITE(ERROR_UNIT,format) expressions`^[e]
ไปข้างหน้า	`buffer length ACCEPT ( # chars read )KEY ( char )`	`buffer length TYPEchar EMIT`	ไม่มีข้อมูล
พีพี	`$x = fgets(STDIN);`หรือ`$x = fscanf(STDIN, format);`	`print x;`หรือหรือ`echox;printf(format, x);`	`fprintf(STDERR, format, x);`
เพิร์ล	`$x = <>;`หรือ`$x = <STDIN>;`	`print x;`หรือ`printfformat, x;`	`print STDERR x;`หรือ`printf STDERR format, x;`
ราคุ	`$x = $*IN.get;`	`x.print`หรือ`x.say`	`x.note`หรือหรือ`$ERR.print(x)$ERR.say(x)`
ทับทิม	`x = gets`	`puts x`หรือ`printf(format, x)`	`$stderr.puts(x)`หรือ`$stderr.printf(format, x)`
วินโดวส์ พาวเวอร์เชลล์	`$x = Read-Host«« -Prompt» text»;`หรือหรือ`$x=[Console]::Read();$x=[Console]::ReadLine()`	`x;`หรือหรือ`Write-Output x;echo x`	`Write-Error x`
โอแคมล์	`let x = read_int ()`หรือหรือ`let str = read_line ()Scanf.scanfformat (fun x ... -> ...)`	`print_int x`หรือหรือ`print_endline strPrintf.printfformat x ...`	`prerr_int x`หรือหรือ`prerr_endline strPrintf.eprintfformat x ...`
เอฟ#	`letx=System.Console.ReadLine()`	`printfformat x ...`หรือ`printfnformat x ...`	`eprintfformat x ...`หรือ`eprintfnformat x ...`
มาตรฐาน ML	`valstr=TextIO.inputLIneTextIO.stdIn`	`print str`	`TextIO.output(TextIO.stdErr, str)`
ฮัสเคลล์ ( GHC )	`x <- readLn`หรือ`str <- getLine`	`print x`หรือ`putStrLn str`	`hPrint stderr x`หรือ`hPutStrLn stderr str`
โคบอล	`ACCEPT x`	`DISPLAY x`

นอกจากนี้ ALGOL 68 ยังมีการแปลงข้อมูลได้แก่read,write,get, และput.
^bgets(x)และอ่านข้อความที่ไม่ได้จัดรูปแบบจาก stdin ไม่แนะนำให้ใช้ getsfgets(x, length, stdin)
^cputs(x)และfputs(x, stdout)เขียนข้อความที่ไม่มีการจัดรูปแบบไปยัง stdout
^dfputs(x, stderr)เขียนข้อความที่ไม่มีการจัดรูปแบบไปยัง stderr
^e INPUT_UNIT, OUTPUT_UNIT, ERROR_UNITถูกกำหนดไว้ในโมดูลISO_FORTRAN_ENV^[¹⁵^]

การอ่านอาร์กิวเมนต์จากบรรทัดคำสั่ง

	ค่าอาร์กิวเมนต์	การโต้แย้งนับคะแนน	ชื่อโปรแกรม / ชื่อสคริปต์
อาดา^{[ 1 ]}	`Argument (n)`	`Argument_Count`	`Command_Name`
ซี ( ซี99 )	`argv[n]`	`argc`	ข้อโต้แย้งแรก
ออบเจกทีฟซี
ซี++
ซี#	`args[n]`	`args.Length`	`Assembly.GetEntryAssembly().Location;`
ชวา		`args.length`
ดี		`args.length`	ข้อโต้แย้งแรก
คริสตัล	`ARGV[n]`	`ARGV.size`	`PROGRAM_NAME`
การใช้งานJavaScript ใน Windows Script Host	`WScript.Arguments(n)`	`WScript.Arguments.length`	`WScript.ScriptName`หรือ`WScript.ScriptFullName`
ไป	`os.Args[n]`	`len(os.Args)`	ข้อโต้แย้งแรก
สนิม^[a]	`std::env::args().nth(n)std::env::args_os().nth(n)`	`std::env::args().count()std::env::args_os().count()`	`std::env::args().next()std::env::args_os().next()`
สวิฟต์	`Process.arguments[n]`หรือ`Process.unsafeArgv[n]`	`Process.arguments.count`หรือ`Process.argc`	ข้อโต้แย้งแรก
ลิสปาร์กทั่วไป	?	?	?
โครงการ ( R ⁶ RS )	`(list-ref(command-line)n)`	`(length(command-line))`	ข้อโต้แย้งแรก
ไอเอสลิสป์	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
ปาสคาล	`ParamStr(n)`	`ParamCount`	ข้อโต้แย้งแรก
วิชวลเบส	`Command`^[ข]	ไม่มีข้อมูล	`App.Path`
Visual Basic .NET	`CmdArgs(n)`	`CmdArgs.Length`	`[Assembly].GetEntryAssembly().Location`
โซโจ	`System.CommandLine`	(การแยกวิเคราะห์สตริง)	`Application.ExecutableFile.Name`
ไพธอน	`sys.argv[n]`	`len(sys.argv)`	ข้อโต้แย้งแรก
เอส-ลัง	`__argv[n]`	`__argc`	ข้อโต้แย้งแรก
ฟอร์ทราน	`DO i = 1,argc CALL GET_COMMAND_ARGUMENT (i,argv(i))ENDDO`	`argc = COMMAND_ARGUMENT_COUNT ()`	`CALL GET_COMMAND_ARGUMENT (0,progname)`
พีพี	`$argv[n]`	`$argc`	ข้อโต้แย้งแรก
เปลือกหอย	`$n ($1, $2, $3, ...)$@`(ข้อโต้แย้งทั้งหมด)	`$#`	`$0`
เพิร์ล	`$ARGV[n]`	`scalar(@ARGV)`	`$0`
ราคุ	`@*ARGS[n]`	`@*ARGS.elems`	`$PROGRAM_NAME`
ทับทิม	`ARGV[n]`	`ARGV.size`	`$0`
วินโดวส์ พาวเวอร์เชลล์	`$args[n]`	`$args.Length`	`$MyInvocation.MyCommand.Name`
โอแคมล์	`Sys.argv.(n)`	`Array.length Sys.argv`	ข้อโต้แย้งแรก
เอฟ#	`args.[n]`	`args.Length`	`Assembly.GetEntryAssembly().Location`
มาตรฐาน ML	`List.nth(CommandLine.arguments(),n)`	`length(CommandLine.arguments())`	`CommandLine.name()`
ฮัสเคลล์ ( GHC )	`do{args<-System.getArgs;returnlengthargs!!n`}	`do{args<-System.getArgs;returnlengthargs`}	`System.getProgName`
โคบอล	^[ค]		ไม่มีข้อมูล

^aใน Rust ฟังก์ชันนี้std::env::argsจะstd::env::args_osส่งคืนตัววนซ้ำstd::env::Argsและstd::env::ArgsOsตามลำดับArgsฟังก์ชันนี้จะแปลงอาร์กิวเมนต์แต่ละตัวเป็นStringและจะเกิดข้อผิดพลาดหากพบอาร์กิวเมนต์ที่ไม่สามารถแปลงเป็นUTF-8ได้ArgsOsฟังก์ชันนี้จะส่งคืนการแสดงผลแบบไม่สูญเสียข้อมูลของสตริงดิบจากระบบปฏิบัติการ (std::ffi::OsString) ซึ่งอาจเป็น UTF-8 ที่ไม่ถูกต้อง
ใน Visual Basic นั้นอาร์กิวเมนต์บรรทัดคำสั่งจะไม่ถูกแยกออกจากกัน การแยกอาร์กิวเมนต์เหล่านั้นต้องใช้ฟังก์ชันsplitSplit(string)
มาตรฐาน COBOL ไม่ได้ระบุวิธีการใด ๆ ในการเข้าถึงอาร์กิวเมนต์จากบรรทัดคำสั่ง แต่ส่วนขยายคอมไพเลอร์ทั่วไปที่ ใช้ในการเข้าถึงอาร์กิวเมนต์เหล่านี้ ได้แก่ การกำหนดพารามิเตอร์สำหรับโปรแกรมหลัก หรือการใช้ACCEPTคำสั่งต่างๆ

การดำเนินการตามคำสั่ง

	คำสั่งเชลล์	ดำเนินการโปรแกรม	แทนที่โปรแกรมปัจจุบันด้วยโปรแกรมที่เรียกใช้งานใหม่
อาดา^{[ 1 ]}	^{ไม่ได้ เป็น}ส่วนหนึ่งของมาตรฐานภาษา โดยทั่วไปจะทำผ่านแพ็กเกจที่คอมไพเลอร์จัดเตรียมไว้ หรือผ่านการเชื่อมต่อกับ C หรือPOSIX [ ^{16 ]}
ซี	`system("command");`		`execl(path, args);`หรือ`execv(path, arglist);`
ซี++			`execl(path, args);`หรือ`execv(path, arglist);`
ออบเจกทีฟซี		`[NSTasklaunchedTaskWithLaunchPath:(NSString)patharguments:(NSArray)arguments];`
ซี#		`System.Diagnostics.Process.Start(path, argstring);`
เอฟ#		`System.Diagnostics.Process.Start(path, argstring);`
คริสตัล	`command` หรือ `Process.run command`	`Process.run path, args`	`Process.exec path, args`
ไป		`exec.Run(path, argv, envv, dir, exec.DevNull, exec.DevNull, exec.DevNull)`	`os.Exec(path, argv, envv)`
วิชวลเบส	`Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn»)`
Visual Basic .NET	`Microsoft.VisualBasic.Interaction.Shell(command «, WindowStyle» «, isWaitOnReturn»)`	`System.Diagnostics.Process.Start(path, argstring)`
โซโจ	`Shell.Execute(command «, Parameters»)`	`FolderItem.Launch(parameters, activate)`	ไม่มีข้อมูล
ดี	`std.process.system("command");`		`std.process.execv(path, arglist);`
ชวา		`Runtime.exec(command);`หรือ`new ProcessBuilder(command).start();`
การใช้งานJavaScript ใน Windows Script Host	`WScript.CreateObject("WScript.Shell").Run(command «, WindowStyle» «, isWaitOnReturn»);`	`WshShell.Exec(command)`
ลิสปาร์กทั่วไป	`(uiop:run-program command)`
โครงการ	`(system command)`
ไอเอสลิสป์	ไม่มีข้อมูล	ไม่มีข้อมูล	ไม่มีข้อมูล
ปาสคาล	`system(command);`
โอแคมล์	`Sys.command command, Unix.open_process_full command env (stdout, stdin, stderr),...`	`Unix.create_process prog args new_stdin new_stdout new_stderr, ...`	`Unix.execv prog args`หรือ`Unix.execve prog args env`
มาตรฐาน ML	`OS.Process.system command`	`Unix.execute (path, args)`	`Posix.Process.exec (path, args)`
ฮัสเคลล์ ( GHC )	`System.system command`	`System.Process.runProcess path args ...`	`Posix.Process.executeFile path True args ...`
เพิร์ล	`system(command)`หรือหรือ$output = `command``$output = qx(command)`		`exec(path, args)`
ทับทิม	`system(command)`หรือoutput = `command`		`exec(path, args)`
พีพี	`system(command)`หรือหรือหรือ$output = `command``exec(command)passthru(command)`
ไพธอน	`os.system(command)`หรือ`subprocess.Popen(command)`	`subprocess.call(["program", "arg1", "arg2", ...])`	`os.execv(path, args)`
เอส-ลัง	`system(command)`
ฟอร์ทราน	`CALL EXECUTE_COMMAND_LINE (COMMAND «, WAIT» «, EXITSTAT» «, CMDSTAT» «, CMDMSG»)`^[ก]
วินโดวส์ พาวเวอร์เชลล์	`[Diagnostics.Process]::Start(command)`	`«Invoke-Item »program arg1 arg2 ...`
เปลือกหอย	output=`command`หรือ`output=$(command)`	`program arg1 arg2 ...`

^a Fortran 2008 หรือใหม่กว่า^{[ 17 ]}

ดูเพิ่มเติม

รายชื่อภาษาโปรแกรมมิ่งโอเพนซอร์ส

[ 1 ]

[ 2 ]

[ 3 ]

[ 4 ]

[ 5 ]

[ 6 ]

[ 7 ]

[ 8 ]

[ 9 ]

[ 10 ]

[ 11 ]

[ 12 ]

[ 13 ]

[ 14 ]

[

ไม่ได้ เป็น

[ 17 ]