ในการเขียนโปรแกรมคอมพิวเตอร์จุดเริ่มต้นคือตำแหน่งในโปรแกรมที่การทำงานของโปรแกรมเริ่มต้นขึ้น และโปรแกรมสามารถเข้าถึงอาร์กิวเมนต์บรรทัดคำสั่งได้^{[ 1 ]}

ในการเริ่มต้น การทำงานของโปรแกรมตัวโหลดหรือระบบปฏิบัติการจะส่งการควบคุมไปยังจุดเริ่มต้นของโปรแกรม (ในระหว่างการบูตระบบปฏิบัติการเองก็คือโปรแกรม) นี่เป็นจุดเปลี่ยนจากเวลาโหลด (และเวลาเชื่อมโยง แบบไดนามิก หากมี) ไปสู่เวลาการทำงาน

สำหรับระบบปฏิบัติการและภาษาโปรแกรม บางภาษา จุดเริ่มต้นจะอยู่ในไลบรารีรันไทม์ซึ่งเป็นชุดฟังก์ชันสนับสนุนสำหรับภาษานั้น โค้ดไลบรารีจะเริ่มต้นโปรแกรมแล้วส่งการควบคุมไปยังโปรแกรมหลัก ในกรณีอื่นๆ โปรแกรมอาจเริ่มต้นไลบรารีรันไทม์เอง^{[ 2 ]}

ในระบบที่เรียบง่าย การประมวลผลจะเริ่มต้นที่คำสั่งแรก ซึ่งเป็นเรื่องปกติในภาษาที่ใช้การตีความ รูปแบบไฟล์ ปฏิบัติการแบบง่ายและบูตโหลดเดอร์ ในกรณีอื่นๆ จุดเริ่มต้นจะอยู่ที่ที่อยู่ หน่วยความจำที่ทราบแล้วซึ่งอาจเป็นที่อยู่สัมบูรณ์หรือที่อยู่สัมพัทธ์ ( ออฟเซ็ต ) ก็ได้

อีกทางเลือกหนึ่ง การดำเนินการของโปรแกรมสามารถเริ่มต้นที่จุดที่มีชื่อ ไม่ว่าจะเป็นชื่อตามธรรมเนียมที่กำหนดโดยภาษาโปรแกรมหรือระบบปฏิบัติการ หรือที่ชื่อที่ผู้เรียกกำหนด ในภาษาตระกูล C หลายภาษา นี่คือฟังก์ชันที่เรียกว่าmainดังนั้น จุดเริ่มต้นจึงมักเรียกว่าฟังก์ชันหลัก^{[ 3 ]}

ในภาษา JVMเช่นJavaจุดเริ่มต้นคือเมธอดแบบ static ที่ชื่อว่าmain; ในภาษา CLIเช่น C# จุดเริ่มต้นคือเมธอดแบบ static ที่Mainชื่อว่า^{[ 4 ]}

จุดเริ่มต้นการทำงาน (Entrypoint) สามารถใช้ได้ทั้งในซอร์สโค้ดและ ไฟล์ ปฏิบัติการ อย่างไรก็ตาม ใน การพัฒนาซอฟต์แวร์ในชีวิตประจำวันโปรแกรมเมอร์มักระบุจุดเริ่มต้นการทำงานเฉพาะในซอร์สโค้ด ซึ่งทำให้เป็นที่รู้จักกันดีมากกว่า จุดเริ่มต้นการทำงานในไฟล์ปฏิบัติการขึ้นอยู่กับอินเทอร์เฟซไบนารีแอปพลิเคชัน (ABI) ของระบบปฏิบัติการ และถูกสร้างขึ้นโดยคอมไพเลอร์หรือลิงเกอร์ (หากไม่ได้กำหนดไว้ใน ABI) ไฟล์ออบเจ็กต์ ที่เชื่อมโยงอื่นๆ อาจมีจุดเริ่มต้นการทำงานเช่นกัน ซึ่งลิงเกอร์จะนำไปใช้ในภายหลังเมื่อสร้างจุดเริ่มต้นของไฟล์ปฏิบัติการ

จุดเริ่มต้นการทำงานสามารถส่งต่ออาร์กิวเมนต์คำสั่ง ตัวแปร หรือข้อมูลอื่นๆ เป็นตัวแปรโลคอลที่ใช้โดยMain()เมธอดได้ ด้วยวิธีนี้ ตัวเลือกเฉพาะสามารถกำหนดได้เมื่อโปรแกรมเริ่มทำงาน จากนั้นโปรแกรมจะตีความตัวเลือกเหล่านั้น โปรแกรมจำนวนมากใช้สิ่งนี้เป็นอีกทางเลือกหนึ่งในการกำหนดค่าการตั้งค่าต่างๆ หรือดำเนินการชุดการกระทำต่างๆ โดยใช้โปรแกรมเดียว

ในภาษาโปรแกรมและระบบปฏิบัติการยอดนิยมส่วนใหญ่ในปัจจุบันโปรแกรมคอมพิวเตอร์มักจะมีจุดเริ่มต้นเพียง จุดเดียวเท่านั้น

ใน โปรแกรม C , C++ , D , Zig , RustและKotlinนี่คือฟังก์ชันชื่อmain; ในJavaนี่คือเมธอดแบบ staticชื่อmain(ถึงแม้ว่าต้องระบุคลาสในเวลาเรียกใช้ก็ตาม) และในC#นี่คือเมธอดแบบ static Mainชื่อ^{[ 5 ] [ 6 ]}

ในระบบปฏิบัติการหลักหลายระบบ รูปแบบไฟล์ปฏิบัติการมาตรฐานจะมีจุดเริ่มต้นเพียงจุดเดียว ในรูปแบบไฟล์ปฏิบัติการและเชื่อมโยงได้ (ELF) ที่ใช้ใน ระบบ Unixและ ระบบ ที่คล้าย Unixเช่นLinuxจุดเริ่มต้นจะถูกระบุไว้ในe_entryฟิลด์ของส่วนหัวของไฟล์ ELF ในชุดคอมไพเลอร์ GNU (gcc) จุดเริ่มต้นที่ใช้โดยตัวเชื่อมโยงคือ_startสัญลักษณ์ ในทำนองเดียวกัน ในรูป แบบไฟล์ ปฏิบัติการแบบพกพา (Portable Executable format) ที่ใช้ในMicrosoft Windowsจุดเริ่มต้นจะถูกระบุโดยAddressOfEntryPointฟิลด์ ซึ่งสืบทอดมาจากCOFFในไฟล์ COM จุดเริ่มต้นจะอยู่ที่ ค่าออฟเซ็ตคงที่ 0100h

ข้อยกเว้นประการหนึ่งของแนวคิดจุดเข้าเดียวคือAndroidแอปพลิเคชัน Android ไม่มีจุดเข้าเดียว – ไม่มีmainฟังก์ชันพิเศษใดๆ แต่จะมีส่วนประกอบที่จำเป็น (กิจกรรมและบริการ) ซึ่งระบบสามารถโหลดและเรียกใช้งานได้ตามต้องการ^{[ 7 ]}

เทคนิคที่ใช้ไม่บ่อยนักคือไบนารีขนาดใหญ่ (fat binary ) ซึ่งประกอบด้วยไฟล์ปฏิบัติการหลายไฟล์สำหรับเป้าหมายที่แตกต่างกัน บรรจุอยู่ในไฟล์เดียว โดยทั่วไปแล้ว จะใช้วิธีการกำหนดจุดเริ่มต้นโดยรวมเพียงจุดเดียว ซึ่งเข้ากันได้กับทุกเป้าหมายและแยกไปยังจุดเริ่มต้นเฉพาะของแต่ละเป้าหมาย เทคนิคทางเลือกอื่นๆ ได้แก่ การจัดเก็บไฟล์ปฏิบัติการแยกต่างหากในฟอร์ก (fork) ที่แยกจาก กัน โดยแต่ละฟอร์กจะมีจุดเริ่มต้นของตัวเอง ซึ่งระบบปฏิบัติการจะเป็นผู้เลือก

ในอดีต และในระบบเก่า บางระบบในปัจจุบัน เช่นVMSและOS/400 โปรแกรมคอมพิวเตอร์มี จุดเริ่มต้นการทำงานหลาย จุด โดยแต่ละจุดสอดคล้องกับฟังก์ชันการทำงานที่แตกต่างกันของโปรแกรม วิธีปกติในการระบุจุดเริ่มต้นการทำงาน ซึ่งใช้กันทั่วทั้งระบบใน VMS และใน โปรแกรม PL/IและMACROคือการเพิ่มจุดเริ่มต้นการทำงานไว้ท้ายชื่อไฟล์ปฏิบัติการโดยคั่นด้วยเครื่องหมายดอลลาร์ ($) เช่นdirectory.exe$make.

คอมพิวเตอร์ Apple Iก็ใช้หลักการนี้ในระดับหนึ่งเช่นกัน ตัวอย่างเช่น จุดเริ่มต้นการทำงานทางเลือกในภาษา BASIC ของ Apple I จะทำให้โปรแกรม BASIC ยังคงใช้งานได้แม้ว่าจะกดปุ่มรีเซ็ตโดยไม่ได้ตั้งใจก็ตาม

โดยทั่วไป โปรแกรมสามารถออกจากระบบได้ตลอดเวลา โดยการกลับไปยังระบบปฏิบัติการหรือเกิดข้อผิดพลาดโปรแกรมที่เขียนด้วยภาษาที่ใช้การตีความจะส่งการควบคุมกลับไปยังตัวตีความ แต่โปรแกรมที่เขียนด้วยภาษาที่ใช้การคอมไพล์จะต้องกลับไปยังระบบปฏิบัติการ มิฉะนั้นโปรเซสเซอร์จะยังคงทำงานต่อไปเกินกว่าจุดสิ้นสุดของโปรแกรม ส่งผลให้เกิดพฤติกรรม ที่ไม่แน่นอน

โดยปกติแล้ว โปรแกรมจะไม่มีจุดออกที่กำหนดไว้ตายตัว อย่างไรก็ตาม ในบางกรณี รันไทม์จะตรวจสอบให้แน่ใจว่าโปรแกรมสิ้นสุดลงอย่างเป็นระบบผ่านจุดออกเพียงจุดเดียว ซึ่งจะเกิดขึ้นได้ก็ต่อเมื่อรันไทม์เองไม่เกิดข้อผิดพลาด วิธีนี้จะช่วยให้โค้ดสำหรับจัดการข้อผิดพลาด เช่นatexitตัวจัดการเหตุการณ์ สามารถทำงานได้ สามารถทำได้โดยการกำหนดให้โปรแกรมสิ้นสุดลงโดยการส่งค่ากลับจากฟังก์ชันหลัก โดยการเรียกใช้ฟังก์ชันออกเฉพาะ หรือโดยที่รันไทม์ดักจับข้อยกเว้นหรือสัญญาณจากระบบปฏิบัติการ

ในภาษาโปรแกรมหลายภาษาmainฟังก์ชันคือจุดเริ่มต้นการทำงานของโปรแกรม ช่วยให้สามารถจัดระเบียบการทำงานของโปรแกรมในระดับสูง และโดยทั่วไปจะสามารถเข้าถึงอาร์กิวเมนต์คำสั่งที่ส่งให้กับโปรแกรมเมื่อมีการเรียกใช้งาน

โดยทั่วไปแล้ว ฟังก์ชัน main คือฟังก์ชัน แรกที่โปรแกรมเมอร์เขียนขึ้น และจะทำงานเมื่อโปรแกรมเริ่มต้น และจะถูกเรียกใช้โดยตรงจากการเริ่มต้นระบบเฉพาะที่อยู่ในสภาพแวดล้อมรันไทม์ ( crt0หรือเทียบเท่า) อย่างไรก็ตาม บางภาษาสามารถเรียกใช้ฟังก์ชันที่ผู้ใช้เขียนขึ้นก่อนที่ฟังก์ชัน main จะทำงาน เช่น คอนสตรัคเตอร์ของ ออบ เจ็กต์ส่วนกลางใน C++

ในภาษาโปรแกรมอื่นๆ โดยเฉพาะภาษาที่ใช้การตีความหลายภาษาการประมวลผลจะเริ่มต้นที่คำสั่งแรกในโปรแกรม

ต่อไปนี้เป็นรายชื่อภาษาโปรแกรม (แต่ไม่ครบถ้วนสมบูรณ์) พร้อมอธิบายวิธีการกำหนดจุดเริ่มต้นหลักของแต่ละภาษา:

ในAPLเมื่อโหลดเวิร์กสเปซ เนื้อหาของตัวแปร "quad LX" (latent expression) จะถูกตีความว่าเป็นนิพจน์ APL และถูกประมวลผล

ในภาษา CและC++ต้นแบบฟังก์ชันของฟังก์ชัน main ต้องเทียบเท่ากับสิ่งต่อไปนี้อย่างใดอย่างหนึ่ง:

int main (); int main ( int argc , char * argv []);

โปรดทราบว่าอาจแสดงได้ในรูปแบบที่เทียบเท่ากันคือและอาจแสดงได้ในรูปแบบที่เทียบเท่ากันคือ; ภายในพารามิเตอร์ของฟังก์ชัน รูปแบบเหล่านี้จะเหมือนกันในสายตาของคอมไพเลอร์ intmain();intmain(void);intmain(intargc,char*argv[]);intmain(intargc,char**argv);

ก่อน C89 ภาษา C ได้กำหนดฟังก์ชันทั้งหมดโดยไม่มีประเภทการส่งคืนที่ชัดเจนที่จะส่งคืนintฟังก์ชันหลักบางฟังก์ชันอาจเป็นเพียงนอกจากนี้ยังเป็นลายเซ็นที่ได้รับการยอมรับในคอมไพเลอร์บางตัว แต่ไม่ได้เป็นส่วนหนึ่งของภาษาอย่างเป็นทางการ ในกรณีดังกล่าว ค่าที่ส่งคืนไปยังสภาพแวดล้อมโฮสต์จะไม่ถูกระบุ^{[ 8 ]}main(){/* ... */}voidmain();

หน้าที่หลักคือเป็นจุดเริ่มต้นสำหรับโปรแกรมแอปพลิเคชันที่เขียนด้วยภาษา C หรือ C++ ตามมาตรฐาน ISO การเขียนโปรแกรมระบบระดับต่ำ (เช่น สำหรับระบบฝังตัวแบบ bare-metal ) อาจระบุจุดเริ่มต้นที่แตกต่างกัน (ตัวอย่างเช่น ผ่านเวกเตอร์ขัดจังหวะ การรีเซ็ต ) โดยใช้ฟังก์ชันการทำงานที่ไม่ได้กำหนดไว้ในมาตรฐานภาษา

สำหรับประเภทการคืนค่าแบบต่อท้ายอาจmain()แสดงได้ในรูปแบบที่เทียบเท่ากันดังนี้:

auto main () -> int ; auto main ( int argc , char * argv []) -> int ;

หากลายเซ็นเป็นแบบ(ไม่มีและ) และมีการระบุอาร์กิวเมนต์ในบรรทัดคำสั่ง โปรแกรมจะเพิกเฉยต่ออาร์กิวเมนต์เหล่านั้น intmain()argcargv

พารามิเตอร์(สำหรับจำนวนอาร์กิวเมนต์ ) และ(สำหรับเวกเตอร์อาร์กิวเมนต์ ) ^{[ 9 ]}จะให้จำนวนและค่าของอาร์กิวเมนต์บรรทัดคำสั่งของโปรแกรมตามลำดับชื่อของและ อาจเป็นตัวระบุที่ถูกต้องใดๆ ก็ได้ แต่โดยทั่วไปมักใช้ชื่อเหล่านี้ มาตรฐาน C และ C++ ยังอนุญาตให้ใช้รูปแบบที่ขึ้นอยู่กับแพลตฟอร์มอื่นๆ ยกเว้นใน C++ ที่ประเภทการส่งคืนจะต้องเป็น; ^{[ 10 ]}ตัวอย่างเช่นUnix (แม้ว่าจะไม่ใช่POSIX.1 ) และWindows มีอาร์กิวเมนต์ที่สามที่ให้ สภาพแวดล้อมของโปรแกรมซึ่งสามารถเข้าถึงได้ผ่านทางใน: argcargvargcargvintgetenv()<stdlib.h>

int main ( int argc , char * argv [], char * envp []);

ระบบปฏิบัติการที่ใช้ Darwinเช่นmacOSมีพารามิเตอร์ที่สี่ซึ่งประกอบด้วยข้อมูลที่ระบบปฏิบัติการจัดหาให้โดยพลการ เช่น เส้นทางไปยังไบนารีที่กำลังดำเนินการ: ^{[ 11 ]}

int main ( int argc , char * argv [], char * envp [], char * apple []);

ค่าที่ส่งคืนจากฟังก์ชันหลักจะกลายเป็นสถานะการออกจากกระบวนการ แม้ว่ามาตรฐาน C จะกำหนดความหมายเฉพาะให้กับค่าเพียงสองค่าเท่านั้นEXIT_SUCCESS(ตามธรรมเนียม0) คือ `false` และEXIT_FAILURE`false` ความหมายของค่าส่งคืนอื่นๆ นั้นขึ้นอยู่กับการใช้งานของโปรแกรม ในกรณีที่โปรแกรมเมอร์ไม่ได้กำหนดค่าส่งคืน คอมไพเลอร์จะแทรกค่า `false` โดยปริยายไว้ที่ท้ายฟังก์ชัน พฤติกรรมนี้เป็นไปตามข้อกำหนดของมาตรฐาน C++ return0;main()

รับประกันได้ว่าargcค่า `non-negative` และ ` null pointer`argv[argc]เป็น ค่าที่ไม่ติดลบ ตามธรรมเนียมแล้ว อาร์กิวเมนต์บรรทัดคำสั่งที่ระบุโดย ` and` จะรวมชื่อโปรแกรมเป็นองค์ประกอบแรกหาก ` or` มากกว่า 0 หากผู้ใช้พิมพ์คำสั่ง `" `" ` เชลล์จะเริ่มต้นกระบวนการด้วย ` and` และ `"` เนื่องจาก ` " ` เป็นชื่อที่กระบวนการปรากฏใน`/ etc/resources` เป็นต้น โปรแกรมบางโปรแกรม เช่นเดมอนหรือโปรแกรมที่ทำงานภายในตัวแปลภาษาหรือเครื่องเสมือน (ซึ่ง `/ etc /resources` จะเป็นชื่อของไฟล์ปฏิบัติการของโฮสต์) อาจเลือกที่จะเปลี่ยน `"` ของตนเพื่อให้ `"` มีความหมายมากขึ้นโดยปกติจะใช้การเรียกใช้ระบบ `"` argcargvargcrm filermargc=2argv={"rm","file",NULL}argv[0]pstopargv[0]argvargv[0]exec

ในGCCและClangสามารถเรียกใช้(หรืออาจเลือกฟังก์ชันอื่นเป็นจุดเริ่มต้น) โดยการส่งแฟล็กคอมไพเลอร์แล้วกำหนดฟังก์ชันนั้น ได้ สามารถดึงอาร์กิวเมนต์จากบรรทัดคำสั่งได้โดย ใช้ แอสเซมบลีแบบอินไลน์main()–nostartfiles_start()main()

#include <stdio.h> #include <stdlib.h>void _start () { int exitCode = Main (); exit ( exitCode ); }// โปรดสังเกตว่าชื่อฟังก์ชันคือ Main() ไม่ใช่ main() int Main () { printf ( "ไม่มีฟังก์ชัน main() ในโปรแกรมนี้" ); return 0 ; }

ฟังก์ชัน นี้มีความพิเศษ โดยปกติแล้วโปรแกรม C และ C++ ทุกโปรแกรมจะต้องกำหนดฟังก์ชันนี้เพียงครั้งเดียวเท่านั้น main()

หากมีการประกาศจะต้องประกาศเสมือนว่ามีการเชื่อมโยงภายนอก ไม่สามารถประกาศแบบอื่นได้ main()staticinline

ใน C++ ฟังก์ชันต้องอยู่ในเนมสเปซ ส่วนกลาง (เช่น `<int> `) และไม่สามารถโอเวอร์โหลดได้ ใน C++ (ต่างจาก C) ฟังก์ชันไม่สามารถเรียกซ้ำได้และไม่สามารถดึงที่อยู่ของฟังก์ชันได้ หากฟังก์ชันไม่ได้ถูกกำหนดไว้ในเนมสเปซส่วนกลาง (ตัวอย่างเช่น หากถูกกำหนดไว้เฉพาะเป็นฟังก์ชันสมาชิกของคลาส) คอมไพเลอร์จะไม่ตรวจพบ ฟังก์ชันไม่ได้ถูกสงวนชื่อไว้ และสามารถใช้สำหรับฟังก์ชันสมาชิก คลาส การแจงนับ หรือฟังก์ชันที่ไม่ใช่สมาชิกในเนมสเปซอื่นๆ ได้ main()::mainmain()main()main()

import std ;using std :: span ; using std :: string_view ; using std :: vector ;class Main { public : static void main ( span < string_view > args ) { std :: println ( "ฟังก์ชัน main() สไตล์ Java พร้อมอาร์กิวเมนต์ {} ตัว:" , args . size ());for ( string_view arg : args ) { std :: println ( " {}" ); } } };int main ( int argc , char * argv []) { vector < string_view > args ( argv , argv + argc ); Main :: main ( args ); return 0 ; }

ในปี 2017 มีข้อเสนอสำหรับลายเซ็นที่ทันสมัยขึ้นสำหรับ ซึ่งคล้ายกับ Java และ C# มากขึ้น (ซึ่งแทนที่จะใช้ภาษาเหล่านี้ใช้ซึ่งรับอาร์เรย์ของสตริง) ลายเซ็นที่แนะนำคือ(เนื่องจากในขณะนั้นยังไม่ได้เป็นส่วนหนึ่งของภาษา) อย่างไรก็ตาม ข้อเสนอนี้ถูกปฏิเสธ^{[ 12 ]}main()main(int,char*[])main(String[])intmain(initializer_list<string_view>args)span<T>

ตั้งแต่C++26 เป็นต้นไป ฟังก์ชันอาจมีการเชื่อมโยง ซึ่งช่วยให้หน่วยการใช้งานโมดูลสามารถทดสอบเอนทิตีภายในได้^{[ 13 ]}main()extern"C++"

โมดูลวิกิพีเดีย. ตัวอย่าง;extern "C++" int main () { // ... }

เมื่อเรียกใช้โปรแกรมที่เขียนด้วยC# CLR จะค้นหาเมธอดแบบคงที่ที่ทำเครื่องหมายด้วยคำสั่ง IL ซึ่งไม่รับอาร์กิวเมนต์หรือรับอาร์กิวเมนต์เดียวที่มีประเภทเป็นและมีประเภทการคืนค่าเป็นหรือและเรียกใช้เมธอดนั้น^{[ 14 ]}.entrypointstring[]voidint

static void Main (); static void Main ( string [] args ); static int Main (); static int Main ( string [] args );

มีการส่งอาร์กิวเมนต์ผ่านบรรทัดคำสั่ง ในargsลักษณะเดียวกับที่ทำในภาษา Java สำหรับเวอร์ชันที่Main()ส่งค่าคืนเป็นจำนวนเต็ม คล้ายกับทั้งภาษา C และ C++ โดยจะส่งค่าดังกล่าวกลับไปยังสภาพแวดล้อมเป็นสถานะการออกจากกระบวนการ

เช่นเดียวกับภาษา Java จุดเริ่มต้นของโปรแกรมมักจะอยู่ในคลาสที่มีชื่อ ดังนี้:

เนมสเปซWikipedia.Examples ;โดยใช้ระบบ;public class HelloWorld { static void Main ( string [] args ) { Console.WriteLine ( " Hello, world!" ) ; } }

ตั้งแต่ C#7.1 เป็นต้นมา มีลายเซ็น ที่เป็นไปได้อีกสี่แบบ สำหรับจุดเริ่มต้น ซึ่งอนุญาตให้ดำเนินการแบบอะซิงโครนัสในMain()เมธอด โดยใช้System.Threading.Tasks.Taskคลาส^{[ 15 ] [ 16 ]}

static async Task Main (); static async Task Main ( string [ ] args ); static async Task <int> Main ( ); static async Task <int> Main ( string [ ] args ) ;

และ ประเภทเหล่า Taskนี้Task<int>เป็นค่าเทียบเท่าแบบอะซิงโครนัสของvoidและint(โปรดทราบว่าTask<void>ไม่ถูกต้อง) asyncจำเป็นต้องใช้ เพื่ออนุญาตให้ใช้การเรียกแบบอะซิงโครนัส ( awaitคำหลัก) ภายในเมธอด

เนมสเปซWikipedia.Examples ;using System ; using System.Threading.Tasks ;public class HelloWorld { static async Task < int > Main ( string [] args ) { Console . WriteLine ( "Hello..." ); await Task . Delay ( 1000 ); Console . WriteLine ( "...world!" ); return 0 ; } }

Cleanเป็นภาษาการเขียนโปรแกรมเชิงฟังก์ชันที่อิงกับการเขียนกราฟใหม่ โหนดเริ่มต้นจะมีชื่อStartและเป็นประเภท `int` *World -> *Worldหากมันเปลี่ยนแปลงโลก หรือเป็นประเภทคงที่บางอย่างหากโปรแกรมเพียงแค่พิมพ์ผลลัพธ์หลังจากลดรูปStartแล้ว

เริ่ม:: * โลก-> * โลกเริ่มโลก= startIO ...

หรือจะง่ายกว่านั้นก็ได้

เริ่มต้น:: สตริงเริ่มต้น= "สวัสดีโลก!"

ตัวเลือกหนึ่งจะบอกคอมไพเลอร์ว่าควรใช้ตัวเลือกใดในการสร้างไฟล์ปฏิบัติการ

ภาษา ANSI Common Lisp ไม่ได้กำหนดฟังก์ชัน main ไว้ แต่จะอ่านและประเมินโค้ดจากบนลงล่างในไฟล์ต้นฉบับแทน อย่างไรก็ตาม โค้ดต่อไปนี้จะจำลองการทำงานของฟังก์ชัน main

( defun hello-main () ( format t "Hello World!~%" ))( hello-main )

ในDต้นแบบฟังก์ชันของฟังก์ชันหลักจะมีลักษณะอย่างใดอย่างหนึ่งดังต่อไปนี้:

void main (); void main ( string [] args ); int main (); int main ( string [] args );

มีการส่งอาร์กิวเมนต์ผ่านบรรทัดคำสั่งargsคล้ายกับวิธีการในภาษา C# หรือ Java สำหรับเวอร์ชันที่main()ส่งค่าจำนวนเต็มกลับมานั้น คล้ายกับทั้งภาษา C และ C++ โดยจะส่งค่าดังกล่าวกลับไปยังสภาพแวดล้อมเป็นสถานะการออกจากกระบวนการ

Dartเป็นภาษาโปรแกรมอเนกประสงค์ที่มักใช้ในการสร้างเว็บและแอปพลิเคชันบนมือถือ เช่นเดียวกับภาษาโปรแกรมอื่นๆ อีกมากมาย Dart มีจุดเริ่มต้น (entry point) ซึ่งทำหน้าที่เป็นจุดเริ่มต้นของโปรแกรม Dart จุดเริ่มต้นคือฟังก์ชันแรกที่จะถูกเรียกใช้เมื่อโปรแกรมทำงาน ใน Dart จุดเริ่มต้นมักจะเป็นฟังก์ชันชื่อ `apply` mainเมื่อโปรแกรม Dart ทำงาน ระบบรันไทม์ของ Dart จะมองหาฟังก์ชันชื่อ `apply` mainและเรียกใช้ฟังก์ชันนั้น โค้ด Dart ใดๆ ที่ตั้งใจจะให้ทำงานเมื่อโปรแกรมเริ่มต้นควรอยู่ในmainฟังก์ชัน `apply` นี่คือตัวอย่างของmainฟังก์ชันง่ายๆ ใน Dart:

void main () { print ( "สวัสดีโลก!" ); }

ในตัวอย่างนี้mainฟังก์ชันจะพิมพ์ข้อความHello, world!ลงในคอนโซลเมื่อโปรแกรมทำงาน โค้ดนี้จะถูกเรียกใช้งานโดยอัตโนมัติเมื่อโปรแกรม Dart ทำงาน

สิ่งสำคัญที่ควรทราบคือ แม้ว่าmainฟังก์ชันจะเป็นจุดเริ่มต้นเริ่มต้นสำหรับโปรแกรม Dart แต่ก็สามารถระบุจุดเริ่มต้นอื่นได้หากจำเป็น โดยสามารถทำได้โดยใช้@pragma("vm:entry-point")คำอธิบายประกอบใน Dart อย่างไรก็ตาม ในกรณีส่วนใหญ่mainฟังก์ชันคือจุดเริ่มต้นที่ควรใช้สำหรับโปรแกรม Dart

FORTRANไม่มีซับรูทีนหรือฟังก์ชันหลัก แต่PROGRAMสามารถใช้คำสั่งเป็นบรรทัดแรกเพื่อระบุว่าหน่วยโปรแกรมเป็นโปรแกรมหลักได้ดังที่แสดงด้านล่างPROGRAMคำสั่งนี้ไม่สามารถใช้สำหรับการเรียกซ้ำได้^{[ 17 ]}

โปรแกรมHELLO พิมพ์* , "Cint!" จบโปรแกรมHELLO

ฟอร์ทรานบางเวอร์ชัน เช่น เวอร์ชันที่ใช้ใน เมนเฟรม IBM System/360และรุ่นต่อมา ไม่รองรับคำสั่ง PROGRAM แต่คอมไพเลอร์จากผู้ผลิตซอฟต์แวร์รายอื่น ๆ จะอนุญาตให้คอมไพล์โปรแกรมฟอร์ทรานได้โดยไม่ต้องใช้คำสั่ง PROGRAM ในกรณีเหล่านี้ โมดูลใดก็ตามที่มีคำสั่งที่ไม่ใช่ข้อความแสดงความคิดเห็น และไม่มีคำสั่ง SUBROUTINE, FUNCTION หรือ BLOCK DATA อยู่ จะถือว่าเป็นโปรแกรมหลัก (Main program)

เมื่อใช้GNATโปรแกรมเมอร์ไม่จำเป็นต้องเขียนฟังก์ชันชื่อ `main` mainเอง ไฟล์ต้นฉบับที่มีโปรแกรมย่อยเพียงโปรแกรมเดียวสามารถคอมไพล์เป็นไฟล์ปฏิบัติการได้ อย่างไรก็ตาม ตัวผูกไฟล์จะสร้างแพ็กเกจada_mainซึ่งจะบรรจุและส่งออกฟังก์ชัน `main` ในรูปแบบภาษาซี

ในภาษาโปรแกรมGomain การทำงานของโปรแกรมจะเริ่มต้นด้วย ฟังก์ชันของpackage main

แพ็คเกจหลักนำเข้า"fmt"func main () { fmt.Println ( " Hello, World! " ) }

ในภาษา Go ไม่มีวิธีใดที่จะเข้าถึงอาร์กิวเมนต์หรือรหัสส่งคืนนอกเหนือจากไลบรารีมาตรฐานได้ สามารถเข้าถึงได้ผ่านทางos.Argsและos.Exitตามลำดับ ซึ่งทั้งสองอย่างนี้รวมอยู่ใน"os"แพ็กเกจแล้ว

โปรแกรมHaskellต้องมีชื่อmainที่ผูกกับค่าของประเภทIO tสำหรับบางประเภทt[ ^{18 ] ซึ่ง}โดยปกติจะเป็นIO ()เป็นIOโมนาดซึ่งจัดระเบียบผลข้างเคียงในแง่ของโค้ดฟังก์ชันล้วนๆ^{[ 19 ]}ค่าmainแสดงถึงการคำนวณที่มีผลข้างเคียงที่โปรแกรมทำ ผลลัพธ์ของการคำนวณที่แสดงโดย จะmainถูกละทิ้ง นั่นคือเหตุผลที่mainโดยปกติจะมีประเภทIO ()ซึ่งบ่งชี้ว่าประเภทของผลลัพธ์ของการคำนวณคือ()ประเภทหน่วยซึ่งไม่มีข้อมูลใดๆ

main :: IO () main = putStrLn "Hello, World!"

ไม่สามารถส่งอาร์กิวเมนต์บรรทัดคำสั่งให้กับได้ ต้องดึง อาร์กิวเมนต์ mainเหล่านั้นโดยใช้การดำเนินการ IO อื่นๆ เช่นSystem.Environment.getArgs

โปรแกรม Java เริ่มทำงานที่ เมธอด main ของคลาส^{[ 20 ] [ 21 ] [ 22 ] [ 23 ]} ซึ่งมี หัวเมธอดหนึ่งต่อไปนี้:

// คลาสที่มีชื่อpublic static void main (); public static void main ( String [] args ); public static void main ( String ... args );// คลาสที่ไม่มีชื่อvoid main (); void main ( String [] args ); void main ( String ... args );

โปรดทราบว่าในภาษา Java การประกาศตัวแปร `and` นั้นเหมือนกันทุกประการ นอกจากนี้รูปแบบ variadicก็เหมือนกันกับที่ variadic คอมไพล์เป็นชนิดอาร์เรย์ (ความแตกต่างเพียงอย่างเดียวคือ `and` ถูกทำเครื่องหมายว่าเป็น variadic ในเมตาเดต้าของคลาส ) voidmain(String[]args);voidmain(Stringargs[]);voidmain(String...args);voidmain(String...args)

อาร์กิวเมนต์บรรทัดคำสั่งจะถูกส่งผ่านในเมธอด `main` argsเช่นเดียวกับในภาษา C และ C++ ชื่อ ` main()main` นั้นมีความพิเศษ เมธอด `main` ของ Java ไม่ส่งคืนค่าโดยตรง แต่สามารถส่งรหัสส่งคืนกลับไปยังระบบปฏิบัติการได้โดยตรงโดยการเรียกSystem.exit()เมธอด `main` ซึ่งจะทำให้โปรแกรมออกจากระบบก่อนกำหนด (แต่รหัสส่งคืนนี้ไม่ได้มาจากเมธอด `main` main())

ต่างจากภาษา C ตรงที่ชื่อของโปรแกรมไม่ได้รวมอยู่ในพารามิเตอร์ `main` argsเพราะมันคือชื่อของคลาสที่ประกอบด้วยเมธอด `main` ดังนั้นจึงทราบอยู่แล้ว นอกจากนี้ ยังต่างจากภาษา C ตรงที่จำนวนอาร์กิวเมนต์ไม่จำเป็นต้องระบุ เพราะอาร์เรย์ใน Java มีฟิลด์ที่ใช้ติดตามจำนวนองค์ประกอบอยู่แล้ว

ฟังก์ชันหลักจะต้องอยู่ภายในคลาส เนื่องจากในภาษา Java ทุกอย่างต้องอยู่ภายในคลาส ตัวอย่างเช่น โปรแกรม "hello world"ในภาษา Java อาจมีลักษณะดังนี้:

แพ็คเกจorg.wikipedia.examples ;public class HelloWorld { public static void main ( String [] args ) { System . out . println ( "Hello, world!" ); } }

ในการเรียกใช้โปรแกรมนี้ จำเป็นต้องเรียกใช้คำสั่งjava HelloWorldในไดเร็กทอรีที่ไฟล์คลาส ที่คอมไพล์แล้ว (HelloWorld.class ) อยู่ หรืออีกทางเลือกหนึ่งไฟล์JAR ที่สามารถเรียกใช้งานได้จะใช้ ไฟล์ manifestเพื่อระบุจุดเริ่มต้นการทำงานในลักษณะที่ไม่ขึ้นอยู่กับระบบไฟล์จากมุมมองของผู้ใช้

ตั้งแต่ Java 25 เป็นต้นมา สามารถสร้าง "ไฟล์ซอร์สโค้ดขนาดกะทัดรัด" ซึ่งประกาศfinalคลาสในแพ็กเกจที่ไม่มีชื่อโดยปริยายได้ คลาสนี้ขยายjava.lang.Objectและไม่ใช้งานอินเทอร์เฟซใดๆ มีเพียงคอนสตรัคเตอร์เริ่มต้น และมีฟิลด์และเมธอดที่ประกาศไว้ในไฟล์ซอร์สโค้ดขนาดกะทัดรัด^{[ 24 ]}นอกจากนี้ Java 25 ยังย้ายคลาสjava.io.IO(ซึ่งเปิดตัวครั้งแรกใน Java 23) ไปยังแพ็กเกจjava.lang(จึงนำเข้าโดยปริยายในไฟล์ซอร์สโค้ดทั้งหมด) โดยอิงจากSystem.outและSystem.inแทนที่จะเป็นjava.io.Consoleซึ่งทำให้โปรแกรม Hello World ง่ายขึ้น อาจคล้ายกับ C และ C++ มากขึ้น โดยที่mainอยู่ในเนมสเปซส่วนกลาง:

void main () { IO.println ( " Hello, world!" ) ; }

ในJavaScriptและTypeScriptไม่มีฟังก์ชัน "main" เนื่องจากโค้ดจะถูกประมวลผลทันทีที่พบเห็น อย่างไรก็ตาม สามารถจำลองการทำงานได้ดังนี้:

// เวอร์ชันที่ไม่ใช้ async: function main () : void { console . log ( "Hello world" ); }// เวอร์ชันแบบอะซิงโครนัส: async function main () : Promise < void > { console . log ( "Hello world" ); }// ในรูปแบบนี้ มีเพียงการเรียก main() เท่านั้นที่เป็นระดับบนสุด// อาจเป็นความคิดที่ดีที่จะเรียก main() และดักจับข้อผิดพลาดใดๆ// จากนั้นบันทึกข้อผิดพลาดเหล่านั้นอย่างเรียบร้อยดังนี้main (). catch (( err ) = > { console.error ( err ) ; process.exit ( 1 ) ; });

หากใช้Node.jsจะสามารถจำลอง รูปแบบการเขียนโค้ดแบบ Pythonได้ดังนี้: if__name__=="__main__":

ฟังก์ชันmain ( ) : void { console.log ( " กำลังทำงานในฐานะโมดูลหลัก" ); }ถ้า( require.main === module ) { main ( ) ; }

ในภาษา Juliaจุดเริ่มต้น (อย่างน้อยก็สำหรับสคริปต์ ดูด้านล่างสำหรับโปรแกรมที่คอมไพล์แล้ว) คือไฟล์โปรแกรมที่คุณเรียกใช้งานนั่นเอง กล่าวคือ ตั้งแต่บรรทัดแรกสุด คุณจึงสามารถทำได้ง่ายๆ ดังนี้ (หรือเริ่มต้นด้วย):

println ( "สวัสดีโลก! เรียกจาก$PROGRAM_FILE ด้วยอาร์กิวเมนต์ต่อไปนี้:" ); for x in ARGS ; println ( x ); end

ตั้งแต่ Julia เวอร์ชัน 1.11 เป็นต้นมา ยังมีวิธีในการกำหนดmainฟังก์ชันที่จะถูกเรียกใช้เป็นจุดเริ่มต้นได้ด้วย ซึ่งอาจมีลักษณะเช่นนี้หากใช้@mainมาโครที่เกี่ยวข้อง:

( @main )( ARGS ) = println ( "Hello World! Called from main." )

เพื่อให้เข้ากันได้กับ Julia เวอร์ชันก่อนหน้า เช่น Julia 1.10 ( LTS ) บรรทัดข้างต้นสามารถใช้งานได้โดยเพิ่มบรรทัดอีกหนึ่งบรรทัดจากเอกสารประกอบ และการใช้วิธีนี้สามารถช่วยได้เนื่องจาก "คุณสมบัติใหม่นี้มีจุดประสงค์เพื่อช่วยในการรวมเวิร์กโฟลว์ที่คอมไพล์และแบบโต้ตอบ" ^{[ 25 ]}วิธีการอื่น ๆ ที่ระบุไว้ในที่อื่น^{[ 26 ]}ไม่จำเป็นอีกต่อไป

วิธีแรกprintlnข้างต้นที่แสดงวิธีการเริ่มต้นการทำงานแบบเก่าโดยไม่ต้องกำหนดmainฟังก์ชันนั้นยังคงใช้ได้ดีสำหรับสคริปต์ (และ ARGS ก็สามารถใช้งานได้ทั้งสองกรณี โดยดึงมาจากตัวแปรส่วนกลางโดยตรง และ PROGRAM_FILE ก็สามารถใช้งานได้ทั้งสองกรณีเช่นกัน) โปรดทราบว่าหากคุณทำทั้งสองวิธี สคริปต์จะยังคงรันบรรทัดแรกตามปกติ และจากนั้นก็จะรันต่อไปเรื่อยๆ ดังนั้นจึงมีการเรียกmainและพิมพ์สองครั้ง แต่ทั้งสองวิธีไม่จำเป็นต้องเป็นโค้ดแรกที่ทำงานเว้นแต่คุณจะเรียกใช้ Julia --startup-file=noเนื่องจากไฟล์เริ่มต้นของ Julia จะทำงานก่อนสิ่งอื่นใด (ไฟล์นี้ว่างเปล่าหลังการติดตั้ง แต่สามารถลืมได้ง่าย เช่น เมื่อทำการวัดประสิทธิภาพ หากคุณได้เพิ่มโค้ดลงไป)

สถานะการออกจากโปรแกรมโดยค่าเริ่มต้นคือ 0 (เมื่อสำเร็จ การเปลี่ยนแปลงสถานะจะเกิดขึ้น) และexit(my_exit_code)เมื่อออกจากโปรแกรม สถานะการออกจากโปรแกรมจะไม่แสดงเป็นค่าเริ่มต้น

ในภาษา Kotlinฟังก์ชัน `main` มักจะอยู่ในระดับบนสุด ดังนี้:

fun main () { println ( "ไม่มีอาร์กิวเมนต์" ) }// พร้อมอาร์กิวเมนต์: fun main ( args : Array < String > ) { println ( "อาร์กิวเมนต์แรก: ${ args [ 0 ] } " ) }// รูปแบบกระชับ: fun main ( args : Array < String > ) = println ( args . joinToString ())

ในJava Virtual Machine (JVM) ไบต์โค้ดของ JVMจะแสดงสิ่งนี้เป็นstaticเมธอดของคลาส เนื่องจาก JVM ไม่รองรับฟังก์ชันระดับบนสุด ตัวอย่างเช่น ถ้าไฟล์ชื่อMain.kt :

public final class MainKt { public static void main ( String [] args ) { System . out . println ( "First argument: " + args [ 0 ] ); } }

ในFMSLogoเมื่อโหลดโปรแกรมแล้ว โปรแกรมเหล่านั้นจะไม่ทำงาน หากต้องการให้โปรแกรมเหล่านั้นทำงาน จำเป็นต้องใช้โค้ดต่อไปนี้:

ถึงโปรซีเนม ... ; คำสั่งเริ่มต้น (เช่น พิมพ์ [ยินดีต้อนรับ]) จบ 

สร้าง "startup [procname] 

ตัวแปรนี้startupใช้สำหรับรายการคำสั่งเริ่มต้น แต่ตามธรรมเนียมแล้วจะเรียกใช้โปรแกรมย่อยที่ดำเนินการตามคำสั่งเหล่านั้น โปรแกรมย่อยนั้นอาจมีชื่อใดก็ได้

OCamlไม่มีmainฟังก์ชัน โปรแกรมจะถูกประเมินจากบนลงล่าง

อาร์กิวเมนต์บรรทัดคำสั่งมีอยู่ในอาร์เรย์ที่มีชื่อSys.argvและสถานะการออกจะมีค่าเริ่มต้นเป็น 0

ตัวอย่าง:

print_endline "สวัสดีโลก"

ในภาษาปาสคาล ขั้นตอนหลัก (main procedure) เป็น บล็อกเดียวในโปรแกรมที่ไม่มีชื่อ เนื่องจากโปรแกรมปาสคาลกำหนดขั้นตอนและฟังก์ชันในลำดับจากล่างขึ้นบนที่เข้มงวดกว่าโปรแกรมซี ซี++ หรือจาวา ขั้นตอนหลักจึงมักเป็นบล็อกสุดท้ายในโปรแกรม ปาสคาลไม่มีความหมายพิเศษสำหรับชื่อ " main" หรือชื่อที่คล้ายกันใดๆ

โปรแกรมHello ( Output ) ; begin writeln ( 'Hello, world!' ) ; end .

อาร์กิวเมนต์บรรทัดคำสั่งจะถูกนับรวมParamCountและสามารถเข้าถึงได้ในรูปแบบสตริงโดยParamStr(n)โดยที่ n มีค่าอยู่ระหว่าง 0 ParamCountถึง

ภาษา Pascal เวอร์ชันที่รองรับหน่วยหรือโมดูล อาจมีบล็อกที่ไม่มีชื่ออยู่ภายในแต่ละหน่วย ซึ่งใช้สำหรับเริ่มต้นการทำงานของโมดูล บล็อกเหล่านี้จะถูกเรียกใช้งานก่อนที่จุดเริ่มต้นของโปรแกรมหลักจะถูกเรียก

ในภาษา Perlไม่มีฟังก์ชัน main คำสั่งต่างๆ จะถูกประมวลผลจากบนลงล่าง แม้ว่าคำสั่งภายในBEGINบล็อกจะถูกประมวลผลก่อนคำสั่งปกติก็ตาม

อาร์กิวเมนต์บรรทัดคำสั่งมีอยู่ในอาร์เรย์พิเศษ@ARGVซึ่งแตกต่างจากภาษา C ตรง@ARGVที่ไม่มีชื่อของโปรแกรม ซึ่งก็$0คือ

PHP ไม่มีฟังก์ชัน "main" นับตั้งแต่บรรทัดแรกของสคริปต์ PHP โค้ดใดๆ ที่ไม่ได้อยู่ในส่วนหัวของฟังก์ชันจะถูกเรียกใช้งานทันทีที่พบเห็น

ไวยากรณ์ ของPikeคล้ายกับของ C และ C++ การทำงานเริ่มต้นที่main`\n` argcตัวแปร `\n` เก็บจำนวนอาร์กิวเมนต์ที่ส่งไปยังโปรแกรมargvตัวแปร `\n` เก็บค่าที่เกี่ยวข้องกับอาร์กิวเมนต์ที่ส่งไปยังโปรแกรม

ตัวอย่าง:

int main ( int argc , array ( string ) argv )

โปรแกรม Pythonจะถูกประเมินจากบนลงล่าง เช่นเดียวกับภาษาสคริปต์ทั่วไป โดยจุดเริ่มต้นคือส่วนแรกของซอร์สโค้ด เนื่องจากคำนิยามต้องมาก่อนการใช้งาน โปรแกรมจึงมักมีโครงสร้างที่คำนิยามอยู่ด้านบนและโค้ดที่จะดำเนินการอยู่ด้านล่าง (ไม่เยื้อง) คล้ายกับโค้ดสำหรับคอมไพเลอร์แบบผ่านครั้งเดียวเช่นในภาษา Pascal

อีกทางเลือกหนึ่ง โปรแกรมสามารถจัดโครงสร้างด้วยmainฟังก์ชันที่ชัดเจนซึ่งมีโค้ดที่จะถูกเรียกใช้เมื่อโปรแกรมถูกเรียกใช้โดยตรง แต่ยังสามารถเรียกใช้ได้โดยการนำเข้าโปรแกรมเป็นโมดูลและเรียกใช้ฟังก์ชัน วิธีนี้สามารถทำได้โดยใช้สำนวนต่อไปนี้ ซึ่งอาศัย__name__การตั้ง ค่าตัวแปรภายใน __main__เมื่อโปรแกรมถูกเรียกใช้ แต่ไม่ใช่เมื่อนำเข้าเป็นโมดูล (ในกรณีนี้จะถูกตั้งค่าเป็นชื่อโมดูลแทน) มีโครงสร้างหลายรูปแบบดังนี้: ^{[ 27 ] [ 28 ] [ 29 ]}

นำเข้าซิสdef main ( argv : list [ str ]) -> int : argc : int = len ( argv ) # รับความยาวของ argv n : int = int ( argv [ 1 ]) print ( n + 1 ) return 0ถ้า__name__ == " __main__ " : sys.exit ( main ( sys.argv ) )​

ในสำนวนนี้ การเรียกไปยังจุดเริ่มต้นที่ระบุชื่อนั้นmainชัดเจน และการโต้ตอบกับระบบปฏิบัติการ (การรับอาร์กิวเมนต์ การเรียกฟังก์ชันออกจากระบบ) จะทำอย่างชัดเจนโดยการเรียกใช้ไลบรารี ซึ่งท้ายที่สุดแล้วจะถูกจัดการโดยรันไทม์ของ Python สิ่งนี้แตกต่างจากภาษา C ซึ่งสิ่งเหล่านี้จะทำ โดย ปริยายโดยรันไทม์ โดยอาศัยข้อตกลงร่วมกัน

ภาษาQB64ไม่มีฟังก์ชันหลัก (main function) โค้ดส่วนที่ไม่อยู่ภายในฟังก์ชันหรือซับรูทีนจะถูกประมวลผลก่อน โดยเรียงจากบนลงล่าง:

พิมพ์"สวัสดีโลก! a =" ; a = getInteger ( 1.8 d ): พิมพ์a

ฟังก์ชันgetInteger ( n เป็นสองเท่า) getInteger = int ( n ) สิ้นสุดฟังก์ชัน

สามารถอ่านค่าอาร์กิวเมนต์บรรทัดคำสั่ง (ถ้ามี) ได้โดยใช้ ฟังก์ชัน COMMAND$ :

dim shared commandline as string commandline = COMMAND$

'สามารถอ่านอาร์กิวเมนต์บรรทัดคำสั่งที่คั่นด้วยช่องว่างหลายรายการได้โดยใช้ COMMAND$(n) commandline1 = COMMAND$ ( 2 )

ในภาษา Rubyไม่มีฟังก์ชัน main ที่แยกต่างหาก แต่โค้ดที่เขียนอยู่นอกขอบเขตใดๆclass .. endจะmodule .. endถูกประมวลผลในบริบทของmainอ็อบเจ็กต์พิเศษ " " อ็อบเจ็กต์นี้สามารถเข้าถึงได้โดยใช้self:

irb(main):001:0> self => main

มีคุณสมบัติดังต่อไปนี้:

irb( main ) : 002 : 0> self.class = > Object irb(main):003:0> self.class.ancestors = > [ Object, Kernel, BasicObject]

เมธอดที่ถูกกำหนดไว้นอกขอบเขตของclassหรือmoduleจะถูกกำหนดให้เป็นเมธอดส่วนตัวของmainอ็อบเจ็กต์ " " เนื่องจากคลาสของ " main" คือObjectเมธอดดังกล่าวจึงกลายเป็นเมธอดส่วนตัวของอ็อบเจ็กต์เกือบทุกตัว:

irb(main):004:0> def foo irb(main):005:1> 42 irb(main):006:1> end => nil irb(main):007:0> foo => 42 irb(main):008:0> []. foo NoMethodError: private method `foo' called for []:Array  from (irb):8  from /usr/bin/irb:12:in `<main>' irb(main):009:0> false . foo NoMethodError: private method `foo' called for false:FalseClass  from (irb):9  from /usr/bin/irb:12:in `<main>'

จำนวนและค่าของอาร์กิวเมนต์บรรทัดคำสั่งสามารถกำหนดได้โดยใช้ARGVอาร์เรย์ค่าคงที่:

$ irb /dev/tty foo bar tty(main):001:0> ARGV ARGV => ["foo", "bar"] tty(main):002:0> ARGV.size ARGV.size => 2

องค์ประกอบแรกของARGV, , ประกอบด้วยอาร์กิวเมนต์บรรทัดคำสั่งแรก ไม่ใช่ชื่อของโปรแกรมที่ถูกเรียกใช้ เหมือนใน ^ภาษาARGV[0] C ชื่อของโปรแกรมสามารถเข้าถึงได้โดยใช้$0หรือ$PROGRAM_NAME[ ^{30 ]}

เช่นเดียวกับ Python เราสามารถใช้:

ถ้า__FILE__ == $PROGRAM_NAME # ใส่โค้ด "หลัก" ตรงนี้end

เพื่อเรียกใช้โค้ดบางส่วนเฉพาะเมื่อมีการระบุไฟล์ของโค้ดนั้นในrubyคำสั่งเรียกใช้งาน เท่านั้น

ในภาษา Rust จุดเริ่มต้นของโปรแกรมคือฟังก์ชันที่มีชื่อว่า `start` mainตามธรรมเนียมแล้ว ฟังก์ชันนี้จะอยู่ในไฟล์ที่ชื่อว่าmain.rs` container.js`

// ใน main.rs fn main () { println! ( "Hello, World!" ); }

main()std::process::Terminationอาจส่งคืนประเภทใดก็ได้ที่ ใช้คุณสมบัติ^{[ 31 ]}ภายในรันไทม์ของ Rust สิ่งเหล่านี้จะส่งคืนlibc::EXIT_SUCCESSเมื่อดำเนินการสำเร็จและlibc::EXIT_FAILUREเมื่อล้มเหลว

ใช้std :: io ;fn main () -> Result < (), io :: Error > { println! ( "Hello, World!" );ตกลง(()) // ส่งคืนประเภท Result ที่มีค่า Ok พร้อมเนื้อหา () ซึ่งเป็นประเภทหน่วย}

ในไลบรารีมาตรฐานของ Rust ประเภทต่อไปนี้มีการใช้งานสำหรับstd::process::Termination:

• !( ประเภทที่ไม่เคย )
• ()( ประเภทหน่วย )
• std::convert::Infalliable
• std::process::ExitCode(พร้อมค่าคงที่SUCCESSและFAIL)
• std::result::Result<T, E>

Rust ไม่มีพารามิเตอร์ในmain()ฟังก์ชันเหมือนกับ C++ และ Java หรือภาษาอื่นๆ ที่มีรูปแบบคล้าย Cแต่จะเข้าถึงอาร์กิวเมนต์จากบรรทัดคำสั่งโดยใช้ ` std::env::args()return` ซึ่งจะส่งค่าคืนเป็น `true` จาก std::env::Argsนั้นจึงแปลงเป็น `true` โดยVec<String>ใช้collect()` true`

ใช้std :: env ::{ self , Args }; ใช้std :: io ;fn main () -> Result < (), io :: Error > { let args : Args = env :: args (); // รับอาร์กิวเมนต์จากบรรทัดคำสั่งlet args_vec : Vec < String > = args . collect (); // รวบรวมอาร์กิวเมนต์ลงใน Vec<String>สำหรับarg ในargs_vec { println! ( "{}" , arg ); }ตกลง(()) }

เมื่อรันในXcode Playground ^{[ 32 ]} Swiftจะทำงานเหมือนภาษาสคริปต์ โดยดำเนินการคำสั่งจากบนลงล่าง อนุญาตให้ใช้โค้ดระดับบนสุดได้

// สนามเด็กเล่น HelloWorldให้hello = "hello" ให้world = "world"ให้helloWorld = hello + " " + worldพิมพ์( helloWorld ) // สวัสดีโลก

แอปพลิเคชันที่ใช้ CocoaและCocoa Touchซึ่งเขียนด้วย Swift มักจะเริ่มต้นด้วย แอตทริบิวต์ @NSApplicationMainและ@UIApplicationMainตามลำดับ แอตทริบิวต์เหล่านี้มีจุดประสงค์เทียบเท่ากับmain.mไฟล์ใน โปรเจกต์ Objective-Cกล่าวคือ แอตทริบิวต์เหล่านี้ประกาศmainฟังก์ชันที่เรียกUIApplicationMain(_:_:_:_:)^{[ 33 ]}ซึ่งสร้างอินสแตนซ์ของUIApplication[ ^{34 ] โดย ปริยาย}

โค้ดต่อไปนี้เป็นวิธีการเริ่มต้นใช้งาน แอป iOS ที่ใช้ Cocoa Touch ตามค่าเริ่มต้น และประกาศตัวแทนแอปพลิเคชัน (Application Delegate)

// AppDelegate.swiftนำเข้าUIKit@UIApplicationMain class AppDelegate : UIResponder , UIApplicationDelegate { var window : UIWindow ? func application ( _ application : UIApplication , didFinishLaunchingWithOptions launchOptions : [ UIApplication . LaunchOptionsKey : Any ]?) -> Bool { return true } }

ในVisual Basicเมื่อโปรเจ็กต์ไม่มีฟอร์ม วัตถุเริ่มต้นอาจเป็นMain()โปรซีเดอร์ได้ ฟังก์ชันนี้Command$สามารถใช้เพื่อเข้าถึงส่วนอาร์กิวเมนต์ของบรรทัดคำสั่งที่ใช้ในการเรียกใช้โปรแกรมได้ (เป็นทางเลือก):

Sub Main () Debug . Print "Hello World!" MsgBox "Arguments if any are: " & Command $ End Sub

ในXojoมีโปรเจ็กต์สองประเภทที่แตกต่างกัน โดยแต่ละประเภทมีจุดเริ่มต้นหลักที่แตกต่างกัน แอปพลิเคชันเดสก์ท็อป (GUI) เริ่มต้นด้วยApp.Openเหตุการณ์ของอ็อบเจ็กต์Applicationแอปพลิเคชันคอนโซลเริ่มต้นด้วยApp.Runเหตุการณ์ของอ็อบเจ็กต์ConsoleApplicationในทั้งสองกรณี ฟังก์ชัน main จะถูกสร้างขึ้นโดยอัตโนมัติและไม่สามารถลบออกจากโปรเจ็กต์ได้

• crt0คือชุดของรูทีนเริ่มต้นการทำงานที่เชื่อมโยงเข้ากับโปรแกรมภาษาซี
• ระบบรันไทม์

• สวัสดีจากโลกที่ปราศจาก libc! (ตอนที่ 1) เก็บถาวรเมื่อวันที่ 17 พฤศจิกายน 2016 ที่Wayback Machineเมื่อวันที่ 16 มีนาคม 2010
• เมธอด main ทำงานอย่างไรในภาษา Java