نقطة الدخول

في معظم لغات البرمجة وأنظمة التشغيل الشائعة اليوم، عادةً ما يكون لبرنامج الكمبيوتر نقطة دخول واحدة فقط .

في برامج C و C++ و D و Zig و Rust و Kotlin ، تُسمى هذه الدالة باسم `function`main ؛ وفي Java ، تُسمى دالة ثابتة باسم `static` main(مع أنه يجب تحديد الفئة عند الاستدعاء)؛ وفي C#، تُسمى دالة ثابتة باسم `static` Main. ^{[ 5 ] [ 6 ]}

في العديد من أنظمة التشغيل الرئيسية، يحتوي تنسيق الملفات التنفيذية القياسي على نقطة دخول واحدة. في تنسيق الملفات التنفيذية والربط (ELF)، المستخدم في أنظمة يونكس والأنظمة الشبيهة بيونكس مثل لينكس ، تُحدد نقطة الدخول في e_entryحقل رأس ELF. في مجموعة مترجمات جنو (gcc)، تكون نقطة الدخول التي يستخدمها الرابط هي _startالرمز. وبالمثل، في تنسيق الملفات التنفيذية المحمولة ، المستخدم في مايكروسوفت ويندوز ، تُحدد نقطة الدخول بواسطة AddressOfEntryPointالحقل الموروث من COFF . في ملفات COM ، تقع نقطة الدخول عند الإزاحة الثابتة 0100h.

يُعد نظام أندرويد استثناءً من نموذج نقطة الدخول الواحدة . فتطبيقات أندرويد لا تحتوي على نقطة دخول واحدة ، إذ لا توجد وظيفة خاصة بها. بدلاً من ذلك، تحتوي على مكونات أساسية (أنشطة وخدمات) يمكن للنظام تحميلها وتشغيلها حسب الحاجة. ^{[ 7 ]} main

من التقنيات المستخدمة أحيانًا تقنية الملف الثنائي المتكامل ، التي تتألف من عدة ملفات تنفيذية لأنظمة تشغيل مختلفة مُجمّعة في ملف واحد. ويتم ذلك عادةً عبر نقطة دخول رئيسية واحدة، متوافقة مع جميع الأنظمة، وتتفرع إلى نقطة الدخول الخاصة بكل نظام. وتشمل التقنيات البديلة تخزين الملفات التنفيذية المنفصلة في فروع منفصلة ، ​​لكل منها نقطة دخول خاصة بها، والتي يختارها نظام التشغيل.

تاريخيًا، وفي بعض الأنظمة القديمة المعاصرة ، مثل VMS و OS/400 ، تحتوي برامج الحاسوب على نقاط دخول متعددة ، كل منها يتوافق مع وظائف البرنامج المختلفة. والطريقة المعتادة للإشارة إلى نقاط الدخول، كما هو مستخدم على مستوى النظام في VMS وفي برامج PL/I و MACRO ، هي إلحاقها بنهاية اسم الملف التنفيذي ، مفصولة بعلامة الدولار ($)، على سبيل المثال directory.exe$make.

استخدم جهاز Apple I هذا الأسلوب أيضاً إلى حد ما. فعلى سبيل المثال، كانت نقطة الدخول البديلة في لغة BASIC الخاصة بجهاز Apple I تُبقي برنامج BASIC قابلاً للاستخدام عند الضغط على زر إعادة الضبط عن طريق الخطأ.

في لغة APL ، عند تحميل مساحة العمل، يتم تفسير محتويات متغير "quad LX" (التعبير الكامن) على أنها تعبير APL ويتم تنفيذه.

في لغتي C و C++ ، يجب أن يكون النموذج الأولي للدالة الرئيسية مكافئًا لأحد الخيارات التالية:

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. قد تحدد برمجة الأنظمة منخفضة المستوى (مثل برمجة الأنظمة المدمجة التي تعمل مباشرة على الجهاز ) نقطة دخول مختلفة (على سبيل المثال، عبر متجه مقاطعة إعادة الضبط ) باستخدام وظائف غير محددة في معيار اللغة.

مع أنواع الإرجاع اللاحقة ، 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 []);

تحتوي أنظمة التشغيل المستندة إلى داروين ، مثل macOS ، على معلمة رابعة تحتوي على معلومات عشوائية مقدمة من نظام التشغيل، مثل مسار الملف الثنائي القابل للتنفيذ: ^{[ 11 ]}

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

تُصبح القيمة المُعادة من الدالة الرئيسية حالة خروج العملية، مع أن معيار لغة C يُحدد معنىً مُعينًا لقيمتين فقط: EXIT_SUCCESS(تقليديًا 0) و EXIT_FAILURE. أما معنى القيم المُعادة الأخرى فيُحدده التنفيذ. في حال عدم تحديد المُبرمج لقيمة مُعادة، يُضيف المُترجم قيمة ضمنية في نهاية الدالة ؛ وهذا السلوك مطلوب بموجب معيار لغة C++.return0;main()

من المؤكد أن argcقيمة غير سالبة وأن argv[argc]مؤشر فارغ . بحسب الاصطلاح، تتضمن وسائط سطر الأوامر المحددة بواسطة argcو argvاسم البرنامج كعنصر أول إذا argcكانت أكبر من 0؛ إذا كتب المستخدم الأمر " rm file"، فستقوم الصدفةrm بتهيئة العملية باستخدام و . بما أن هو الاسم الذي تظهر به العمليات في ، إلخ، فقد تختار بعض البرامج، مثل البرامج الخفية أو تلك التي تعمل داخل مترجم أو آلة افتراضية (حيث يكون هو اسم الملف التنفيذي المضيف)، تغيير لإعطاء وصف أكثر ، عادةً عن طريق استدعاء النظام .argc=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++، يجب أن يكون اسم الدالة ضمن النطاق العام (أي `< اسم الدالة>`)، ولا يمكن إعادة تعريفها. في C++ (على عكس C)، لا يمكن استدعاء الدالة بشكل متكرر ، ولا يمكن الوصول إلى عنوانها. إذا لم يتم تعريف الدالة في النطاق العام (على سبيل المثال، إذا تم تعريفها فقط كدالة عضو في فئة)، فلن يكتشفها المترجم. الاسم غير محجوز، ويمكن استخدامه للدوال الأعضاء، والفئات، والتعدادات، أو الدوال غير الأعضاء في نطاقات أسماء أخرى.main()::mainmain()main()main()

استيراد std ؛باستخدام std :: span ؛ باستخدام std :: string_view ؛ باستخدام 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، طُرح اقتراحٌ لتوقيعٍ مُحدَّثٍ لـ `include` ، يُشبه توقيعَي Java وC# (اللذين يستخدمان `include` بدلاً من `include`، حيث يأخذ `include` مصفوفةً من السلاسل النصية). كان التوقيع المُقترح هو `include` (حيث لم يكن `include` جزءًا من اللغة آنذاك)، إلا أن هذا الاقتراح رُفض. ^{[ 12 ]}main()main(int,char*[])main(String[])intmain(initializer_list<string_view>args)span<T>

main()قد لا يكون روتينًا فرعيًا . ^{[ 13 ]}

ابتداءً من C++26 ، يمكن أن تحتوي الدالة على روابط؛ وهذا يسمح لوحدات تنفيذ الوحدات النمطية باختبار الكيانات الداخلية. ^{[ 14 ]}main()extern"C++"

وحدة ويكيبيديا . أمثلة ؛extern "C++" int main () { // ... }

عند تنفيذ برنامج مكتوب بلغة C# ، يبحث CLR عن دالة ثابتة مُعلَّمة بتوجيه .entrypointIL، والتي لا تأخذ أي وسيطات، أو تأخذ وسيطًا واحدًا من النوع string[]، ويكون نوع الإرجاع الخاص بها إما voidأو int، ثم يقوم بتنفيذها. ^{[ 15 ]}

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

يتم تمرير وسائط سطر الأوامر args، على غرار ما يتم في لغة جافا. أما بالنسبة للإصدارات التي Main()تُرجع عددًا صحيحًا، كما هو الحال في لغتي C و C++، فيتم إرجاعه إلى بيئة التشغيل كحالة خروج للعملية.

كما هو الحال في لغة جافا، فإن نقطة دخول البرنامج عادةً ما تكون موجودة في فئة مُسماة، على النحو التالي:

namespace Wikipedia.Examples ;باستخدام النظام ؛public class HelloWorld { static void Main ( string [] args ) { Console . WriteLine ( "Hello, world!" ); } }

منذ إصدار C# 7.1، توجد أربع توقيعات إضافية محتملة لنقطة الدخول، مما يسمح بالتنفيذ غير المتزامن في Main()الدالة؛ وتستخدم هذه System.Threading.Tasks.Taskالتوقيعات الفئة. ^{[ 16 ] [ 17 ]}

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

النوعان ` Taskand` و`is` Task<int>هما المكافئان غير المتزامنين للنوعين ` voidand` و`is` int(لاحظ أن ` Task<void>is` غير صالح). asyncيلزم استخدام `is` للسماح باستخدام الاستدعاءات غير المتزامنة (الكلمة awaitالمفتاحية `is`) داخل الدالة.

namespace Wikipedia.Examples ;باستخدام System ؛ باستخدام 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وتكون من نوع معين *World -> *Worldإذا غيّرت العالم، أو من نوع ثابت إذا كان البرنامج يطبع النتيجة فقط بعد الاختزالStart .

ابدأ :: * العالم -> * العالم ابدأ العالم = startIO ...

أو حتى أبسط من ذلك

ابدأ :: سلسلة نصية ابدأ = "مرحباً بالعالم!"

يُخبر هذا الخيار المُترجم بالخيار الذي يجب استخدامه لإنشاء الملف القابل للتنفيذ.

لا تُعرّف لغة ANSI Common Lisp دالة رئيسية؛ بل يُقرأ الكود ويُقيّم من أعلى إلى أسفل في ملف المصدر. مع ذلك، سيُحاكي الكود التالي دالة رئيسية.

( 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++، فيتم إرجاعه إلى بيئة التشغيل كحالة خروج العملية.

دارت هي لغة برمجة متعددة الأغراض تُستخدم غالبًا لبناء تطبيقات الويب والهواتف المحمولة. وكغيرها من لغات البرمجة، تحتوي دارت على نقطة دخول تُعدّ بمثابة نقطة البداية لبرنامج دارت. نقطة الدخول هي أول دالة تُنفَّذ عند تشغيل البرنامج. في دارت، عادةً ما تكون نقطة الدخول دالة تُسمى `input` main. عند تشغيل برنامج دارت، يبحث وقت تشغيل دارت عن دالة تُسمى `input` mainويُنفِّذها. يجب تضمين أي كود دارت مُراد تنفيذه عند بدء البرنامج في هذه mainالدالة. إليك مثال على mainدالة بسيطة في دارت:

void main () { print ( "Hello, world!" ); }

في هذا المثال، mainتقوم الدالة ببساطة بطباعة النص Hello, world!على وحدة التحكم عند تشغيل البرنامج. سيتم تنفيذ هذا الكود تلقائيًا عند تشغيل برنامج Dart.

على الرغم من أن هذه mainالدالة هي نقطة الدخول الافتراضية لبرنامج Dart، إلا أنه من الممكن تحديد نقطة دخول مختلفة عند الحاجة. يمكن القيام بذلك باستخدام التعليق @pragma("vm:entry-point")التوضيحي في Dart. مع ذلك، في معظم الحالات، تُعد هذه mainالدالة هي نقطة الدخول التي ينبغي استخدامها لبرامج Dart.

لا تحتوي لغة فورترانPROGRAM على روتين فرعي أو دالة رئيسية. بدلاً من ذلك، يمكن استخدام عبارة في السطر الأول لتحديد أن وحدة البرنامج هي برنامج رئيسي، كما هو موضح أدناه. PROGRAMلا يمكن استخدام هذه العبارة للاستدعاءات المتكررة. ^{[ 18 ]}

برنامج HELLO طباعة * ، "Cint!" نهاية برنامج HELLO

بعض إصدارات لغة فورتران، مثل تلك الموجودة على نظام IBM System/360 والأنظمة اللاحقة، لا تدعم عبارة PROGRAM. تسمح العديد من المترجمات من شركات برمجيات أخرى بتجميع برنامج فورتران بدون عبارة PROGRAM. في هذه الحالات، يُعتبر البرنامج الرئيسي هو أي وحدة تحتوي على أي عبارة غير تعليقية لا تتضمن عبارة SUBROUTINE أو FUNCTION أو BLOCK DATA.

باستخدام GNAT ، لا يُطلب من المبرمج كتابة دالة باسم معين main؛ إذ يمكن تجميع ملف مصدر يحتوي على برنامج فرعي واحد إلى ملف تنفيذي. مع ذلك، سيقوم المُجمِّع بإنشاء حزمة ada_main، والتي ستحتوي على دالة رئيسية مكتوبة بلغة C وتُصدِّرها.

في لغة البرمجة Gomain ، يبدأ تنفيذ البرنامج بوظيفةpackage main

الحزمة الرئيسيةاستيراد "fmt"func main () { fmt . Println ( "Hello, World!" ) }

لا توجد طريقة للوصول إلى الوسائط أو رمز الإرجاع خارج المكتبة القياسية في لغة Go. يمكن الوصول إليها عبر ` os.Argsand` و`and` os.Exitعلى التوالي، وكلاهما مُضمّن في "os"الحزمة.

يجب أن يحتوي برنامج Haskell على اسم mainمرتبط بقيمة من نوع معين IO t، حيث يكون هذا النوع عادةً t. ^{[ 19 ]} وهو عادةً IO (). IOهو موناد ، يُنظم الآثار الجانبية في شكل كود وظيفي بحت . ^{[ 20 ]} تمثل القيمة mainالحساب الذي يُجريه البرنامج والذي يتضمن آثارًا جانبية. يتم تجاهل نتيجة الحساب المُمثلة بـ main؛ ولهذا السبب mainيكون عادةً من النوع IO ()، مما يشير إلى أن نوع نتيجة الحساب هو ()، وهو نوع الوحدة ، الذي لا يحتوي على أي معلومات.

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

لا يتم تمرير وسائط سطر الأوامر إلى main؛ يجب جلبها باستخدام إجراء إدخال/إخراج آخر، مثل System.Environment.getArgs.

تبدأ برامج جافا بالتنفيذ عند الدالة الرئيسية للفئة، ^{[ 21 ] [ 22 ] [ 23 ] [ 24 ]} والتي تحتوي على أحد عناوين الدوال التالية :

// دالة عامة ثابتة void main (); دالة عامة ثابتة void main ( String [] args ); دالة عامة ثابتة void main ( String ... args );// دالة رئيسية غير مسماة تعتمد على الصنف void main (); void main ( String [] args ); void main ( String ... args );

لاحظ أنه في لغة جافا، فإن التصريحات متطابقة؛ بالإضافة إلى ذلك، فإن الشكل المتغير هو نفسه حيث يتم تجميع المتغيرات إلى نوع مصفوفة (الفرق الوحيد هو أن يتم وضع علامة على أنها متغيرة في بيانات تعريف الفئة ).voidmain(String[]args);voidmain(Stringargs[]);voidmain(String...args);voidmain(String...args)

يتم تمرير وسائط سطر الأوامر args. وكما هو الحال في لغتي C و C++، فإن الاسم " main()" له دلالة خاصة. لا تُرجع الدوال الرئيسية في جافا قيمة مباشرة، ولكن يمكن إرجاع رمز إرجاع مباشرة إلى نظام التشغيل عن طريق استدعاء الدالة System.exit()، مما يؤدي إلى إنهاء البرنامج قبل الأوان (ولكن رمز الإرجاع هذا لا يأتي من main()).

على عكس لغة C، لا يُدرج اسم البرنامج في Java args، لأنه اسم الصنف الذي يحتوي على الدالة الرئيسية، وبالتالي فهو معروف مسبقًا. أيضًا، على عكس لغة C، لا يلزم تضمين عدد الوسائط، لأن المصفوفات في Java تحتوي على حقل يُسجل عدد العناصر.

يجب تضمين الدالة الرئيسية داخل فئة. وذلك لأن كل شيء في لغة جافا يجب أن يكون محصورًا داخل فئة. على سبيل المثال، قد يبدو برنامج "مرحباً بالعالم" في جافا كما يلي:

package org.wikipedia.examples ;public class HelloWorld { public static void main ( String [] args ) { System . out . println ( "Hello, world!" ); } }

لتشغيل هذا البرنامج، يجب استدعاء البرنامج java HelloWorldمن المجلد الذي يحتوي على ملف الفئة المُجمَّع (HelloWorld.class ). بدلاً من ذلك، تستخدم ملفات JAR التنفيذية ملف بيان لتحديد نقطة الدخول بطريقة مستقلة عن نظام الملفات من وجهة نظر المستخدم.

منذ إصدار Java 25، أصبح من الممكن إنشاء "ملف مصدر مضغوط" يُعلن ضمنيًا عن finalفئة في حزمة غير مُسماة. ترث هذه الفئة من فئة أخرى java.lang.Objectولا تُنفذ أي واجهات، ولها مُنشئ افتراضي فقط، وتحتوي على الحقول والأساليب المُعلنة في ملف المصدر المضغوط. ^{[ 25 ]} علاوة على ذلك، ينقل 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!" ); }

في لغتي جافا سكريبت وتايب سكريبت ، لا توجد دالة "main" لأن الكود يُنفذ فور رؤيته. ومع ذلك، يمكن محاكاتها على النحو التالي:

// النسخة غير المتزامنة: 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 ، فمن الممكن محاكاة نمط بايثون التالي :if__name__=="__main__":

function main () : void { console.log ( " Running as main module" ); }إذا كان ( require.main === module ) { main ( ) ; }

في لغة جوليا، نقطة الدخول (على الأقل بالنسبة للبرامج النصية، انظر أدناه للبرامج المُجمّعة) هي ملف البرنامج نفسه الذي تقوم بتشغيله، أي من السطر الأول، لذا يمكنك ببساطة القيام بما يلي (أو البدء به):

println ( "Hello, world! Called from $PROGRAM_FILE with following arguments:" ); for x in ARGS ; println ( x ); end

منذ إصدار جوليا 1.11، أصبح من الممكن أيضًا تعريف mainدالة يتم استدعاؤها كنقطة دخول، ويمكن أن تبدو على سبيل المثال كما يلي عند استخدام @mainالماكرو المرتبط:

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

لضمان التوافق مع إصدارات جوليا السابقة، مثل جوليا 1.10 ( LTS )، يمكن تعديل السطر المذكور أعلاه بإضافة سطر واحد من الوثائق، ويمكن أن يساعد استخدام هذه الطريقة لأن "الميزة الجديدة تهدف إلى المساعدة في توحيد سير العمل المترجم والتفاعلي". ^{[ 26 ]} لم تعد هناك حاجة إلى الطرق الأخرى الموثقة في أماكن أخرى ^{[ 27 ] .}

الطريقة السابقة printlnالمذكورة أعلاه، والتي تُظهر الطريقة القديمة لإنشاء نقطة دخول دون تعريف دالة، mainلا تزال مناسبة تمامًا للبرامج النصية (ويتوفر المتغير ARGS في كلتا الحالتين، مباشرةً من متغير عام؛ وكذلك المتغير PROGRAM_FILE في كلتا الحالتين). لاحظ أنه في حال استخدام الطريقتين معًا، ستُنفذ البرامج النصية السطر الأول كالمعتاد، ومن ثم ستُنفذ الخطوات التالية، مما سيؤدي إلى استدعاء الدالة mainوطباعتها مرتين. ولكن لا يُشترط أن يكون أي منهما هو أول سطر يُنفذ إلا إذا استدعيت جوليا باستخدام --startup-file=noملف بدء التشغيل الافتراضي، حيث يُنفذ ملف بدء تشغيل جوليا الافتراضي قبل أي شيء آخر (يكون فارغًا بعد التثبيت، ولكن قد يُنسى بسهولة، على سبيل المثال عند إجراء اختبارات الأداء، إذا أضفت إليه أي شيء).

تكون حالة الخروج 0 افتراضيًا (عند النجاح، يؤدي طرح استثناء إلى تغيير ذلك)، exit(my_exit_code)ويخرج البرنامج بحالة غير افتراضية.

في لغة كوتلن ، غالباً ما تكون الدالة الرئيسية على المستوى الأعلى، كما يلي:

fun main () { println ( "لا توجد وسائط" ) }// مع الوسائط: fun main ( args : Array < String > ) { println ( "الوسيط الأول: ${ args [ 0 ] } " ) }// أسلوب مختصر: fun main ( args : Array < String > ) = println ( args . joinToString ())

في آلة جافا الافتراضية ، سيمثل رمز بايت JVMstatic هذا كطريقة من طرق فئة، لأن JVM لا تدعم الدوال ذات المستوى الأعلى. على سبيل المثال، إذا كان اسم الملف Main.kt :

public final class MainKt { public static void main ( String [] args ) { System . out . println ( "الوسيط الأول: " + args [ 0 ] ); } }

في برنامج FMSLogo ، لا يتم تنفيذ الإجراءات عند تحميلها. ولتنفيذها، يجب استخدام هذا الكود:

إلى اسم العملية ... ؛ أوامر بدء التشغيل (مثل طباعة [مرحباً]) نهاية

قم بتشغيل "startup [procname]"

يُستخدم المتغير startupلقائمة الإجراءات عند بدء التشغيل، ولكن جرت العادة على أن يستدعي هذا إجراءً يقوم بتنفيذ هذه الإجراءات. ويمكن أن يكون لهذا الإجراء أي اسم.

لا تحتوي لغة OCamlmain على دالة. يتم تقييم البرامج من الأعلى إلى الأسفل.

تتوفر وسائط سطر الأوامر في مصفوفة باسم معين Sys.argv، ويكون وضع الخروج 0 افتراضيًا.

مثال:

print_endline "Hello World"

في لغة باسكال ، يُعد الإجراء الرئيسي الكتلة الوحيدة غير المسماة في البرنامج. ولأن برامج باسكال تُعرّف الإجراءات والدوال بترتيب تصاعدي أكثر دقة من برامج C أو C++ أو جافا، فإن الإجراء الرئيسي عادةً ما يكون الكتلة الأخيرة في البرنامج. ولا تحمل لغة باسكال معنىً خاصًا لاسم " main" أو أي اسم مشابه.

برنامج Hello ( الإخراج ) ؛ ابدأ كتابة ( 'Hello, world!' ) ؛ نهاية .

يتم احتساب وسائط سطر الأوامر ParamCountويمكن الوصول إليها كسلاسل نصية بواسطة ParamStr(n)، حيث n بين 0 و ParamCount.

قد تحتوي إصدارات لغة باسكال التي تدعم الوحدات أو النماذج على كتلة غير مسماة في كل منها، تُستخدم لتهيئة النموذج. تُنفذ هذه الكتل قبل استدعاء نقطة دخول البرنامج الرئيسية.

في لغة بيرل ، لا توجد دالة رئيسية. يتم تنفيذ التعليمات من الأعلى إلى الأسفل، على الرغم من أن التعليمات الموجودة في BEGINكتلة برمجية يتم تنفيذها قبل التعليمات العادية.

تتوفر وسائط سطر الأوامر في مصفوفة خاصة @ARGV. على عكس لغة C، @ARGVلا تحتوي هذه المصفوفة على اسم البرنامج، وهو $0.

لا تحتوي لغة PHP على دالة "main". بدءًا من السطر الأول في سكربت PHP، يتم تنفيذ أي كود غير مضمن في رأس دالة بمجرد رؤيته.

في لغة بايك ، يكون بناء الجملة مشابهًا لبناء الجملة في لغتي C و C++. يبدأ التنفيذ عند main. argcيحتفظ المتغير " " بعدد الوسائط المُمرَّرة إلى البرنامج. argvويحتفظ المتغير " " بالقيمة المرتبطة بالوسائط المُمرَّرة إلى البرنامج.

مثال:

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

تُقيّم برامج بايثون من الأعلى إلى الأسفل، كما هو معتاد في لغات البرمجة النصية: نقطة الدخول هي بداية الكود المصدري. ولأن التعريفات يجب أن تسبق الاستخدام، تُبنى البرامج عادةً بحيث تكون التعريفات في الأعلى والكود المراد تنفيذه في الأسفل (بدون مسافة بادئة)، على غرار الكود الخاص بالمترجم أحادي المرور ، كما هو الحال في لغة باسكال.

بدلاً من ذلك، يمكن هيكلة البرنامج بدالة صريحة mainتحتوي على الكود المراد تنفيذه عند تشغيل البرنامج مباشرةً، ولكن يمكن استدعاؤها أيضًا باستيراد البرنامج كوحدة نمطية واستدعاء الدالة. ويمكن تحقيق ذلك باستخدام الأسلوب التالي، الذي يعتمد على __name__تعيين قيمة المتغير الداخلي __main__عند تشغيل البرنامج، وليس عند استيراده كوحدة نمطية (حيث يتم تعيين قيمته إلى اسم الوحدة النمطية). وهناك العديد من الصيغ المختلفة لهذه البنية: ^{[ 28 ] [ 29 ] [ 30 ]}

استيراد sysdef 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صريحًا، ويتم التفاعل مع نظام التشغيل (استقبال الوسائط، واستدعاء وظيفة الخروج) بشكل صريح عبر استدعاءات المكتبات، والتي يتولى وقت تشغيل بايثون معالجتها في النهاية. وهذا يختلف عن لغة C، حيث يتم ذلك ضمنيًا بواسطة وقت التشغيل، وفقًا للعرف السائد.

لا تحتوي لغة QB64 على دالة رئيسية، ويتم تنفيذ الكود الذي ليس داخل دالة أو روتين فرعي أولاً، من الأعلى إلى الأسفل:

اطبع "Hello World!" a =" ; a = getInteger ( 1.8 d ): اطبع a

الدالة getInteger ( n as double ) getInteger = int ( n ) end function

يمكن قراءة وسائط سطر الأوامر (إن وجدت) باستخدام الدالة COMMAND$ :

dim shared commandline as string commandline = COMMAND$

يمكن قراءة عدة وسائط سطر أوامر مفصولة بمسافات باستخدام COMMAND$(n) commandline1 = COMMAND$ ( 2 )

في لغة روبي ، لا توجد دالة رئيسية مستقلة. بدلاً من ذلك، يتم تنفيذ الكود المكتوب خارج أي 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أو كطرق خاصة بالكائن " ". وبما أن فئة " " هي ، فإن هذه الطرق تصبح طرقًا خاصة لكل كائن تقريبًا:modulemainmainObject

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: تم استدعاء الدالة الخاصة `foo` لـ []:Array  من (irb):8  من /usr/bin/irb:12:in `<main>' irb(main):009:0> false . foo NoMethodError: تم استدعاء الدالة الخاصة `foo` لـ false:FalseClass  من (irb):9  من /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. ^{[ 31 ]}

على غرار لغة بايثون، يمكن للمرء استخدام ما يلي:

إذا كان __FILE__ يساوي $PROGRAM_NAME # ضع الكود "main" هنا نهاية

لتنفيذ بعض التعليمات البرمجية فقط إذا تم تحديد ملفها في rubyالاستدعاء.

في لغة Rust، نقطة دخول البرنامج هي دالة تُسمى main. وبحسب الاصطلاح، توجد هذه الدالة في ملف يُسمى main.rs.

// في ملف main.rs، الدالة main () { println! ( "Hello, World!" ); }

main()قد تُرجع أي نوع يُنفذ السمة std::process::Termination. ^{[ 32 ]} داخليًا في وقت تشغيل Rust، ستُرجع هذه libc::EXIT_SUCCESSعند التنفيذ الناجح libc::EXIT_FAILUREوعند الفشل.

استخدم std :: io ؛fn main () -> Result < (), io :: Error > { println! ( "Hello, World!" );Ok (())) // إرجاع نتيجة من النوع 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()، والتي تُرجع قيمة std::env::Argsيمكن تحويلها بعد ذلك إلى ` Vec<String>باستخدام ` collect().

استخدم 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>for arg in args_vec { println! ( "{}" , arg ); }نعم (()) }

عند تشغيلها في Xcode Playground، ^{[ 33 ]} تتصرف Swift كلغة برمجة نصية، حيث تقوم بتنفيذ التعليمات من الأعلى إلى الأسفل؛ يُسمح باستخدام التعليمات البرمجية على المستوى الأعلى.

// HelloWorld.playgroundlet hello = "hello" let world = "world"let helloWorld = hello + " " + worldprint ( helloWorld ) // مرحباً بالعالم

عادةً ما تُهيأ التطبيقات المبنية على Cocoa و Cocoa Touch@NSApplicationMain والمكتوبة بلغة Swift باستخدام السمتين `<script>` و `<script> @UIApplicationMain` على التوالي. تُعادل هاتان السمتان في وظيفتهما main.mملف `<script>` في مشاريع Objective-C : فهما تُعلنان ضمنيًا عن mainالدالة التي تستدعي UIApplicationMain(_:_:_:_:)^{[ 34 ]} والتي بدورها تُنشئ نسخة من `<script> UIApplication`. ^{[ 35 ]}

الكود التالي هو الطريقة الافتراضية لتهيئة تطبيق iOS قائم على Cocoa Touch والإعلان عن مفوض التطبيق الخاص به.

// AppDelegate.swiftاستيراد UIKit@UIApplicationMain class AppDelegate : UIResponder , UIApplicationDelegate { var window : UIWindow ? func application ( _ application : UIApplication , didFinishLaunchingWithOptions launchOptions : [ UIApplication . LaunchOptionsKey : Any ]?) -> Bool { return true } }

في لغة فيجوال بيسك ، عندما لا يحتوي المشروع على نماذج، قد يكون كائن بدء التشغيل هو Main()الإجراء. Command$ويمكن استخدام الدالة اختيارياً للوصول إلى جزء الوسائط من سطر الأوامر المستخدم لتشغيل البرنامج.

Sub Main () Debug . Print "Hello World!" MsgBox "الوسائط إن وجدت هي: " & Command $ End Sub

في Xojo ، يوجد نوعان مختلفان من المشاريع، لكل منهما نقطة دخول رئيسية مختلفة. تبدأ تطبيقات سطح المكتب (واجهة المستخدم الرسومية) بحدث كائن App.Openالمشروع Application. أما تطبيقات سطر الأوامر فتبدأ بحدث كائن App.Runالمشروع ConsoleApplication. في كلتا الحالتين، يتم إنشاء الدالة الرئيسية تلقائيًا، ولا يمكن حذفها من المشروع.