لماذا الوظائف مهمة في البرمجة؟ أساسيات البرمجة: البرمجة الوظيفية

دالات على الأرقام.للغة VB الوظائف الرياضية التالية: عضلات المعدة(x) - حساب الوحدة ؛ sqr(x) - حساب الجذر التربيعي ، أتينيسي (x) - حساب قوس الظل. كوس(x) - حساب جيب التمام. الخطيئة(x) - حساب الجيب. تان(x) - حساب الظل. سجل(x) - حساب اللوغاريتم الطبيعي ، إكسب(x) - حساب الأس ، أين x- وسيطة دالة من النوع العددي. لحساب قيم الوظائف الغائبة في لغة VisualBasic ، من الضروري استخدام الصيغ المعروفة من الرياضيات.

تعبير ذ= في VB ستكتب على النحو التالي: y = sin (x ^ 2) + sqr (tan (x)) * (x + 5) ^ (1/5).

يجب كتابة وسيطة الوظيفة بين قوسين.

وظائف لتحويل قيمة من نوع إلى آخر.توفر لغة البرمجة VB وظائف لتغيير نوع بيانات القيمة. على سبيل المثال ، يوجد متغير من النوع Double ومتغير s من النوع String.

لكتابة متغير a إلى متغير s ، من الضروري إجراء تحويل من النوع S = CStr (a) ، وكتابة متغير s إلى متغير a – a = CDbl (s).

وظائف VB لتحويل نوع القيمة:

CStr - تحويل إلى سلسلة ؛

CByte - التحويل إلى بايت ؛

CInt - التحويل إلىInteger ؛

CLng - التحويل إلى Long ؛

CSng - التحويل إلى Single ؛

CDbl - تحويل إلى ملف مزدوج.

2.6. تمثيل أنواع مختلفة من البيانات في ذاكرة الكمبيوتر

لتمثيل المعلومات في ذاكرة الكمبيوتر (الرقمية وغير الرقمية) ، يتم استخدام طريقة تشفير ثنائية.

يبلغ طول الخلية الأولية لذاكرة الكمبيوتر 8 بت (بايت). كل بايت له رقمه الخاص (يطلق عليه عنوان). يسمى أكبر تسلسل من البتات يمكن للحاسوب معالجته ككل كلمة آلة. يعتمد طول الكلمة الآلية على طول كلمة المعالج ويمكن أن يكون 16 ، 32 ، 64 بتًا ، إلخ.

ترميز الأحرف. بايت واحد يكفي لترميز الأحرف. في هذه الحالة ، يمكن تمثيل 256 حرفًا (برموز عشرية من 0 إلى 255). غالبًا ما تكون مجموعة أحرف أجهزة الكمبيوتر الشخصية المتوافقة مع كمبيوتر IBM الشخصي امتدادًا لرمز ASCII (الكود القياسي الأمريكي لتبادل المعلومات - الكود الأمريكي القياسي لتبادل المعلومات). حاليًا ، يتم أيضًا استخدام تمثيلات ثنائية البايت للأحرف.

تمثيل الأعداد الصحيحة في مكمل اثنين.يعتمد نطاق القيم على عدد بتات الذاكرة المخصصة لتخزينها. يمكن أن تحمل ذاكرة n-bit قيم مختلفة ، على سبيل المثال ، تقع قيم النوع الصحيح في النطاق من -32768 (-2 15) إلى 32767 (2 15-1) ويتم تخصيص 2 بايت (16 بت) لتخزينها ؛ من النوع طويل - في النطاق من -2 31 إلى 2 31-1 وتقع في 4 بايت (32 بت).

للتمثيل بدون إشارة للأرقام الثنائية الصحيحة تختلف من 0 إلى
، وفي التمثيل الموقع - من
قبل
. في أجهزة الكمبيوتر الحديثة ، من المعتاد اختيار طول n لشبكة البت للأعداد الصحيحة كمضاعفات 8 (أي عدد صحيح من البايتات).

في حالة تمثيل كمية بعلامة ، يشير الرقم الموجود في أقصى اليسار إلى رقم موجب إذا كان يحتوي على صفر ، وسالب إذا كان يحتوي على واحد.

يتم ترقيم الأرقام من اليمين إلى اليسار ، بدءًا من 0. في الشكل. .2.2 يُظهر ترقيم البتات في كلمة آلة ثنائية البايت.

أرز. 2.2. حتحجيم البت في كلمة آلة ثنائية البايت

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

على سبيل المثال ، إذا تم الإعلان عن الرقم 37 (10) = 100101 (2) كقيمة عدد صحيح (ستة عشر بت موقعة) ، فسيكون الرمز المباشر الخاص به هو 0000000000100101 ، وإذا كان قيمة طويلة (32 بت موقعة) ) ، فسيكون رمزه المباشر. للحصول على تدوين أكثر إحكاما ، يتم استخدام التمثيل السداسي العشري للشفرة في كثير من الأحيان. يمكن إعادة كتابة الرموز الناتجة كـ 0025 (16) و 00000025 (16) على التوالي.

يمكن الحصول على الكود الإضافي لعدد صحيح سالب باستخدام الخوارزمية التالية:

اكتب الكود المباشر لوحدة الرقم ؛

قلبها (استبدل الآحاد بالأصفار والأصفار بأخرى) ؛

أضف واحدًا إلى الرمز العكسي.

على سبيل المثال ، لنكتب الرمز التكميلي للاثنين -37 ، ونفسره كقيمة طويلة (موقعة 32 بت):

الرمز المباشر للرقم 37 هو ؛

رمز معكوس

كود إضافي أو FFFFFFDB (16).

عند الحصول على رقم من خلال الكود الإضافي الخاص به ، أولاً وقبل كل شيء ، من الضروري تحديد علامته. إذا كان الرقم موجبًا ، فقم ببساطة بترجمة الكود الخاص به إلى نظام رقم عشري. في حالة وجود رقم سالب ، يجب تنفيذ الخوارزمية التالية:

اطرح الرقم 1 من الكود ؛

رمز معكوس

التحويل إلى نظام الأرقام العشري. اكتب الرقم الناتج بعلامة ناقص.

أمثلة.دعنا نكتب الأرقام المقابلة للرموز الإضافية:

0000000000010111. بما أن الصفر مكتوب في البتة الأكثر دلالة ، فإن النتيجة ستكون موجبة. هذا هو رمز الرقم 23.

1111111111000000. كود الرقم السالب مكتوب هنا. نقوم بتنفيذ الخوارزمية: 1) 1111111111000000 (2) - 1 (2) = 1111111110111111 (2) ؛ 2) 0000000001000000 ؛ 3) 1000000 (2) = 64 (10). الجواب: -64.

يعتبر مشغل الحلقة هو العامل الأكثر أهمية ويوجد في معظم لغات البرمجة الحديثة ، وتعود فكرة الحلقة إلى القرن التاسع عشر. تسمح لك الدورة بأداء سلسلة معينة من الإجراءات بشكل متكرر ، والتي يحددها المشغلون الذين يشكلون جسم الدورة.

لنبدأ بالمعامل حلقة مع شرط مسبق. هذا العامل يشبه:

بينما<условие>يفعل<оператор>.

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

في الحلقة ذات الشرط المسبق ، يحدد الشرط المسبق ما إذا كان سيتم تنفيذ جسم الحلقة قبل التكرار الأول أم لا. إذا كان هذا يتوافق مع منطق الخوارزمية ، فيمكن استخدام حلقة ذات حالة لاحقة.

حلقة مع حالة لاحقةيشبه:

يكرر...<выражние_1>حتى...<выражение_2>

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

Operator_1 ؛

المشغل_2 ؛

…………….

عامل التشغيل.

حتى<условие>

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

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

البديل الثالث لبيان الحلقة هو حلقة مع المعلمة. يمكن اعتبار أن هناك نوعين متشابهين جدًا من الدورة مع عداد. أول هؤلاء المشغلين هو:

لمعلمة الحلقة: = قيمة البداية إلى القيمة النهائية تفعل<оператор>;

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

بعد تنفيذ حلقة for ، تصبح قيمة متغير التحكم غير معرفة.

يشبه متغير الحلقة for ... downto ... do ... متغير الحلقة for حلقة for..to ... do ، باستثناء أن متغير التحكم فيه لا يزيد في كل خطوة تنفيذ ، ولكنه يقل بمقدار واحد:

ل: -<выражение_1>نازل إلى<выражение_2>يفعل<оператор>.

تلخيصًا ، يمكن صياغة التوصيات التالية لاستخدام الدورات:

استخدم حلقة for عندما تعرف بالضبط عدد مرات تنفيذ جسم الحلقة. خلاف ذلك ، استخدم حلقات التكرار أو أثناء.

· استخدم أثناء إذا كنت تريد إجراء الاختبار قبل تنفيذ جسم الحلقة.

· في بعض الأحيان يكون من الملائم التحقق من وجود مخرج محتمل من الحلقة في مكان ما في وسطها ، وليس في بدايتها أو نهايتها.

يتم توفير هذا الخروج من الحلقة بواسطة إجراء Break ، الذي يكسر تنفيذ الحلقة المتداخلة الداخلية ، سواء كان ذلك من أجل أو أثناء أو تكرار. يتم توصيل الوحدة المحددة بالبرنامج تلقائيًا ، إذا لزم الأمر.

بينما صحيح تبدأ

<Выражение_1>

لو<оператор>ثم كسر

<Выражение_2>؛ نهاية

وتجدر الإشارة أيضًا إلى إجراء المتابعة ، الذي يقطع تنفيذ جسم الجزء الداخلي من أجل ، أو أثناء ، أو تكرار الحلقة وينقل التحكم إلى رأسها ، بحيث يبدأ التكرار التالي للحلقة.

تكون خطوة الحلقة for ثابتة دائمًا وتساوي الفاصل الزمني بين أقرب قيمتين لنوع معلمة الحلقة.

Var (وصف معلمات الحلقة)

أنا: عدد صحيح (نوع عدد صحيح) ؛

ج: شار (نوع الحرف) ؛

1. ابدأ (طباعة أعداد صحيحة من 1 إلى 10)

بالنسبة إلى i: = 1 إلى 10 do writeln (i) ؛ (خطوة الحلقة هي 1)

2. (طباعة الأرقام من 10 إلى -10)

من 10 إلى -10 (خطوة الحلقة هي -1)

3. (طباعة الأحرف اللاتينية من الألف إلى الياء)

(تتغير معلمة الحلقة من A إلى R بترتيب أبجدي)

بالنسبة إلى c: = 'A' إلى 'R' do writeln (c) ؛

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

مثال: حساب المجموع من 1 إلى n.

var s، n، i: عدد صحيح ؛

writeln ('أدخل n') ؛

بالنسبة إلى i: = 1 إلى n do s: = s + i ؛

إذا كنت مطورًا مثلي ، فمن المحتمل أنك تعلمت نموذج OOP أولاً. كانت لغتك الأولى هي Java أو C ++ - أو ، إذا كنت محظوظًا ، Ruby أو Python أو C # - لذلك ربما تعرف الفئات والأشياء والحالات وما إلى ذلك. ما لا تفهمه حقًا هو أساسيات هذا النموذج الغريب المسمى البرمجة الوظيفية ، والذي يختلف اختلافًا كبيرًا ليس فقط عن OOP ، ولكن أيضًا عن أنواع البرمجة الإجرائية والموجهة نحو النموذج الأولي وأنواع البرمجة الأخرى.

أصبحت البرمجة الوظيفية شائعة - ولسبب وجيه. النموذج نفسه ليس جديدًا: ربما تكون هاسكل هي اللغة الأكثر فاعلية ، وقد نشأت في التسعينيات. لغات مثل Erlang و Scala و Clojure تندرج أيضًا تحت تعريف الوظيفة. تتمثل إحدى المزايا الرئيسية للبرمجة الوظيفية في القدرة على كتابة البرامج التي تعمل بشكل متزامن (إذا كنت قد نسيت بالفعل ما هي عليه - قم بتحديث ذاكرتك عن طريق القراءة) ، وبدون أخطاء - أي أن الجمود وسلامة الخيط لن يزعجك.

تتميز البرمجة الوظيفية بالعديد من المزايا ، ولكن أقصى استخدام ممكن لموارد وحدة المعالجة المركزية بسبب السلوك التنافسي هو ميزتها الرئيسية. أدناه ، سنلقي نظرة على المبادئ الأساسية للبرمجة الوظيفية.

مقدمة: كل هذه المبادئ اختيارية (العديد من اللغات لا تتبعها بالكامل). كلهم نظريون ويحتاجون إلى تعريف أدق للنموذج الوظيفي.

1. جميع الوظائف نظيفة

هذه القاعدة هي بالتأكيد القاعدة الرئيسية في البرمجة الوظيفية. تكون جميع الوظائف نقية إذا استوفت شرطين:

1. تُرجع الدالة التي يتم استدعاؤها بنفس الوسيطات القيمة نفسها دائمًا.
2. لا توجد آثار جانبية أثناء تنفيذ الوظيفة.

القاعدة الأولى واضحة - إذا استدعيت دالة sum (2 ، 3) ، أتوقع أن تكون النتيجة دائمًا 5. بمجرد استدعاء دالة rand () ، أو الوصول إلى متغير غير محدد في الوظيفة ، تم انتهاك نقاء الوظيفة ، وهذا غير مسموح به في البرمجة الوظيفية.

القاعدة الثانية - لا توجد آثار جانبية - أوسع في طبيعتها. التأثير الجانبي هو تغيير لشيء آخر غير الوظيفة التي يتم تنفيذها حاليًا. تغيير متغير خارج الوظيفة ، الكتابة إلى وحدة التحكم ، طرح استثناء ، قراءة البيانات من ملف كلها أمثلة على الآثار الجانبية التي تقلل من نقاء الوظيفة. قد يبدو هذا قيدًا خطيرًا ، لكن فكر مرة أخرى. إذا كنت متأكدًا من أن استدعاء الوظيفة لن يغير أي شيء "خارجي" ، فيمكنك استخدام هذه الوظيفة في أي سيناريو. هذا يمهد الطريق للبرمجة التنافسية والتطبيقات متعددة الخيوط.

2. جميع الوظائف من الدرجة الأولى وأعلى رتبة

هذا المفهوم ليس سمة من سمات FP (يتم استخدامه في Javascript و PHP واللغات الأخرى) - ولكنه مطلب. في الواقع ، تحتوي ويكيبيديا على مقالة كاملة مخصصة لوظائف من الدرجة الأولى. لكي تكون الوظيفة من الدرجة الأولى ، يجب أن تكون قابلة للإعلان عنها كمتغير. هذا يسمح بالوظيفة ليتم معالجتها كنوع بيانات عادي ولا يزال يتم تنفيذها.

3. المتغيرات ثابتة

كل شيء بسيط هنا. في البرمجة الوظيفية ، لا يمكنك تغيير متغير بعد تهيئته. يمكنك إنشاء متغيرات جديدة ، ولكن لا يمكنك تغيير المتغيرات الحالية - وبفضل هذا يمكنك التأكد من عدم تغير أي متغير.

4. الشفافية النسبية للوظائف

من الصعب إعطاء تعريف صحيح للشفافية النسبية. أعتقد أن هذا هو الأكثر دقة: إذا كان بإمكانك استبدال استدعاء دالة بقيمة إرجاع ، ولم تتغير الحالة ، فإن الوظيفة تكون شفافة نسبيًا. قد يكون هذا واضحًا ، لكني سأقدم مثالاً.

لنفترض أن لدينا وظيفة Java تضيف 3 و 5:

public int addNumbers () (إرجاع 3 + 5 ؛) addNumbers () // 8 8 // 8

من الواضح أنه يمكن استبدال أي استدعاء لهذه الوظيفة بالرقم 8 ، مما يعني أن الوظيفة شفافة نسبيًا. فيما يلي مثال على وظيفة غير شفافة:

printText عام باطل () (System.out.println ("Hello World") ؛) printText () // لا يُرجع شيئًا ، لكنه يطبع "Hello World"

لا تقوم هذه الوظيفة بإرجاع أي شيء ، ولكنها تطبع نصًا ، وإذا تم استبدال استدعاء الوظيفة بلا شيء ، فستكون حالة وحدة التحكم مختلفة - مما يعني أن الوظيفة ليست شفافة نسبيًا.

5. تعتمد البرمجة الوظيفية على حساب لامدا

تعتمد البرمجة الوظيفية بشكل كبير على نظام رياضي يسمى حساب لامدا. أنا لست متخصصًا في الرياضيات ، لذا لن أخوض في التفاصيل - لكني أريد أن أشير إلى مبدأين أساسيين في حساب لامدا يشكّلان مفهوم البرمجة الوظيفية:

1. في حساب التفاضل والتكامل lambda ، يمكن أن تكون جميع الوظائف مجهولة الهوية ، نظرًا لأن الجزء الوحيد ذي المعنى من رأس الوظيفة هو قائمة الوسائط.
2. عند الاتصال ، تمر جميع الوظائف بعملية كاري. وهي كالتالي: إذا تم استدعاء دالة بعدة وسيطات ، فسيتم تنفيذها في البداية باستخدام الوسيطة الأولى فقط وستُرجع دالة جديدة تحتوي على وسيطة واحدة أقل ، والتي سيتم استدعاؤها على الفور. هذه العملية متكررة وتستمر حتى يتم تطبيق جميع الوسائط ، مع إرجاع النتيجة النهائية. نظرًا لأن الوظائف نقية ، فهذا يعمل.

كما قلت ، لا ينتهي حساب لامدا عند هذا الحد - لكننا قمنا فقط بتغطية الجوانب الرئيسية المتعلقة بـ FP. الآن ، في محادثة حول البرمجة الوظيفية ، يمكنك وميض كلمة "lambda calculus" ، وسيعتقد الجميع أنك تتخبط 🙂

خاتمة

البرمجة الوظيفية هي إجهاد حقيقي للدماغ - لكنها طريقة قوية للغاية وأعتقد أن شعبيتها ستزداد فقط.

إذا كنت ترغب في معرفة المزيد عن البرمجة الوظيفية ، فننصحك بمراجعة أمثلة استخدام مبادئ FP في JavaScript (،) ، وكذلك تلك المخصصة للوظيفة C #.

الوظيفة في البرمجة هي قسم منفصل من الكود يمكن استدعاؤه بالرجوع إليه بالاسم الذي سميت به. عند الاستدعاء ، يتم تنفيذ أوامر جسم الوظيفة.

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

هناك العديد من الوظائف المضمنة في لغة البرمجة. لقد واجهنا بالفعل بعضًا منها في بايثون. وهي print () ، و input () ، و int () ، و float () ، و str () ، و type (). رمز أجسادهم غير مرئي لنا ، إنه في مكان ما "مخفي داخل اللغة". يتم تزويدنا فقط بواجهة - اسم الوظيفة.

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

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

أنا = 0 بينما أنا< 3 : a = int (input () ) b = int (input () ) print (a+b) i += 1

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

print () a = int (input ()) b = int (input ()) print ("Total"، a + b، "pcs") print () a = int (input ()) b = int (input ( )) طباعة ("Total"، a + b، "pieces")

مثال على تنفيذ البرنامج:

كم عدد الموز والأناناس للقرود؟ 15 5 مجموع 20 قطعة. كم عدد الخنافس والديدان للقنافذ؟ 50 12 مجموع 62 قطعة. كم عدد الأسماك والمحار لثعالب الماء؟ 16 8 مجموع 24 قطعة.

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

تعريف الوظيفة. بيان مواطنه

في لغة برمجة بايثون ، يتم تعريف الوظائف باستخدام العبارة def. ضع في اعتبارك الكود:

def countFood (): a = int (input ()) b = int (input ()) print ("Total"، a + b، "pcs")

هذا مثال على تعريف الوظيفة. مثل العبارات المعقدة الأخرى مثل العبارات والحلقات الشرطية ، تتكون الوظيفة من رأس وجسم. العنوان ينتهي بنقطتين وسطر جديد. الجسم مسنن.

تخبر الكلمة الأساسية def المترجم أنه تعريف دالة. ويتبع def باسم الوظيفة. يمكن أن يكون أي شيء ، بالإضافة إلى أي معرف ، على سبيل المثال ، متغير. في البرمجة ، من المستحسن للغاية إعطاء أسماء ذات معنى لكل شيء. لذلك في هذه الحالة ، تسمى الوظيفة "حساب الطعام" في الترجمة إلى اللغة الروسية.

يتم وضع الأقواس بعد اسم الوظيفة. في المثال أعلاه ، كانت فارغة. هذا يعني أن الوظيفة لا تقبل أي بيانات من البرنامج الذي يستدعيها. ومع ذلك ، يمكنها قبولها ، وبعد ذلك سيتم الإشارة إلى المعلمات المزعومة بين قوسين.

يتم اتباع القولون من قبل الجسم ، والذي يحتوي على التعليمات التي يتم تنفيذها عند استدعاء الوظيفة. يجب التمييز بين تعريف الوظيفة واستدعائها. في كود البرنامج ، هم ليسوا بجانب بعضهم البعض وليسوا معًا. يمكنك تحديد وظيفة ولكن لا تسميها أبدًا. لا يمكنك استدعاء وظيفة لم يتم تعريفها. إذا قمت بتعريف وظيفة ولكنك لم تسميها مطلقًا ، فلن تقوم بتنفيذ هيكلها أبدًا.

استدعاء وظيفة

ضع في اعتبارك النسخة الكاملة من البرنامج مع الوظيفة:

def countFood (): a = int (input ()) b = int (input ()) print ("Total"، a + b، "pcs") print ( "كم عدد الموز والأناناس للقرود؟") countFood () print ( "كم عدد الخنافس والديدان للقنافذ؟") countFood () print ( "كم عدد الأسماك والمحار لثعالب الماء؟") عدد الطعام ()

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

عندما يتم استدعاء دالة ، ينتقل مؤشر ترابط تنفيذ البرنامج إلى تعريفه ويبدأ في تنفيذ جسمه. بعد تنفيذ جسم الوظيفة ، يعود تدفق التنفيذ إلى الكود الرئيسي في المكان الذي تم استدعاء الوظيفة فيه. بعد ذلك ، يتم تنفيذ التعبير الذي يلي المكالمة.

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

مطبعة ( "كم عدد الموز والأناناس للقرود؟") countFood () print ( "كم عدد الخنافس والديدان للقنافذ؟") countFood () print ( "كم عدد الأسماك والمحار لثعالب الماء؟") countFood () def countFood (): a = int (input ()) b = int (input ()) print ("Total"، a + b، "pcs")

نتيجة:

كم عدد الموز والأناناس للقرود؟ Traceback (آخر مكالمة أخيرة): ملف "test.py" ، السطر 2 ، في< module>countFood () NameError: الاسم "countFood" غير محدد

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

تعطي الوظائف هيكلًا للبرنامج

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

افترض أنك بحاجة إلى كتابة برنامج يقوم بحساب مناطق الأشكال المختلفة. يحدد المستخدم المنطقة التي يريد حسابها. بعد ذلك يدخل البيانات الأولية. على سبيل المثال ، الطول والعرض في حالة المستطيل. لتقسيم مسار التنفيذ إلى عدة فروع ، استخدم عبارة if-elif-else:

الشكل = الإدخال () إذا كان الشكل == "1": أ = عائم (إدخال ("العرض:")) ب = عائم (إدخال ("الارتفاع:")) طباعة ("المنطقة:٪ .2f"٪ (أ * ب)) elif figure == "2": a = float (input ("Base:")) h = float (input ("Height:")) print ("Area:٪ .2f"٪ (0.5 * a * h)) elif figure == "3": r = float (input ("Radius:")) print ("Area:٪ .2f"٪ (3.14 * r ** 2)) else: print ("Input error" )

لا توجد وظائف هنا ، وكل شيء على ما يرام. لكن دعنا نكتب إصدارًا به وظائف:

def rectangle (): a = float (input ("Width:")) b = float (input ("Height:")) print ("Area:٪ .2f"٪ (a * b)) def triangle (): a = float (input ("Base:")) h = float (input ("Height:")) print ("Area:٪ .2f"٪ (0.5 * a * h)) def Circle (): r = float (الإدخال ("نصف القطر:")) طباعة ("المنطقة:٪ .2f"٪ (3.14 * r ** 2)) الشكل = الإدخال ( "1-مستطيل ، 2-مثلث ، 3 دوائر:") إذا كان الشكل == "1": المستطيل () شكل elif == "2": مثلث () شكل elif == "3": دائرة () وإلا: طباعة ("خطأ في الإدخال")

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

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

إذا احتجنا إلى استخدام هذه الوظائف في برنامج آخر ، فيمكننا استيرادها هناك من خلال الرجوع إلى ملف الكود هذا (ستتم مناقشة كيفية القيام بذلك في Python لاحقًا).

العمل التطبيقي

في البرمجة ، يمكنك استدعاء وظيفة أخرى من وظيفة واحدة. لتوضيح هذا الاحتمال ، اكتب برنامجًا كما هو موضح أدناه.

يتكون الفرع الرئيسي للبرنامج ، دون احتساب رؤوس الوظائف ، من سطر واحد من التعليمات البرمجية. هذه دعوة لوظيفة test (). يسأل عن عدد صحيح. إذا كانت موجبة ، فسيتم استدعاء الوظيفة الإيجابية () ، والتي يحتوي جسمها على الأمر لعرض كلمة "إيجابي" على الشاشة. إذا كان الرقم سالبًا ، فسيتم استدعاء الوظيفة السالبة () ، ويحتوي جسمه على تعبير لعرض كلمة "سلبي" على الشاشة.

المتغيرات المحلية والعالمية

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

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

تقريبًا ، كل شيء يبدو هكذا. سأشرح بإيجاز. نقوم بإنشاء بعض المتغيرات وتعيينها نتيجة تنفيذ وظيفة myfunc ، والتي بدورها تحسب قيمة تربيع بعض الأرقام. لا يتم تنفيذ الوظائف على الفور أثناء بدء تشغيل البرنامج ، ولكن فقط عندما يتم استدعاؤها. ربما يكون الأمر محيرًا بعض الشيء ، لكن هكذا هو الأمر.

كيف تستدعي وظيفة؟

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

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

الوظيفة hello () (echo "Hello، world!"؛)

ثم نسميها. وإذا لم تكن تحتوي على معاملات ، فسنضع أقواسًا فقط. لاستدعاء هذه الوظيفة ، نستخدم السطر فقط: مرحبًا()؛. يمكن لأي دالة أيضًا إرجاع قيمة باستخدام كلمة محجوزة. يعود. ينهي هذا البيان تنفيذ الوظيفة ويرسل القيمة المعادة إلى البرنامج المستدعي. مجموع الدالة ($ first، $ second) ($ r = $ first + $ second؛ return $ r؛) echo sum (2،5)؛ ستكون نتيجة تنفيذ البرنامج مساوية لـ 7. المتغيرات المحلية والعالمية

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

$ لكل = "ديما" ؛ function primer () // Do: إخراج متغير محلي (echo "My name is". $ per؛) echo primer ()؛

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

$ لكل = "ديما" ؛ function primer () // Performs: global variable output (global $ per؛ echo "My name is". $ per؛) echo primer ()؛

يجب أن يكون كل شيء على ما يرام الآن - تم حل المشكلة. فقط لا تنس أنه إذا غيرت الوظيفة قيمة متغير خارجي ، فإن مثل هذا التغيير سيؤثر على البرنامج بأكمله ، لذلك تحتاج إلى استخدام هذا المشغل بعناية!

الدالات ذات الوسيطتين أو أكثر

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

... خط الوظيفة ($ text، $ size = 5) // Do: output font size (echo " ". $ text.""؛) الخط (" مرحبًا
"، 1) ؛ الخط (" مرحبًا
"، 2)؛ الخط (" Hello
"، 3) ؛ الخط (" مرحبًا
"، 4) ؛ الخط (" Hello
"، 5) ؛ الخط (" Hello
"، 6) ؛ الخط (" Hello
");

حجم الخط افتراضيًا هو 5. إذا حذفنا المعامل الثاني للوظيفة ، فسيكون مساويًا لهذه القيمة.

خاتمة

قبل أن أقول وداعًا ، أود أن ألفت انتباهك إلى نصيحة واحدة. يتكون من وضع جميع الوظائف التي كتبتها في ملف واحد (على سبيل المثال ، function.php). وبعد ذلك ، في الملف الذي تريد استدعاء الوظيفة فيه ، ما عليك سوى تضمين function.php وسيكون كل شيء جاهزًا للاستخدام. هذا سيجعل فهم المنطق في برنامجك أسهل بكثير. للاتصال ، استخدم:

include_once ("function.php") ؛

need_once ("function.php") ؛

إذا فهمت جوهر المشكلة قيد النظر في هذه المقالة ، فأنا متأكد من أنه يمكنك بسهولة استخدام الوظائف في برامجك. مرة أخرى ، هذا لجعلها أكثر قابلية للتحرير وإعادة الاستخدام.