المحتوى عن 'guide'.



مزيد من الخيارات

  • ابحث بالكلمات المفتاحية

    أضف وسومًا وافصل بينها بفواصل ","
  • ابحث باسم الكاتب

نوع المُحتوى


التصنيفات

  • التخطيط وسير العمل
  • التمويل
  • فريق العمل
  • دراسة حالات
  • نصائح وإرشادات
  • التعامل مع العملاء
  • التعهيد الخارجي
  • مقالات عامة
  • التجارة الإلكترونية

التصنيفات

  • PHP
    • Laravel
    • ووردبريس
  • جافاسكريبت
    • Node.js
    • jQuery
    • AngularJS
    • Cordova
  • HTML5
  • CSS
    • Sass
    • إطار عمل Bootstrap
  • SQL
  • سي شارب #C
    • منصة Xamarin
  • بايثون
    • Flask
    • Django
  • لغة روبي
    • إطار العمل Ruby on Rails
  • لغة Go
  • لغة جافا
  • لغة Kotlin
  • برمجة أندرويد
  • لغة R
  • سير العمل
    • Git
  • صناعة الألعاب
    • Unity3D
  • مقالات عامّة

التصنيفات

  • تجربة المستخدم
  • الرسوميات
    • إنكسكيب
    • أدوبي إليستريتور
    • كوريل درو
  • التصميم الجرافيكي
    • أدوبي فوتوشوب
    • أدوبي إن ديزاين
    • جيمب
  • التصميم ثلاثي الأبعاد
    • 3Ds Max
    • Blender
  • مقالات عامّة

التصنيفات

  • خواديم
    • الويب HTTP
    • قواعد البيانات
    • البريد الإلكتروني
    • DNS
    • Samba
  • الحوسبة السّحابية
    • Docker
  • إدارة الإعدادات والنّشر
    • Chef
    • Puppet
    • Ansible
  • لينكس
  • FreeBSD
  • حماية
    • الجدران النارية
    • VPN
    • SSH
  • مقالات عامة

التصنيفات

  • التسويق بالأداء
    • أدوات تحليل الزوار
  • تهيئة محركات البحث SEO
  • الشبكات الاجتماعية
  • التسويق بالبريد الالكتروني
  • التسويق الضمني
  • استسراع النمو
  • المبيعات

التصنيفات

  • إدارة مالية
  • الإنتاجية
  • تجارب
  • مشاريع جانبية
  • التعامل مع العملاء
  • الحفاظ على الصحة
  • التسويق الذاتي
  • مقالات عامة

التصنيفات

  • الإنتاجية وسير العمل
    • مايكروسوفت أوفيس
    • ليبر أوفيس
    • جوجل درايف
    • شيربوينت
    • Evernote
    • Trello
  • تطبيقات الويب
    • ووردبريس
    • ماجنتو
  • أندرويد
  • iOS
  • macOS
  • ويندوز

التصنيفات

  • شهادات سيسكو
    • CCNA
  • شهادات مايكروسوفت
  • شهادات Amazon Web Services
  • شهادات ريدهات
    • RHCSA
  • شهادات CompTIA
  • مقالات عامة

أسئلة وأجوبة

  • الأقسام
    • أسئلة ريادة الأعمال
    • أسئلة العمل الحر
    • أسئلة التسويق والمبيعات
    • أسئلة البرمجة
    • أسئلة التصميم
    • أسئلة DevOps
    • أسئلة البرامج والتطبيقات
    • أسئلة الشهادات المتخصصة

التصنيفات

  • ريادة الأعمال
  • العمل الحر
  • التسويق والمبيعات
  • البرمجة
  • التصميم
  • DevOps

تمّ العثور على 5 نتائج

  1. تعتمد صفحات الويب على HTML التي تُحدد محتوى الصفحة.تعدّ CSS لغة منفصلة عن HTML ودورها هو تحديد الشكل والمظهر الخاص بصفحة الويب. الشفرة الخاصّة بـ CSS عبارة عن قواعد ساكنة. كل قاعدة تأخذ مُحدِدًا Selector أو أكثر، وتُرجع قيم لمجموعة من الخصائص الشكلية. تُطبَّق هذه الخصائص بعد ذلك على عناصر صفحة الويب المشار إليها بواسطة المحددات. ملاحظة: لتعلم CSS بطريقة صحيحة، ولأن مخرجات هذه اللغة عبارة عن نتائج مرئية، يجب عليك ممارسة كل ما تتعلمه وننصحك بتطبيقه على موقع dabblet. الهدف الرئيسي من هذا المقال التركيز على كيفية الكتابة الصحيحة مع بعض النصائح. سنتناول في هذا المقال العناوين التالية: التعليقات. المحددات. الخصائص. طريقة استخدام CSS في الصفحة. الأولوية أم التتالي. استعلامات الميديا. التوافقية. التعليقات توجد طريقة واحدة لكتابة التعليقات في ملف CSS وهي كتابة التعليقات بين الرمزين /* */. /* التعليقات تُتكتب هنا ولا يوجد نمط لكتابة التعليق في سطر واحد سوى هذه الطريقة */ المحددات يُستخدم المحدد في استهداف عنصر في صفحة، ويُكتَب بالطريقة التالية: selector { property: value; /* خصائص أخرى*/ } لنفترض وجود العنصر التالي من نوع div في صحة ويب: <div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' /> تستطيع تطبيق قاعدة CSS على هذا العنصر باستخدام أحد أسماء الأصناف Classes التي ينتمي إليها في الصفحة: .class1 { } أو باستخدام جميع أسماء الأصناف المطبَّقة عليه: .class1.class2 { } أو باستخدام نوع العنصر: div { } أو باستخدام الرقم الخاص بالعنصر: #anID { } نستطيع تحدد العنصر من الصفحة في حال وجود صفة Attribute باسم معين: [attr] { font-size:smaller; } أو في حالة وجود صفة بقيمة معينة: [attr='value'] { font-size:smaller; } في حالة وجود صفة معينة في عنصر، ونريد تطبيق قاعدة على هذا العنصر بشرط وجود قيمة تبدأ منها الصفة نستخدم الطريقة التالية: [attr^='val'] { font-size:smaller; } أما إن كان الشرط يتعلّق بقيمة معينة تنتهي بها الصفة: [attr$='ue'] { font-size:smaller; } نستطيع تحديد العنصر في حالة احتواء الصفة على قيمة معينة ضمن قائمة قيم منفصلة عن بعضها بمسافة فارغة (يوافق الشرط أدناه العناصر التي لديها صفة otherAttr تساوي “foo” أو “foo bar” أو “foo bar far” …إلخ): [otherAttr~='foo'] { } أو تحديد العنصر في حالة احتواء الصفة على قيمة معينة ضمن قائمة قيم منفصلة عن بعضها برمز – كما في المثال التالي: [otherAttr|='en'] { font-size:smaller; } نستطيع جمع أكثر من مُحدد ببعضها للحصول على مُحدد مُركز كما في المثال التالي: div.some-class[attr$='ue'] { } من الممكن أيضا أن تقوم بتحديد عنصر يكون تابعا (ابن) لعنصر آخر: div.some-parent > .class-name { } في المثال السابق، يكون العنصر الابن على مستوى واحد أسفل من العنصر الأب. تستطيع أن تُحدد عنصر من سلالة عنصرآأخر (الأب)، وهذا يعني من أي مستوى أسفل من مستوى العنصر الأب (ليس شرطا أن يكون مستوى واحد أقل): div.some-parent .class-name { } يختلف المُحدد التالي عن المُحدد السابق لوجود مسافة فاصلة بين الأسماء: div.some-parent.class-name { } نستطيع تحديد العنصر بناءً على عنصر آخر مجاور له باستخدام الطريقة التالية: .i-am-just-before + .this-element { } أو بناءً على أي عنصر يسبق العنصر الذي نريده: .i-am-any-element-before ~ .this-element { } توجد بعض المُحددات تسمى الأصناف الزائفة pseudo classes تطبَّق على العنصر عندما يكون بحالة محددة، فمثلا، نستطيع تحديد عنصر عندما يمر عليه المؤشر: selector:hover { } أو رابط تمت زيارته: selector:visited { } أو لم تتم زيارته: selected:link { } أو عنصر في حالة التركيز: selected:focus { } لتحديد أول عنصر تابع لعنصر: selector:first-child {} لتحديد آخر عنصر تابع لعنصر: selector:last-child {} نستطيع تنسيق أجزاء محددة من العنصر باستخدام العناصر الزائدة Pseudo elements، فمثلا، نستخدم before لإضافة محتوى قبل محتوى عنصر معين: selector::before {} وafter لإضافة محتوى بعد محتوى عنصر معين: selector::after {} في أماكن معينة، يُستخدم رمز * كحرف “بدل” لاختيار كافة العناصر. * { } /* كل العناصر */ .parent * { } /* كل التابعين */ .parent > * { } /* كل الأبناء */ الخصائص selector { وحدات الطول إما مطلقة أو نسبية. الوحدات النسبية: width: 50%; /* نسبة من عرض العنصر الأب */ font-size: 2em; /* مضاعفة حجم الخط الخاص بالعنصر نفسه*/ font-size: 2rem; /* مضاعفة حجم الخط حسب حجم الخط الخاص بالعنصر الأب */ font-size: 2vw; /* مضاعفة حجم الخط بالنسبة ل 1% من عرض المساحة المرئية للمستخدم*/ font-size: 2vh; /* من الارتفاع*/ font-size: 2vmin; /* مضاعفة حجم الخط لأصغر قيمة من الارتفاع أو العرض*/ font-size: 2vmax; /* لاكبر قيمة */ القيم المطلقة: width: 200px; /* بكسل */ font-size: 20pt; /* نقطة */ width: 5cm; /* سنتميتر */ min-width: 50mm; /* مليميتر */ max-width: 5in; /* إنش */ الألوان: color: #F6E; /* صيغة سداسية قصيرة */ color: #FF66EE; /* صيغة سداسية طويلة */ color: tomato; /* حسب الاسم */ color: rgb(255, 255, 255); /* كقيم rgb */ color: rgb(10%, 20%, 50%); /* كنسبة rgb */ color: rgba(255, 0, 0, 0.3); /* كقيم rgba */ color: transparent; /* الشفافية صفر*/ color: hsl(0, 100%, 50%); /* كنسب hsl */ color: hsla(0, 100%, 50%, 0.3); /* كنسب hsla */ الحدود: border-width:5px; border-style:solid; border-color:red; border: 5px solid red; /* اختصار القواعد السابقة في قاعدة واحدة */ border-radius:20px; /* خاصية ابتداء من css3 */ الصور: background-image: url(/img-path/img.jpg); الخطوط: font-family: Arial; إذا كان اسم الخط به مسافات فيجب وضع الاسم بين علامتي تنصيص: font-family: "Courier New"; في نسرُد لائحة من الخطوط وإن لم يجد المتصفح الخط، يستخدم نوع الخط التالي: font-family: "Courier New", Trebuchet, Arial, sans-serif; } طريقة استخدام CSS في الصفحة توجد ثلاث طرق لإجراء عملية تنسيق صفحة الويب وهي كالتالي: 1- تضمين اسم الملف بالامتداد .css داخل العنصر head في بداية صفحة html كالتالي (وهي الطريقة المُوصى بها): <link rel='stylesheet' type='text/css' href='path/to/style.css'> 2- كتابة قواعد css مباشرة في ملف الصفحة: <style> a { color: purple; } </style> 3- تنسيق العنصر بطريقة مباشرة: <div style="border: 1px solid red;"> </div> الأولوية أم التتالي العنصر الواحد في صفحة الويب قد يكون مُستهدفا (محددا) من قبل مجموعة متعددة من المحددات، وقد يكون هناك تعديل أو تحديد لقيمة خاصية تابعة لهذا العنصر من قبل أكثر من مُحدد. في مثل هذه الحالات، فإن قاعدة واحدة سيكون لها الأولوية في التطبيق على هذا العنصر. القواعد التي تمتلك محددات مُفصلة لها أولوية على المحددات ذات التفاصيل الأقل، والقواعد التي تأتي في النهاية تقوم بالتعديل على القواعد التي قبلها (وهذا يعني أنه في حالة تضمين ملفي css وكلاهما يقومان بتحديد عنصر والتعديل على خصائصه، فإن ترتيب ربط الملفات يحكم تنسيق العنصر حسب قاعدة الترتيب المذكورة والتي تُسمى التتالي أو التتابع). استعلامات الوسائط Media queris استعلامات الوسائط هي خاصية بدأت من CSS 3 وتسمح لك بتحديد متى تُطبَّق قواعد CSS، مثلا عند الطباعة، أو عند كثافة وأبعاد شاشة معينين. أمثلة: هذه قاعدة CSS تُطبَّق على كل الأجهزة. h1 { font-size: 2em; color: white; background-color: black; } يعدّل استعلام الوسيط التالي القاعدة السابقة عند الطباعة: @media print { h1 { color: black; background-color: white; } } يجعل استعلام الوسيط التالي حجم الخط أكبر في شاشة بعرض 480 بكسل على الأقل: @media screen and (min-width: 480px) { h1 { font-size: 3em; font-weight: normal; } } تحتوي استعلامات الوسائط على الخصائص التالية: width, height, device-width, device-height, orientation, aspect-ratio, device-aspect-ratio, color,color-index, monochrome, resolution, scan, grid. من الممكن أن يسبق أغلب الخصائص السابقة خاصيتي min- و max-. خاصية الدقة Resolution غير مدعومة على الأجهزة القديمة، وبدلا من ذلك استخدم خاصية device-pixel-ratio. تحاول كثير من أجهزة الجوال والأجهزة اللوحية عرض الصفحة كما لو كانت على سطح المكتب العادي إلا إذا قمت بإضافة الصفة viewport بالشكل التالي: <head> <meta name="viewport" content="width=device-width; initial-scale=1.0"> </head> التوافقية أغلب المميزات والخصائص الموجودة في CSS2 وكثيرا من CSS3 موجودة في كل المتصفحات والأجهزة، ولكن ينصح من باب الممارسة الأفضل أن يتم الفحص قبل استخدام الخاصية الجديدة. ترجمة – بتصرّف – للمقال Learn X in Y minutes Where X=CSS.
  2. وضع Netscape’s Brendan Eich أسس جافا سكريبت سنة 1995. وكان الغرض منها أن تكون لغة ترميز سهلة خاصة بالمواقع ومكملة للجافا في تطبيقات الويب المعقدة، ولكن سهولة دمج جافا سكريبت والدعم الذاتي لها مع المتصفحات جعلها أكثر شيوعًا من لغة الجافا الأصلية في واجهات الويب. لا يقتصر استخدام جافا سكريبت مقتصرة على المتصفحات، ف Node.js مشروع قائم بذاته ويقدم إمكانية بناء تطبيقات إنترنت قائمة بذاتها. صيغة الشفرة البرمجية الخاصة بجافا سكريبت شبيهة بطريقة كتابة لغة C، فإذا كنت قد تعاملت مع لغة البرمجة C قبل ذلك أو جافا، ستكون الكثير من الأساسيات مألوفة لك. على الرغم من ذلك، وعلى الرغم من سهولة الاسم، إلا أن النموذج الكائني في جافا سكريبت مختلف تماماً عن الموجود في الجافا. سنتناول في هذا المقال المواضيع التالية: التعليقات. الأرقام، النصوص والعمليات. المتغيرات، المصفوفات والكائنات. جمل التحكم والمنطق. الدوال، نطاق الوصول و Closures. المشيّدات Constructors والنماذج الأولية Prototypes التعليقات لكتابة تعليق من سطر واحد نبدأ السطر بعلامتي / كما في السطر التالي: // Single-line comments start with two slashes. لكتابة تعليق من أكثر من سطر، نستخدم /* و */ في إحاطة الأسطر التي نريدها كما في الأسطر التالية: /* Multiline comments start with slash-star، and end with star-slash */ تنتهي الجمل في جافا سكريبت بفاصلة منقوطة، ولكن هذا الأمر غير ضروري، حيث يتم إضافة الفاصلة المنقوطة تلقائيا عند وجود سطر جديد وعدم وجود الفاصلة، وهذا الأمر مستثنى في بعض الحالات: doStuff(); بدون فاصلة: doStuff() سنعتمد في هذا الدرس استخدام الفاصلة المنقوطة. الأرقام، النصوص والعمليات تحتوي جافا سكريبت على نوع رقمي واحد (64-bit IEEE 754 double). الأرقام من نوع Double (الأعداد الحقيقة) تحتوي على 52 بت من الأساس العشري، بما يكفي لتخزين الأعداد الصحيحة Integers حتى 9✕10¹⁵ بدقة. 3; // = 3 1.5; // = 1.5 بعض العمليات الحسابية الأساسية: 1 + 1; // = 2 0.1 + 0.2; // = 0.30000000000000004 8 - 1; // = 7 10 * 2; // = 20 35 / 5; // = 7 5 / 2; // = 2.5 10 % 2; // = 0 30 % 4; // = 2 18.5 % 7; // = 4.5 العمليات الثنائية متاحة أيضا، فعند إجراءك لعملية ثنائية، فإن الأعداد العشرية Float يتم تحويله إلى أعداد طبيعية Int حتى 32 بت: 1 << 2; // = 4 ترتيب العمليات يتم بواسطة استخدام الأقواس: (1 + 3) * 2; // = 8 توجد ثلاثة قيم أرقام غير حقيقية كالتالي: Infinity; // ناتجة عن قسمة رقم موجب على صفر -Infinity; // ناتجة عن قسمة رقم سالب على صفر NaN; //تشير إلى قيمة "غير رقم" القيم المنطقية: true; false; يتم استخدام علامة التنصيص المنفردة أو المزدوجة لبناء النصوص: 'abc'; "Hello، world"; لعكس القيمة نستخدم علامة التعجب: !true; // = false !false; // = true لفحص المساواة: 1 === 1; // = true 2 === 1; // = false لفحص عدم المساواة: 1 !== 1; // = false 2 !== 1; // = true عمليات المقارنة: 1 < 10; // = true 1 > 10; // = false 2 <= 2; // = true 2 >= 2; // = true دمج النصوص يتم بواسطة عملية + : "Hello " + "world!"; // = "Hello world!" وعملية الدمج + لا تعمل فقط مع النصوص، بل مع الأرقام أيضا والتراكيب مثل المصفوفات: "1، 2، " + 3; // = "1، 2، 3" "Hello " + ["world"، "!"] // = "Hello world،!" من الممكن مقارنة النصوص: "a" < "b"; // = true لإجراء عملية فحص المساواة باعتبار تحويل أنواع البيانات (في حالة اختلافها) نستخدم عملية = مرتين: "5" == 5; // = true null == undefined; // = true في حالة استخدام = ثلاثة مرات، لا تتم عملية التحويل: "5" === 5; // = false null === undefined; // = false لابد من الانتباه من التحويل التلقائي للنوع تجنبا لبعض الحالات غير المرغوبة: 13 + !0; // 14 "13" + !0; // '13true' نستخدم charAt للوصول لمحرف Character معين في النصوص بتعيين مكانها في سلسلة المحارف: "This is a string".charAt(0); // = 'T' أو نستخدم substring للحصول على أجزاء أكبر من النصوص: "Hello world".substring(0, 5); // = "Hello" length تعتبر خاصية، لذلك لا تستخدم الأقواس في النهاية: "Hello".length; // = 5 نستخدم null للإشارة للفارغ أو غير الموجود، بينما نستخدم undefined للإشارة لقيمة غير منشأة أو غير موجودة حاليا (مثل تعريف متغير وعدم إعطائه قيمة). القيم false، null، undefined، NaN، 0 ،”” كلها قيم خاطئة (تستخدم كقيمة منطقية خطأ) والباقي صحيح. المتغيرات، المصفوفات، والكائنات يتم تعريف المتغيرات باستخدام كلمة var. جافا سكريبت ديناميكية النوع، حيث لا يجب عليك تحديد نوع المتغير عند تعريفه، ولإعطاء قيمة للمتغير نستخدم = كما في المثال التالي: var someVar = 5; عند عدم استخدام كلمة var لن يظهر لك خطأ، ولكن في هذه الحالة فإن المتغير يكون مستواه على نطاق الوصول العام Global scope ولن يكون على المستوى الذي تم تعريفه فقط. someOtherVar = 10; المتغيرات التي لا تأخذ قيمة عند تعريفها تكون بقيمة undefined تلقائيا: var someThirdVar; // = undefined لتعريف أكثر من متغير في نفس السطر نفصل بين المتغيرات بفاصلة عادية: var someFourthVar = 2، someFifthVar = 4; نستطيع اختصار كتابة العمليات الحسابية بالشكل التالي: someVar += 5; // هذا يعادل someVar = someVar + 5; someVar is 10 now someVar *= 10; // someVar = 100 someVar++; // someVar = 101 someVar--; // back = 100 المصفوفات عبارة عن قائمة من القيم المرتبة من أي نوع: var myArray = ["Hello"، 45، true]; نستطيع الوصول لمحتويات المصفوفة باستخدام الأقواس المعكوفة والفهرس. فهرس المصفوفات يبدأ من صفر: myArray[1]; // = 45 المصفوفات غير ثابتة وذات حجم متغير: myArray.push("World"); myArray.length; // = 4 للتعديل أو الإضافة في موقع معين في المصفوفة: myArray[3] = "Hello"; لتعريف قاموس (Hash): var myObj = {key1: "Hello"، key2: "World"}; المفاتيح في القاموس عبارة عن نص، أو مُعرف صحيح، والقيم تأخذ أي نوع: var myObj = {myKey: "myValue"، "my other key": 4}; للوصول إلى قيمة باستخدام مفتاح والأقواس المعكوفة: myObj["my other key"]; // = 4 أو باستخدام صيغة النقطة والمُعِرف الذي يمثل المفتاح: myObj.myKey; // = "myValue" الكائنات في جافا سكريبت غير ثابتة وقابلة للتعديل: myObj.myThirdKey = true; إذا حاولت الوصول لقيمة غير موجودة في القاموس، ستكون النتيجة المرجعة undefined: myObj.myFourthKey; // = undefined جمل التحكم والمنطق جملة if: var count = 1; if (count == 3){ // ستُنفَّذ هذه الشفرةإذا كانت قيمة المتغير تساوي 3 } else if (count == 4){ // ستُنفَّذ هذه الشفرةإذا كانت قيمة المتغير تساوي 4 } else { // ستُنفَّذ هذه الشفرة في حالة عدم تحقق أي شرط سابق } جملة while: while (true){ // جملة تكرار غير منتهية } جملة do تشبه جملة while إلا أنها تُكرَّر مرة واحدة على الأقل: var input; do { input = getInput(); } while (!isValid(input)) جملة For تشبه الموجودة في لغة سي وجافا: for (var i = 0; i < 5; i++){ // ستُنفَّذ هذه الشفرة خمس مرات } توقف جملة التكرار باستخدام break مع تحديد اسم جملة التكرار التي نريد وقفها: outer: for (var i = 0; i < 10; i++) { for (var j = 0; j < 10; j++) { if (i == 5 && j ==5) { break outer; } } } تسمح لنا جملة for/in بالمرور على خصائص ومحتويات الكائن. في المثال التالي نقوم بالمرور على محتوى قاموس وحفظ النتيجة في متغير: var description = ""; var person = {fname:"Paul"، lname:"Ken"، age:18}; for (var x in person){ description += person[x] + " "; } // description = 'Paul Ken 18 ' العملية المنطقية and تُمَثَلْ ب && والعملية or تُمَثَلْ ب ||: if (house.size == "big" && house.colour == "blue"){ house.contains = "bear"; } if (colour == "red" || colour == "blue"){ // colour is either red or blue } نستفيد من && و || في تحديد القيم التلقائية كما في المثال التالي: var name = otherName || "default"; جملة switch تفحص المساواة باستخدام ===، استخدم break بعد كل حالة فحص وإلا سيتم تنفيذ حالة case الصحيحة التالية أيضا: grade = 'B'; switch (grade) { case 'A': console.log("Great job"); break; case 'B': console.log("OK job"); break; case 'C': console.log("You can do better"); break; default: console.log("Oy vey"); break; } الدوال، نطاق الوصول وClosures تُعرَّف الدوال في جافا سكريبت باستخدام كلمة function: function myFunction(thing){ return thing.toUpperCase(); } myFunction("foo"); // = "FOO" لابد الانتباه أن تضع القيمة المرجعة في نفس السطر الموجودة به كلمة return، إذا لم يكن كذلك، ستكون النتيجة المرجعة undefined بسبب الإضافة التلقائية للفاصلة المنقوطة عند كل سطر جديد (وقد نوهنا لهذه النقطة في البداية). function myFunction(){ return // الفاصلة المنقوطة مضافة تلقائيا هنا {thisIsAn: 'object literal'} } myFunction(); // = undefined يُتعامل مع الدوال في جافا سكريبت بوصفها كائنات، وهذا يعني أنك تستطيع تمرير الدالة معاملا لدالة أخرى، أو قيمة لمتغير. تُستخدَم الدالة myFunction في معالجة حدث في المثال التالي، حيث سيتم تنفيذها بعد فترة زمنية محددة: function myFunction(){ } // ينتُج عن السطر التالي تنفيذ الدالة أعلاه بعد 5 ثوان setTimeout(myFunction، 5000); ملاحظة: الدالة setTimeout ليست جزءًا من جافا سكريبت، ولكنها مقدمة من قبل المتصفحات و Node.js. وظيفة setInterval أيضا مقدمة من قبل المتصفحات. function myFunction(){ } setInterval(myFunction، 5000); ليس من الشرط تحديد اسم الدالة، ونستطيع كتابة الدالة دون اسم في المكان الذي يتم تمرير قيمتها المُرجعة فيه بالطريقة التالية: setTimeout(function(){ }, 5000); تمتلك جافا سكريبت نطاقاً وظيفياً، حيث لكل دالة نطاقها الخاص، بينما الكتل الأخرى لا تشاركها هذا النطاق. if (true){ var i = 5; } i; // = 5 إن كتبنا الشفرة في المثال السابق داخل دالة فإن قيمة المتغير i تساوي 5 على عكس ما تتوقعه في النطاق الكتلي، بمعنى أن المتغيرات مُشاهدَة ونستطيع الوصول إليها على مستوى الدالة بغض النظر عن مكان تعريفها داخل هذه الدالة. وهذا يشير إلى نمط متعارف عليه يمنع المتغيرات المؤقتة من الظهور في نطاق الوصول العام. وللتوضيح على ما سبق، في المثال التالي، يبقى المتغير temporary داخل نطاق الدالة المُعرف فيها، أما المتغيرات في النطاق العام مثل permanent فنستطيع الوصول إليه باستخدام الكائن العام والمسمى في كل المتصفحات ب window وتكون صيغة الوصول للمتغير هكذا window.permanent. الكائن ذو النطاق العام يختلف اسمه في البيئات التي لا علاقة لها بالمتصفحات مثل Node.js. (function(){ var temporary = 5; window.permanent = 10; })(); temporary; // raises ReferenceError permanent; // = 10 من أقوى خصائص لغة جافا سكريبت وجود ما يسمى بclosures ، حيث إذا كانت دالة مُعرفة داخل دالة أخرى، فإن الدالة الداخلية تمتلك الوصول لكافة المتغيرات الخاصة بالدالة الخارجية حتى بعد خروجها وانتهائها. في المثال التالي، فإن استدعاء الدالة setTimeout سيتم تنفيذها مباشرة بعد استدعاء الدالة الخارجية sayHelloInFiveSeconds والتي ستنتهي مباشرة. ومن ثم سوف يبدأ العد حتى 5 ثوان لاستدعاء الوظيفة الداخلية، وعند انتهاء المدة، وعلى الرغم من خروج وانتهاء الدالة الخارجية، إلا أنه سيتم تنفيذ الداخلية بنجاح وسيتم الوصول للمتغير prompt دون مشاكل. function sayHelloInFiveSeconds(name){ var prompt = "Hello، " + name + "!"; function inner(){ alert(prompt); } setTimeout(inner، 5000); } // سيتم طباعة "مرحبا أدم" بعد 5 ثواني sayHelloInFiveSeconds("Adam"); المشيّدات Constructors والنماذج الأولية Prototypes يمكن للكائنات أن تحتوي على دوال، كما في المثال التالي: var myObj = { myFunc: function(){ return "Hello world!"; } }; myObj.myFunc(); // = "Hello world!" عندما يتم استدعاء دوال معرَّفة في كائن، فإن هذه الدوال تستطيع الوصول للكائن التي عُرِّفت فيه باستخدام كلمة this كما في المثال التالي: myObj = { myString: "Hello world!"، myFunc: function(){ return this.myString; } }; myObj.myFunc(); // = "Hello world!" الدالة myFunc لا تعمل إذا لم يتم استدعاؤها في سياق الكائن الذي تتصل به، لاحظ في المثال التالي: var myFunc = myObj.myFunc; myFunc(); // = undefined نستطيع ربط دالة بكائن والوصول لمتغيرات هذا الكائن بواسطة this على الرغم من أن هذه الدالة لم تُعرَّف مع تعريف بالكائن. var myOtherFunc = function(){ return this.myString.toUpperCase(); } myObj.myOtherFunc = myOtherFunc; myObj.myOtherFunc(); // = "HELLO WORLD!" نستطيع أيضا تحديد سياق الدالة لتنفيذها من خلاله وذلك عن طريق استدعاء الوظيفة باستخدام call او apply. var anotherFunc = function(s){ return this.myString + s; } anotherFunc.call(myObj، " And Hello Moon!"); // = "Hello World! And Hello Moon!" استخدمنا في المثال السابق الدالة call. تؤدّي الدالة apply نفس الغرض ولكننا نمرر لها مصفوفة معاملات، وهذا يفيدنا في حالة التعامل مع دالة تقبل مجموعة من المعاملات. anotherFunc.apply(myObj، [" And Hello Sun!"]); // = "Hello World! And Hello Sun!" Math.min(42، 6، 27); // = 6 Math.min([42، 6، 27]); // = NaN (uh-oh!) Math.min.apply(Math، [42، 6، 27]); // = 6 لاحظ أننا عند استخدام apply و call قمنا بتمرير السياق الذي نريده من خلال myObj. إذا أردنا أن نُثبت السياق الذي نريد تنفيذ الدالة من خلاله، فإننا نستخدم bind عوضا عن ذلك. var boundFunc = anotherFunc.bind(myObj); boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!" نستطيع استخدام bind لتطبيق دالة جزئيا، انظر المثال التالي: var product = function(a، b){ return a * b; } var doubler = product.bind(this، 2); doubler(8); // = 16 عند استدعاء دالة بواسطة الكلمة new فإن كائناً جديداً يتم إنشاؤه وسوف يكون متاحا للدالة بواسطة كلمة this. الدوال التي صُممت للاستدعاء بهذه الطريقة تسمى المشيّدات constructors. var MyConstructor = function(){ this.myNumber = 5; } myNewObj = new MyConstructor(); // = {myNumber: 5} myNewObj.myNumber; // = 5 على خلاف لغات البرمجة الكائنية الأخرى، جافا سكريبت لا تحتوي على مفهوم العيّنة Instance أو “الكائن المتولد من الفئة عند التشغيل”. تُقدم جافا سكريبت المفاهيم الكائنية مثل التوليد والوراثة من خلال مفهوم واحد يسمى النموذج الأولي Prototype. كل كائن في الجافا سكريبت يحتوي على نموذج أولي. عندما تقوم بمحاولة استخدام لخاصية غير موجودة في كائن معين، فإن مفسر جافا سكريبت سوف ينظر في النموذج الأولي للكائن. تجعلك بعض تطبيقات الجافا سكريبت تصل لنموذج الكائن بواسطة الخاصية “proto“. على الرغم من أن هذه الطريقة مفيدة في شرح مفهوم النموذج الأولي، إلا أنها ليست الطريقة المعيارية لذلك، وسوف نشرح الطريقة الصحيحة لهذا الأمر لاحقا. var myObj = { myString: "Hello world!" }; var myPrototype = { meaningOfLife: 42، myFunc: function(){ return this.myString.toLowerCase() } }; myObj.__proto__ = myPrototype; myObj.meaningOfLife; // = 42 myObj.myFunc(); // = "hello world!" في حال لم تكن الخاصية موجودة في النموذج الأولي، فإن المفسر يبحث في نموذج النموذج وهكذا. myPrototype.__proto__ = { myBoolean: true }; myObj.myBoolean; // = true لا يوجد نُسَخْ عند استخدام النموذج، حيث إن كل كائن يقوم بالتأشير للنموذج الخاص به، وهذا يعني أن أي تغيير على النموذج سوف ينعكس في كل مكان آخر. myPrototype.meaningOfLife = 43; myObj.meaningOfLife; // = 43 جملة for/in تسمح بالمرور على خصائص كائن، مرورا بسلسلة النماذج الأولية حتى الوصول إلى نموذج فارغ. for (var x in myObj){ console.log(myObj[x]); } ///prints: // Hello world! // 42 // [Function: myFunc] للمرور على خصائص الكائن دون النموذج، نستخدم وظيفة hasOwnProperty كما في المثال التالي: for (var x in myObj){ if (myObj.hasOwnProperty(x)){ console.log(myObj[x]); } } ///prints: // Hello world! كما ذكرنا سابقا، فإن استخدام “proto” في تعريف نموذج كائن هي طريقة غير معيارية، ولا يوجد طريقة لتغيير نموذج أولي لكائن موجود. على الرغم من ذلك، توجد طريقتان لإنشاء كائن مع نموذج مُعطى. الأولى هي استخدام Object.create: var myObj = Object.create(myPrototype); myObj.meaningOfLife; // = 43 الطريقة الثانية – مضمونة أكثر - باستخدام المشيّدات. تمتلك المشيّدات خاصية تسمى prototype تُحدَّد عند إنشاء كائن جدي باستخدام كلمة new، المثال التالي يشرح هذا الأمر: MyConstructor.prototype = { myNumber: 5، getMyNumber: function(){ return this.myNumber; } }; var myNewObj2 = new MyConstructor(); myNewObj2.getMyNumber(); // = 5 myNewObj2.myNumber = 6 myNewObj2.getMyNumber(); // = 6 توجد لدى أنواع البيانات مثل النصوص والأرقام مشيّدات تقوم بإنشاء كائنات تعادل الكائنات المنشأة بطريقة عادية. عدا أنها ليست متماثلة تماما! var myNumber = 12; var myNumberObj = new Number(12); myNumber == myNumberObj; // = true typeof myNumber; // = 'number' typeof myNumberObj; // = 'object' myNumber === myNumberObj; // = false if (0){ //لن تُنفَّذ هذه الشفرة لأن قيمة الصفر خاطئة } if (new Number(0)){ //سوف تُنفَّذ هذه الشفرة لأن الرقم في الشرط عبارة عن كائن وليس نوع رقم، والكائنات دائما ذات قيمة منطقية صحيحة } الكائنات المغلفة أو العادية تتشارك في النموذج الأولي الخاص بنوعها، فمثلا، نستطيع إضافة خاصية على النموذج الخاص بنوع string بهدف الحصول على الحرف الأول من النص، كما في المثال التالي: String.prototype.firstCharacter = function(){ return this.charAt(0); } "abc".firstCharacter(); // = "a" تُستخدَم الخاصية السابقة غالباً في ما يُعرَف بالملْء المتعدّد Polyfilling والتي تُطَبِقْ مميزات أحدث من جافا سكريبت في مجموعة قديمة من نُسخ جافا سكريبت بهدف استخدام هذه المميزات الحديثة في بيئات قديمة مثل المتصفحات المنتهية تاريخا. ملاحظة: تنفيذ Object.create قد يكون غير متاح في بعض التطبيقات، ولكننا نستطيع استخدام الملْء المتعدّد لتعويض هذا الغياب كالتالي: if (Object.create === undefined){ //في حالة كانت موجودة لا تعدل عليها Object.create = function(proto){ // أنشئ مشيّدًا مؤقتا باستخدام النموذج الأولي المناسب var Constructor = function(){}; Constructor.prototype = proto; return new Constructor(); } } ترجمة – بتصرّف – للمقال Learn X in Y minutes Where X=javascript.
  3. في بدايات التسعينات، قام Guido van Rossum بإنشاء لغة البايثون. تُعتبر البايثون من أشهر لغات البرمجة حاليا، ولها حضور واسع في العديد من المجالات التطبيقية والعلمية، وتتميز بسهولة شفرتها البرمجية وسرعة تعلمها مع متانة وقوة تضاهي اللغات الأخرى. سوف نتناول في هذا المقال المواضيع التالية: التعليقات. أنواع البيانات. المتغيرات والتراكيب. جمل التحكم. الدوال Functions. الوحدات. الفئات. ملاحظة: إصدار البايثون 3 هو المعتمد في شرح هذا المقال، وناتج العمليات والأوامر في هذا المقال سيتم كتابتها بعد الرمز # =>. التعليقات تبدأ التعليقات ذات السطر الواحد برمز #، أما التعليقات التي تحتوي أكثر من سطر فتجب إحاطتها بثلاث علامات تنصيص (منفردة أو مزدوجة) في البداية والنهاية. أنظر المثال التالي: # Single line comments start with a number symbol. """ Multiline strings can be written using three "s, and are often used as documentation. """ أنواع البيانات والعمليات الأرقام: 3 # => 3 العمليات الرياضية: 1 + 1 # => 2 8 - 1 # => 7 10 * 2 # => 20 35 / 5 # => 7.0 يوجد نوعان من القسمة في بايثون 3، الأولى تُسمى القسمة بعدد فاصل عائم “floating point division” ونَستخدم رمز القسمة المعروف / ، وناتج العملية هو دائما عدد حقيقي من النوع float: 10.0 / 3 # => 3.3333333333333335 أما النوع الثاني من القسمة فيُسمى القسمة الصحيحة “integer division” ونَستخدم الرمز // لهذا النوع، ويكون ناتج العملية دون الفاصلة والأرقام التي بعدها: 5 // 3 # => 1 5.0 // 3.0 # => 1.0 # يعمل هذا النوع من القسمة على الأعداد الحقيقية أيضا -5 // 3 # => -2 -5.0 // 3.0 # => -2.0 عملية باقي القسمة: 7 % 3 # => 1 عملية الأس: 2**3 # => 8 قاعدة أولوية العمليات حسب الأقواس: (1 + 3) * 2 # => 8 القيم المنطقية (لاحظ الحرف الكبير في البداية): True False عكس القيمة المنطقية باستخدام not: not True # => False not False # => True العمليات المنطقية (العمليات المنطقية حساسة لحالة الأحرف): True and False # => False False or True # => True القيمة المنطقية False تساوي الرقم 0، والقيمة المنطقية True تساوي الرقم 1: 0 and 2 # => 0 -5 or 0 # => -5 0 == False # => True 2 == True # => False 1 == True # => True -5 != False != True #=> True عملية فحص المساواة باستخدام ==: 1 == 1 # => True 2 == 1 # => False فحص عدم المساواة: 1 != 1 # => False 2 != 1 # => True المقارنات: 1 < 10 # => True 1 > 10 # => False 2 <= 2 # => True 2 >= 2 # => True 1 < 2 < 3 # => True 2 < 3 < 2 # => False تفحص عملية is إذا كان متغيران يشيران لنفس الكائن أم لا، ولكن العملية == تفحص إذا كانا بنفس القيمة أم لا: a = [1, 2, 3, 4] b = a b is a # => True b == a # => True b = [1, 2, 3, 4] b is a # => False b == a # => True تُنشَأ النصوص باستخدام علامات التنصيص المزدوجة أو الفردية: "This is a string." 'This is also a string.' تستطيع جمع النصوص ببعضها، ولكن حاول تجنب هذه الطريقة: "Hello " + "world!" # => "Hello world!" تستطيع دمج النصوص ببعضها دون استخدام + : "Hello " "world!" # => "Hello world!" من الممكن التعامل مع النص وكأنه مصفوفة من الحروف: "This is a string"[0] # => 'T' للحصول على طول نص نستخدم الدالة المضمنة len : len("This is a string") # => 16 تستطيع استخدام الدالة format لإجراء عملية التنسيق على النص: "{} can be {}".format("Strings", "interpolated") # => "Strings can be interpolated" تستطيع عند استخدام الدالة format ترقيم المدخلات حسب ترتيبها واستخدامها في تنسيق النص أكثر من مرة: "{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick") # => "Jack be nimble, Jack be quick, Jack jump over the candle stick" أو باستخدام طريقة تسمية المدخلات: "{name} wants to eat {food}".format(name="Bob", food="lasagna") # => "Bob wants to eat lasagna" تستطيع في البايثون 3 استخدام الطريقة القديمة في بايثون 2 لعمل تنسيق للنصوص: "%s can be %s the %s way" % ("Strings", "interpolated", "old") # => "Strings can be interpolated the old way" None عبارة عن كائن: None # => None لا تستخدم فحص المساواة باستخدام رمز == للمقارنة مع None واستخدم عملية الفحص is بدلا منها: "etc" is None # => False None is None # => True None والرقم 0 والمتغيرات الفارغة من الأنواع strings، lists، dict، وtuples جميعها تُرادف القيمة المنطقية False، أما باقي القيم فهي True: # All other values are True bool(0) # => False bool("") # => False bool([]) # => False bool({}) # => False bool(()) # => False المتغيرات والتراكيب: تتوفّردالة خاصة للطباعة (الإخراج على الطرفية) وتسمى print: print("I'm Python. Nice to meet you!") # => I'm Python. Nice to meet you! يُطبَع سطر جديد تلقائيا عند استخدام الدالة print. تستطيع استخدام المعطى end لتغيير هذا الأمر وتحديد النص الذي تريده بدلا من السطر الجديد: print("Hello, World", end="!") # => Hello, World! للحصول على مدخلات من الطرفية نستخدم الدالة input: input_string_var = input("Enter some data: ") # Returns the data as a string ملاحظة/ في النسخ القديمة من البايثون، كانت الدالة input باسم raw_input. لا يوجد في البايثون تعريفات، ولكن يوجد إعطاء قيم مباشرة. الطريقة المتعارف عليها في تسمية المتغيرات هي الأحرف الصغيرة مع التسطير السفلي: some_var = 5 some_var # => 5 محاولة استخدام متغير لم يأخذ قيمة مسبقاً ينتج عنه خطأ، راجع كيفية معالجة الأخطاء تحت عنوان جمل التحكم. some_unknown_var # ينتُج خطأ من الصنف NameError تشبه القوائم المصفوفات في اللغات الأخرى: li = [] other_li = [4, 5, 6] نستخدم append لإضافة عناصر في نهاية القائمة: li.append(1) # li is now [1] li.append(2) # li is now [1, 2] li.append(4) # li is now [1, 2, 4] li.append(3) # li is now [1, 2, 4, 3] نستخدم الدالةpop لحذف العناصر من آخر القائمة. ترجع التعليمة أدناه القيمة 3 وتصبح مكونات القائمة [1, 2, 4]: li.pop() # => 3 and li is now [1, 2, 4] تعود القائمة إلى حالتها السابقة لتنفيذ الدالة pop بعد تنفيذ الدالة append على النحو التالي: li.append(3) # li is now [1, 2, 4, 3] again. تستطيع التعامل مع القائمة مثل المصفوفة من حيث الوصول لعناصرها: li[0] # => 1 li[-1] # => 3 في حال استخدام فهرس خارج حدود القائمة سينتج خطأ من نوع IndexError: li[4] # Raises an IndexError تستطيع استخدام مجال للحصول على جزء أكبر من القائمة بحيث نحدد فهرس البداية وفهرس النهاية. li[1:3] # => [2, 4] ملاحظة: فهرس النهاية غير مشمول في القيمة المرجعة، حيث يعدّ النمط المستخدم هو نمط نطاق مغلق-مفتوح. في حال عدم استخدام فهرس النهاية: li[2:] # => [4, 3] في حال عدم استخدام فهرس البداية: li[:3] # => [1, 2, 4] اختيار عنصر كل خطوتين ابتداء من العنصر الأول في القائمة: li[::2] # =>[1, 4] إرجاع كامل المصفوفة بطريقة عكسية: li[::-1] # => [3, 4, 2, 1] القاعدة العامة للاستعلامات السابقة في القوائم هي كالتالي(البداية start، النهاية end والخطوة step): # li[start:end:step] نسخ عميق (Deep Copy): li2 = li[:] # => li2 = [1, 2, 4, 3] عندما نفحص المساواة باستخدام عملية is كالتالي: (li2 is li) ستكون النتيجة False. لحذف عنصر من القائمة: del li[2] # li is now [1, 2, 3] لحذف أول عنصر في القائمة يساوي القيمة المدخلة في الدالة remove: li.remove(2) # li is now [1, 3] li.remove(2) # ValueError لأن القيمة غير موجودة إضافة عنصر في مكان معين في القائمة: li.insert(1, 2) # li is now [1, 2, 3] again الحصول على فهرس أول عنصر في القائمة يساوي القيمة المعطاة: li.index(2) # => 1 li.index(4) # ValueError لأن القيمة غير موجودة لإضافة قائمة لقائمة وإرجاع النتيجة كقائمة جديدة: li + other_li # => [1, 2, 3, 4, 5, 6] لتمديد قائمة وإضافة قائمة إليها: li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6] لفحص وجود قيمة في القائمة: 1 in li # => True للحصول على حجم القائمة (عدد العناصر التي بها): len(li) # => 6 نوع البيانات Tuple تشبه القائمة ولكنها غير قابلة للتعديل (ثابتة-immutable): tup = (1, 2, 3) tup[0] # => 1 tup[0] = 3 # Raises a TypeError لاحظ أنه في حالة وجود عنصر واحد في tuple لابد من وضع فاصلة عادية بعد العنصر، أما في حالة وجود أكثر من عنصر فتصبح الفاصلة إضافية: type((1)) # => <class 'int'> type((1,)) # => <class 'tuple'> type(()) # => <class 'tuple'> تستطيع تنفيذ أغلب عمليات القوائم على النوع Tuple: len(tup) # => 3 tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6) tup[:2] # => (1, 2) 2 in tup # => True تستطيع تفريغ (unpacking) محتويات Tuples وكذلك القوائم في متغيرات كما في الأمثلة التالية: a, b, c = (1, 2, 3) # a = 1, b = 2, c = 3 a, *b, c = (1, 2, 3, 4) # a = 1, b = [2, 3], c = 4 عند عدم استخدام الأقواس فإن نوع البيانات التلقائي الذي سيتم استخدامه هو Tuple: d, e, f = 4, 5, 6 تبديل قيم المتغيرات بطريقة سهلة: e, d = d, e # d = 5, e = 4 القواميس عبارة عن مؤشرات (مُخططات) من المفاتيح للقيم (كل مفتاح يؤشر على قيمة خاصة به). تعريف قاموس فارغ: empty_dict = {} تعريف قاموس بقيم مسبقة: filled_dict = {"one": 1, "two": 2, "three": 3} لاحظ أن المفاتيح في القواميس لابد أن يكون نوع بياناتها ثابتا (immutable) وذلك لضمان الحصول على مفتاح ثابت (لا تتغير قيمته). أنواع البيانات الثابتة والتي من الممكن استخدامها هي int , float, string, tuple. invalid_dict = {[1,2,3]: "123"} # => Raises a TypeError: unhashable type: 'list' valid_dict = {(1,2,3):[1,2,3]} # Values can be of any type, however. يمكن للقيم – عكس المفاتيح – أن تكون من أي نوع. للبحث عن قيم نستخدم الأقواس المعكوفة: filled_dict["one"] # => 1 للحصول على مفاتيح قاموس على شكل قائمة (الترتيب في القواميس غير ثابت): list(filled_dict.keys()) # => ["three", "two", "one"] للحصول على قيم قاموس على شكل قائمة: list(filled_dict.values()) # => [3, 2, 1] للتأكد من وجود مفتاح قاموس معين: "one" in filled_dict # => True 1 in filled_dict # => False في حالة استخدام مفتاح غير موجود للبحث في قاموس، فإن ذلك ينتج خطأ: filled_dict["four"] # KeyError استخدم الدالة get لتجنب الخطأ السابق: filled_dict.get("one") # => 1 filled_dict.get("four") # => None تدعم الدالة get إعادة قيمة تلقائية في حالة عدم وجود المفتاح: filled_dict.get("one", 4) # => 1 filled_dict.get("four", 4) # => 4 تضيف الدالة setdefault المفتاح المُمرر إلى القاموس في حالة عدم وجوده. تضيف التعليمة التالية مفتاحا باسم five وتعطيه قيمة 5، أما التعليمة الثانية فلا تحدت تغييرا على القاموس. filled_dict.setdefault("five", 5) # filled_dict["five"] is set to 5 filled_dict.setdefault("five", 6) # filled_dict["five"] is still 5 للإضافة إلى القاموس: filled_dict.update({"four":4}) # => {"one": 1, "two": 2, "three": 3, "four": 4} filled_dict["four"] = 4 # طريقة أخرى حذف المفتاح من القاموس: del filled_dict["one"] # Removes the key "one" from filled dict بعض طرق التفريغ في القواميس: {'a': 1, **{'b': 2}} # => {'a': 1, 'b': 2} {'a': 1, **{'a': 2}} # => {'a': 2} المجموعات: empty_set = set() some_set = {1, 1, 2, 2, 3, 4} # some_set is now {1, 2, 3, 4} نوع البيانات الخاص بعناصر المجموعات لابد أن يكون ثابتا: invalid_set = {[1], 1} # => Raises a TypeError: unhashable type: 'list' valid_set = {(1,), 1} للإضافة إلى المجموعة: filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5} إجراء عملية التقاطع بين مجموعتين: other_set = {3, 4, 5, 6} filled_set & other_set # => {3, 4, 5} إجراء عملية الاتحاد بين مجموعتين: filled_set | other_set # => {1, 2, 3, 4, 5, 6} إجراء عملية الطرح بين مجموعتين: {1, 2, 3, 4} - {2, 3, 5} # => {1, 4} لإجراء عملية فرق التماثل بين مجموعتين: {1, 2, 3, 4} ^ {2, 3, 5} # => {1, 4, 5} لفحص إذا كانت المجموعة على الشمال هي مجموعة تحتوي المجموعة على اليمين أم لا: {1, 2} >= {1, 2, 3} # => False عكس المثال السابق: {1, 2} <= {1, 2, 3} # => True فحص وجود قيمة في مجموعة: 2 in filled_set # => True 10 in filled_set # => False جمل التحكم some_var = 5 جملة if: if some_var > 10: print("قيمة المتغيّر أكبر تماما من 10") elif some_var < 10: # هذه الجملة اختيارية print("قيمة المتغيّر أصغر من 10") else: # هذه الجملة اختيارية print("قيمة المتغيّر تساوي 10") جملة for: for animal in ["dog", "cat", "mouse"]: print("{} is a mammal".format(animal)) لاحظ استخدام الدالة format في جملة for السابقة. يمكن أيضا تطبيق الجملة على مجال عددي range: for i in range(4): print(i) for i in range(4, 8): print(i) for i in range(4, 8, 2): print(i) جملة while: x = 0 while x < 4: print(x) x += 1 # اختصارا ل x = x + 1 معالجة الأخطاء باستخدام try/except (استخدم raise لتوليد الخطأ): try: raise IndexError("This is an index error") except IndexError as e: pass except (TypeError, NameError): pass else: print("All good!") finally: print("We can clean up resources here") ملاحظات حول معالجة الأخطاء: Pass تعني عدم وجود عملية للتنفيذ. تستطيع سرد أكثر من نوع خطأ في جملة except. تستطيع استخدام جملة else مع try/except اختياريا (تنفذ في حالة كانت الشفرة البرمجية في try لم تُصدر أي خطأ). نستخدم جملة finally لتنفيذ شفرة برمجية بعد try/except بغض النظر عن وجود أخطاء أم لا، وعادةً يُعاد تحرير المصادر المستخدمة. بدلا من استخدام جملة finally لإعادة تحرير المصادر المستخدمة، تستطيع استخدام جملة with: with open("myfile.txt") as f: for line in f: print(line) تُقدم البايثون كائنًا متُعددًا (Iterable) وهو كائن مجرد (عام) يُتعامل معه مثل sequence. فمثلا الكائن المُرجع من الدالة range هو كائن مُتعدد: filled_dict = {"one": 1, "two": 2, "three": 3} our_iterable = filled_dict.keys() print(our_iterable) # => dict_keys(['one', 'two', 'three']). تستطيع المرور على عناصر الكائن المتعدد والتعامل معها: for i in our_iterable: print(i) # Prints one, two, three على الرغم من خاصية الكائن المتعدد، إلا أنه لا تستطيع استخدام الفهرس معه: our_iterable[1] # Raises a TypeError تستطيع الحصول من خلال الكائن المُتعدد على كائن iterator منه بحيث تستطيع المرور على عناصره: our_iterator = iter(our_iterable) يحتفظ الكائن iterator بحالته كلما تم استخدامه، فمثلا، باستخدام وظيفة next تستطيع الحصول على العنصر التالي في هذا الكائن: next(our_iterator) # => "one" next(our_iterator) # => "two" next(our_iterator) # => "three" بعد الحصول على كافة عناصر iterator فإن استخدام الدالة next سيعيد خطأ: next(our_iterator) # Raises StopIteration تستطيع الحصول على كافة عناصر iterator دفعة واحدة على شكل قائمة وذلك باستخدام الدالة list : list(filled_dict.keys()) # => Returns ["one", "two", "three"] الدوال نستخدم الكلمة def في تعريف الدالة، ونستخدم كلمة return في إرجاع النتيجة: def add(x, y): print("x is {} and y is {}".format(x, y)) return x + y تطبع الدالة السابقة قيمتيْ المعامليْن المُمرّرين لها وتعيد ناتج جمعهما: add(5, 6) # => prints out "x is 5 and y is 6" and returns 11 يمكن أيضا استدعاء الدالة بذكر أسماء المعاملات (شرط الترتيب غير مطلوب هنا للمعاملات): add(y=6, x=5) تستطيع تعريف دالة باستقبال عددًا غير محدد من المعاملات: def varargs(*args): return args varargs(1, 2, 3) # => (1, 2, 3) من الممكن استخدام المعاملات المُسماة لاستقبال عدد غير محدد من المعاملات أيضا: def keyword_args(**kwargs): return kwargs keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"} كما نستطيع دمج الطريقتين في نفس الدالة: def all_the_args(*args, **kwargs): print(args) print(kwargs) all_the_args(1, 2, a=3, b=4) # => (1, 2) {"a": 3, "b": 4} توجد طريقة أخرى لاستدعاء الدوال باستخدام args/kwargs وذلك عندما تكون المعطيات من النوع tuple أو قاموس: args = (1, 2, 3, 4) kwargs = {"a": 3, "b": 4} all_the_args(*args) # equivalent to foo(1, 2, 3, 4) all_the_args(**kwargs) # equivalent to foo(a=3, b=4) all_the_args(*args, **kwargs) # equivalent to foo(1, 2, 3, 4, a=3, b=4) يمكن أيضا إرجاع نتيجة من قيم متعددة على شكل tuple: def swap(x, y): return y, x x = 1 y = 2 x, y = swap(x, y) # => x = 2, y = 1 يختلف المتغيّر في نطاق scope الدالة عن المتغيّرات العامة Global: x = 5 def set_x(num): x = num # => 43 print(x) # => 43 تُستخدَم الكلمة المفتاحية global لتعريف متغيّر عام من داخل الدالة: def set_global_x(num): global x print(x) # => 5 x = num # هذا المتغير يمثل المتغير على النطاق العام وقيمته الان 6 print(x) # => 6 set_x(43) set_global_x(6) تعدّ الدوال في بايثون كائنات من الفئة الأولى: def create_adder(x): def adder(y): return x + y return adder add_10 = create_adder(10) add_10(3) # => 13 كما يمكنك تعريف دوال غير مسمّاة Anonymous functions: (lambda x: x > 2)(3) # => True (lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5 ويمكنك تمرير الدالة معاملا لدالة أخرى: list(map(add_10, [1, 2, 3])) # => [11, 12, 13] list(map(max, [1, 2, 3], [4, 2, 1])) # => [4, 2, 3] list(filter(lambda x: x > 5, [3, 4, 5, 6, 7])) # => [6, 7] تستطيع استخدام مبدأ “تفهيم القائمة” للحصول على نفس نتيجة الدوال map و filter: [add_10(i) for i in [1, 2, 3]] # => [11, 12, 13] [x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7] تستطيع استخدام مبدأ “تفيهم القاموس” و “تفهيم المجموعة” كذلك: {x for x in 'abcddeef' if x not in 'abc'} # => {'d', 'e', 'f'} {x: x**2 for x in range(5)} # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16} الوحدات Modules الوحدات في بايثون عبارة عن ملفات بايثون عادية. تستطيع أن تكتب الوحدة الخاصة بك وتستوردها في الشفرة البرمجة الخاصة بمشروعك. اسم الوحدة سيكون نفس اسم الملف الذي أنشأته لهذا الغرض. تُستورَد الوحدات بالطريقة التالية: import math print(math.sqrt(16)) # => 4.0 تستطيع الحصول على دوال محددة من الوحدات: from math import ceil, floor print(ceil(3.7)) # => 4.0 print(floor(3.7)) # => 3.0 تستطيع استيراد جميع الدوالّ من الوحدة دفعة واحدة ولكن هذا الأمر غير منصوح به: from math import * تستطيع اختصار أسماء الوحدات عند استيرادها: import math as m math.sqrt(16) == m.sqrt(16) # => True تُستخدَم الدالة المضمنة dir لمعرفة مكان ملف الوحدة. import math dir(math) إذا كان لديك ملف بايثون باسم math في نفس المجلد الذي يوجد به ملف العمل الخاص بك، فإن الملف math هو الذي سيُحمَّل ويُستورد بدلا من الوحدة التلقائية المضمنة في البايثون باسم math ذلك لأن الأولوية في حال تشابه الأسماء هي للملفات في مجلد العمل المحلي أو الحالي. الأصناف Classes نستخدم كلمة class لتعريف صنف: class Human: لتعريف خاصية للصنف (هذه الخاصية تكون مُشاركة بين كل العناصر المتولدة من هذا الصنف): species = "H. sapiens" init هو المشيّدات Constructor الأساسي ويُستدعى عند توليد عنصر من الصنف. التسطير السفلي المكرر مرتين قبل كلمة init وبعدها يدل على أن هذا الكائن أو الخاصية يستخدمه بايثون ولا يجب علينا استخدامها مباشرة. def __init__(self, name): # إعطاء قيمة المعطى للخاصية الموجودة في الصنف self.name = name # قيمة مبدئية self._age = 0 الدالة say هي تابع عيّنة Instance method، أي أن لكل كائن نسخة خاصة به منها. تأخذ هذه التوابع أن self في أول معامل يُمرّر لها: def say(self, msg): print ("{name}: {message}".format(name=self.name, message=msg)) def sing(self): return 'yo... yo... microphone check... one two... one two...' يمكن أيضا تعريف تابع متشارك بين كل كائنات الصنف: @classmethod def get_species(cls): return cls.species نستطيع كذلك تعريف تابع ساكن يُستدعى دون الحاجة لإنشاء كائن من الصنف: @staticmethod def grunt(): return "*grunt*" يحوّل التعليمة property@ دالة إلى خاصيّة للقراءة فقط لها نفس اسم الدالة، لتؤدّي بالتالي وظيفة المسترجعات Getters. @property def age(self): return self._age يمكننا جعل الخاصية قابلة للتعيين لتصبح الدالة تعمل معدّلا Setter: @age.setter def age(self, age): self._age = age كما يمكننا السماح بحذفها: @age.deleter def age(self): del self._age يقوم مُفسر البايثون بتنفيذ كافة اشيفرة البرمجية في ملف الوحدة الذي يقرأه، ومن خلال الخاصية name نتأكد من أن كتلة الشفرة البرمجية التي في جملة الشرط ستُنفَّذ في حال كانت الوحدة هي البرنامج الرئيسي المُنفذ: if __name__ == '__main__': i = Human(name="Ian") i.say("hi") # "Ian: hi" j = Human("Joel") j.say("hello") # "Joel: hello" # استدعاء دالة الفئة i.say(i.get_species()) # "Ian: H. sapiens" # تغيير الخاصية المشتركة Human.species = "H. neanderthalensis" i.say(i.get_species()) # => "Ian: H. neanderthalensis" j.say(j.get_species()) # => "Joel: H. neanderthalensis" # استدعاء الدالة الساكنة print(Human.grunt()) # => "*grunt*" لا تستطيع استدعاء الدالة الساكنة من خلال العنصر المتولد i لأن استدعاءها بهذه الطريقة سيضيف self كمعامل لها مما سينتج عنه خطأ: print(i.grunt()) # => TypeError: grunt() takes 0 positional arguments but 1 was given i.age = 42 i.say(i.age) # => "Ian: 42" j.say(j.age) # => "Joel: 0" del i.age # i.age # => this would raise an AttributeError ترجمة -وبتصرف- للمقال Learn X in Y minutes Where X=Python3
  4. أُنشئت لغة البرمجة Go لإنجاز العمل بسهولة، وهي ليست ضمن الاتجاهات الحديثة في علم الحاسوب، ولكنها أحدث وسيلة برمجية لحل المشاكل في الواقع بسرعة. تمتلك لغة Go مفاهيم مُشابهة للغات البرمجة الإجبارية Imperative Languages بالإضافة لثبات أنواع البيانات Static typing، وتعدّ كذلك سريعة في البرمجة Compilation وسريعة في التشغيل والتنفيذ، ومتوافقة مع المعالجات ذات الأنوية المتعددة بهدف الاستفادة منها بسهولة، كما أنها تمتلك الكثير من المزايا التي تساعد في البرمجة للأنظمة الكبيرة والمعقَّدة. تتمتع لغة Go بمكتبة معيارية عظيمة ومجتمع برمجي متحمس ونشط. في هذا المقال، سوف نشرح أساسيات لغة Go بطريقة سهلة وبسيطة، ونُعرج على بعض المفاهيم المهمة. الشفرة البرمجية الموجودة في هذا المقال مترابطة، ولكننا قسّمناها إلى أجزاء ووضعنا عناوين لهذه الأجزاء، كما توجد الكثير من التعليقات المباشرة على الشفرة البرمجية. المواضيع الأساسية التي يغطيها هذا المقال كالتالي: كتابة التعليقات. المكتبات واستيرادها. الدوال. أنواع البيانات. القيم الراجعة المسماة. المتغيرات والذاكرة. جمل التحكم. توليد الدوال. التنفيذ المؤجل. الواجهات. المُدخلات المتعددة. معالجة الأخطاء. التنفيذ المتزامن. الويب كتابة التعليقات لكتابة تعليق من سطر واحد // single line comment لكتابة تعليق بأكثر من سطر /* Multi- line comment */ المكتبات واستيرادها يبدأ كل ملف مصدري بالكلمة المفتاحية packag. تُستخدَم الكلمة المفتاحية main لتعريف الملف كملف تشغيلي وليس مكتبة. package main لاستيراد حزمة مكتبية في الملف نستخدم التعليمة Import بالطريقة التالية: import ( "fmt" // حزمة في المكتبة المعيارية للغة "io/ioutil" // تطبق دوال إدخال وإخراج m "math" //نستخدم الحرف m لاختصار اسم مكتبة الدوال الرياضية "net/http" // خادوم ويب "os" // دوال على مستوى نظام التشغيل مثل التعامل مع الملفات "strconv" // تحويلات نصية ) الدوال Functions تُعرَّف الدوال باستخدام كلمة func متبوعة باسم الدالة. تعدّ الدالة main خاصة، وهي المدخل للملف التنفيذي للبرنامج (لغة Go تستخدم الأقواس المزخرفة {} لتحديد الأجزاء/الكتل البرمجية). func main() { // لإخراج نص على وحدة الإخراج (العرض) الرئيسية stdout نستخدم الدالة Println الموجودة في مكتبة fmt fmt.Println("Hello world!") // استدعاء دالة من نفس الحزمة الحالية beyondHello() } تحتاج الدوال لأقواس تستقبل المعاملات Parameters، وحتى في عدم وجود معاملات فإن الأقواس مطلوبة. func beyondHello() { // تعريف متغير (لا بد من تعريف المتغير قبل استخدامه) var x int // إعطاء قيمة للمتغير x = 3 // التعريف القصير باستخدام := ويشمل تعريف المتغير, وتحديد نوعه وإعطاءه قيمة y := 4 // دالة ترجع قيمتين منفصلتين sum, prod := learnMultiple(x, y) // طباعة وإخراج بشكل بسيط ومباشر fmt.Println("sum:", sum, "prod:", prod) learnTypes() } يمكن أن توجد في تعريف الدوال معاملات وقيم مرجعة متعددة، فمثلا تأخذ الدالة learnMultiple أدناه معاملين x و y وترجع قيمتين sum و prod من نوع عدد صحيح Int. func learnMultiple(x, y int) (sum, prod int) { // نفصل بين القيم المُرجعة بفاصلة عادية return x + y, x * y } أنواع البيانات Data Types func learnTypes() { //التعريفات القصيرة عادة تؤدي الغرض المطلوب // تعريف متغير نصي باستخدام علامة التنصيص المزدوجة str := "Learn Go!" // تعريف متغير نصي باستخدام علامة التنصيص المنفردة s2 := `A "raw" string literal can include line breaks.` // تعريف متغير من نوع rune وهو عبارة عن مسمى آخر لنوع int32 ويحتوي المتغير من هذا النوع على يونيكود g := 'Σ' // تعريف عدد عشري Float f := 3.14195 // تعريف عدد مركب (عقدي)Complex c := 3 + 4i // تعريف المتغيرات باستخدام var var u uint = 7 //عدد طبيعي (صحيح موجب) var pi float32 = 22. / 7 //عدد عشري من 32 بت // طريقة التحويل باستخدام التعريف القصير (byte تعتبر مسمى اخر لنوع uint8) n := byte('\n') // المصفوفات لها حجم محدد وثابت في وقت الترجمة // تعريف مصفوفة من نوع int بحجم 4 عناصر وبقيمة أولية تساوي صفر var a4 [4]int // تعريف مصفوفة بحجم 3 عناصر بالقيم 3 و 1 و 5 a3 := [...]int{3, 1, 5} يقدّم Go نوع بيانات يُسمّى الشرائح Slices. الشرائح (Slices) لها حجم ديناميكي. المصفوفات والشرائح لها مميزات ولكن حالات الاستخدام للشرائح شائعة أكثر. تعرّف التعليمة التالية شريحة من النوع int // لاحظ الفرق بين تعريف المصفوفة والشريحة، حيث عند تعريف الشريحة لا يوجد رقم يحدد حجمها s3 := []int{4, 5, 9} //تعريف شريحة من نوع int بأربعة عناصر بقيم صفرية s4 := make([]int, 4) // تعريف فقط، ولا يوجد تحديد var d2 [][]float64 // طريقة تحويل النوع من نص لشريحة bs := []byte("a slice") بحكم طبيعة الشرائح الديناميكية، فإنه من الممكن إضافة عناصر جديدة للشريحة وذلك يتم باستخدام الدالة المضمنة append. نمرر أولا الشريحة التي نريد الإضافة عليها ومن ثم العناصر التي نريد إضافتها، أنظر للمثال بالأسفل. s := []int{1, 2, 3} s = append(s, 4, 5, 6) // ستُطبَع شريحة بالمحتويات التالية [1 2 3 4 5 6] fmt.Println(s) لإضافة شريحة إلى شريحة أخرى نمرر الشريحتين للدالة بدلا من تمرير عناصر منفردة، ونتبع الشريحة الثانية بثلاث نقاط كما في المثال التالي. s = append(s, []int{7, 8, 9}...) // سيتم طباعة شريحة بالمحتويات التالية [1 2 3 4 5 6 7 8 9] fmt.Println(s) تعرّف التعليمة التالية متغيرين p وq ليكونا مؤشّريْن Pointers على متغيّرين من نوع int يحويان قيمتين مُرجعتيْن من الدالة learnMemory: p, q := learnMemory() عندما تسبق النجمة مؤشرا فإن ذلك يعني قيمة المتغير الذي يحيل إليه المؤشر، أي في المثال التالي قيمتا المتغيريْن اللذيْن ترجعهما الدالة learnMemory: fmt.Println(*p, *q) الخرائط Maps في Go هي مصفوفات ترابطية يمكن التعديل عليها ديناميكيا وهي تشابه نوع القاموس او الهاش في اللغات الأخرى. /* هنا نعرف خريطة يكون مفتاحها من نوع نصي، وقيم العناصر رقمية. */ m := map[string]int{"three": 3, "four": 4} m["one"] = 1 تعدّ لغة Go المتغيرات غير المستخدمة خطأ. التسطير السفلي بالطريقة التالية يجعلك تستخدم المتغير ولكن تتجاهل قيمته في نفس الوقت: _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs تُستخدَم هذه الطريقة عادة لتجاهل قيمة راجعة من دالة، فمثلا تستطيع تجاهل رقم الخطأ الراجع من دالة إنشاء الملف os.Create والذي يفيد بأن الملف موجود مسبقا، وتفترض دائما أن الملف شيُنشَأ: file, _ := os.Create("output.txt") fmt.Fprint(file, "بالمناسبة، هذه هي دالة الكتابة في ملف") file.Close() fmt.Println(s, c, a4, s3, d2, m) learnFlowControl() } القيم الراجعة المسماة Named return values خلافا للغات الأخرى، من الممكن أن تكون للدوال قيم راجعة مسماة. حيث يتم إعطاء اسم للقيمة الراجعة من الدالة وذلك في سطر تعريف الدالة، وهذه الميزة تتيح الرجوع بسهولة من أي نقطة في الدالة بالإضافة لاستخدام كلمة return فقط دون ذكر شيء بعدها: func learnNamedReturns(x, y int) (z int) { z = x * y //هنا كتبنا كلمة return فقط وضمنيا نعني إعادة قيمة المتغير z return } ملاحظة: تعتمد لغة Go كثيرا على جمع الموارد غير المستخدمة Garbage collection. توجد في Go مؤشّرات لكن بدون إجراء عمليات حسابية عليها (تستطيع الخطأ في استخدام مؤشر فارغ ولكن لا تستطيع الزيادة على المؤشر). المتغيرات والذاكرة المتغيّران p وq أدناه هما مؤشّران على النوع int ويمثّلان قيمتين راجعتين في الدالة. يكون المؤشّران عند تعريفهما فارغين؛ إلا أن استخدام الدالة المُضمّنة new يجعل قيمة المتغيّر العددي الذي يحيل إليه المؤشّرp مساوية للصفر، وبالتالي يأخذ حيزا من الذاكرة؛ أي أن المؤشر p لم يعد فارغا. func learnMemory() (p, q *int) { p = new(int) // تعريف شريحة من 20 عنصر كوحدة واحدة في الذاكرة s := make([]int, 20) // إعطاء قيمة لأحد العناصر s[3] = 7 // تعريف متغير جديد محلي على مستوى الدالة r := -2 // إرجاع قيمتين من الدالة هما عبارة عن عناوين الذاكرة للمتغيرات s و r على الترتيب. return &s[3], &r } func expensiveComputation() float64 { return m.Exp(10) } جمل التحكم تتطلّب الجمل الشرطية وجود أقواس مزخرفة ولا تتطلب وجود أقواس هلالية. func learnFlowControl() { if true { fmt.Println("told ya") } if false { // Pout. } else { // Gloat. } نستخدم جملة switch في حال حاجتنا لكتابة أكثر من جملة شرطية متتابعة. x := 42.0 switch x { case 0: case 1: case 42: case 43: default: } كما الجملة الشرطية، فإن جملة for لا تأخذ أقواس هلالية.المتغيرات المعرفة في جملة for تكون مرئية على مستوى الجملة. for x := 0; x < 3; x++ { fmt.Println("iteration", x) } جملة for هي جملة التكرار الوحيدة في لغة Go ولها شكل آخر بالطريقة التالية: for { // تكرار لا نهائي // نستطيع استخدام break لوقف التكرار break // نستطيع استخدام continue للذهاب للتكرار القادم continue } تستطيع استخدام range للمرور على عناصر مصفوفة، شريحة، نص، خريطة أو قناة Channel تـعيد range قيمة واحدة عند استخدام قناة، وقيمتين عند استخدام شريحة أو مصفوفة أو نص أو خريطة. // مثال: for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} { // نطبع قيمة كل عنصر في الخريطة fmt.Printf("key=%s, value=%d\n", key, value) } استخدم علامة التسطير السفلي مقابل القيمة الراجعة إذا كنت تريد الحصول على القيمة فقط، كالتالي: for _, name := range []string{"Bob", "Bill", "Joe"} { fmt.Printf("Hello, %s\n", name) } نستطيع استخدام التعريف القصير مع الجملة الشرطية بحيث يُعرف متغير ومن ثم يُفحَص في جملة الشرط. نعرّف في ما يلي متغيرًا y ونقوم بإعطائه قيمة ومن ثم نقوم بوضع شرط الجملة بحيث يتم فصلهما ب فاصلة منقوطة. if y := expensiveComputation(); y > x { x = y } نستطيع تعريف دوال وهمية anonymous مباشرة في الشفرة البرمجية” xBig := func() bool { // عرّفنا المتغيّر x التالي قبل جملة switch السابقة return x > 10000 } x = 99999 // ترجع الدالة xBig الآن القيمة true fmt.Println("xBig:", xBig()) x = 1.3e3 // بعد تعديل قيمة x إلى 1.3e3 التي تساوي 1300 (أي أكبر من 1000) فإن الدالة xBig ترجع false fmt.Println("xBig:", xBig()) بالإضافة لما سبق، فإنه من الممكن تعريف الدالة الوهمية واستدعائها في نفس السطروتمريرها في معطى لدالة أخرى بشرط أن يتم استدعاؤها مباشرة وأن يكون نوع النتيجة متوافقا مع ما هو متوقع في معطى الدالة. fmt.Println("Add + double two numbers: ", func(a, b int) int { return (a + b) * 2 }(10, 2)) goto love love: learnFunctionFactory() // دالة ترجع دالة learnDefer() // التأجيل learnInterfaces() // التعامل مع الواجهات } توليد الدوال نستطيع التعامل مع الدوال ككائنات منفصلة، فمثلا من الممكن أن نقوم بإنشاء دالة وتكون القيمة الراجعة منها دالة أخرى. func learnFunctionFactory() { تعدّ الطريقتان التاليتان في طباعة الجملة متماثلتين، إلا أن الطريقة الثانية أوضح ومقروءة أكثر وهي الشائعة. fmt.Println(sentenceFactory("summer")("A beautiful", "day!")) d := sentenceFactory("summer") fmt.Println(d("A beautiful", "day!")) fmt.Println(d("A lazy", "afternoon!")) } المزخرفات Decorators موجودة في بعض لغات البرمجة، وموجودة بنفس المفهوم في لغة Go بحيث نستطيع تمرير معطيات إلى الدوال. func sentenceFactory(mystring string) func(before, after string) string { return func(before, after string) string { return fmt.Sprintf("%s %s %s", before, mystring, after) } } التنفيذ المؤجل نستطيع استخدام خاصية التأجيل في الدوال بحيث ننفّذ إجراءً قبل إعادة القيمة المرجعة، وفي حال كتابة أكثر من إجراء، فإن تنفيذ هذه الإجراءات يكون بطريقة عكسية، كما في وظيفة learnDefer: func learnDefer() (ok bool) { // تُنفَّذ التعليمات المؤجلة قبل أن ترجع الوظيفة النتيجة. defer fmt.Println("deferred statements execute in reverse (LIFO) order.") defer fmt.Println("\nThis line is being printed first because") // يُستخدَم تأجيل التنفيذ عادة لإغلاق ملف بعد فتحه. return true } الواجهات Interfaces نعرّف في ما يلي دالة باسم Stringer تحتوي على دالة واحدة باسم String ؛ ثم نعرّف هيكلا Struct من خانتين نوع int باسم x وy. type Stringer interface { String() string } type pair struct { x, y int } نعرّف في ما يلي دالة String على النوع pair، ليصبح pair تطبيقا Implementation للواجهة Stringer. يُسمى المتغيّرp أدناه بالمُستقبل. لاحظ كيفية الوصول لحقول الهيكل pair وذلك باستخدام اسم الهيكل متبوعا بنقطة ثم اسم الحقل. func (p pair) String() string { return fmt.Sprintf("(%d, %d)", p.x, p.y) } تُستخدَم الأقواس الهلالية لإنشاء عنصر من الهياكل Structs. نستخدم التعريف القصير (باستخدام := ) في المثال أدناه لإنشاء متغير باسم p وتحديد نوعه بالهيكل pair . func learnInterfaces() { p := pair{3, 4} // نستدعي الدالة String الخاصة بالنوع pair fmt.Println(p.String()) // نُعرف متغيرًا باسم i من نوع الواجهة المعرفة سابقا Stringer var i Stringer // هذه المساواة صحيحة، لأن pair تُطبق Stringer i = p /* نستدعي الدالة String الخاصة بالمتغير i من نوع Stringer ونحصُل على نفس النتيجة السابقة */ fmt.Println(i.String()) /* عند تمرير المتغيرات السابقة مباشرةإلى دوال الحزمة fmt الخاصة بالطباعة والإخراج، فإن هذه الدوال تستدعي الدالة String لطباعة التمثيل الخاص بالمتغير. */ // يعطي السطران التاليان نفس النتيجة السابقة للطباعة fmt.Println(p) fmt.Println(i) learnVariadicParams("great", "learning", "here!") } المدخلات المتعددة من الممكن أن نمرر معطيات متغيرة العدد للدوال. func learnVariadicParams(myStrings ...interface{}) { /* تمرّ جملة التكرار التالية على عناصر المعطيات المدخلة للدالة. التسطير السفلي هنا نعني به تجاهل المؤشر الخاص بالعنصر الذي نمر عليه. */ for _, param := range myStrings { fmt.Println("param:", param) } /* هنا نمرّر مدخلات الدالة ذات العدد المتغير كمعامل لدالة أخرى (للدالة Sprintln) */ fmt.Println("params:", fmt.Sprintln(myStrings...)) learnErrorHandling() } معالجة الأخطاء Errors Handling تُستخدَم الكلمة المفتاحية “ok,” لمعرفة صحة عبارة من عدمها. في حال حدوث خطأ فيمكننا استخدام err لمعرفة تفاصيل أكثر عن الخطأ. func learnErrorHandling() { m := map[int]string{3: "three", 4: "four"} if x, ok := m[1]; !ok { // ok هنا ستكون false لأن رقم 1 غير موجود في الخريطة m fmt.Println("no one there") } else { // x ستكون القيمة الموجودة في map fmt.Print(x) } /* هنا نحاول أن نقوم بعمل تحويل لقيمة نصية إلى عدد مما سينتج عنه خطأ, ونقوم بطباعة تفاصيل الخطأ في حالة أن err ليست nil */ if _, err := strconv.Atoi("non-int"); err != nil { fmt.Println(err) } learnConcurrency() } // المعطى c هنا من نوع قناة، وهو كائن لتأمين الاتصالات المتزامنة func inc(i int, c chan int) { // عندما يظهر عنصر من نوع قناة على الشمال، فإن العملية <- تعني إرسال c <- i + 1 } التنفيذ المتزامن Concurrency نستخدم الدالة السابقة لعمل إضافة عددية على بعض الأرقام بالتزامن. نستخدم make كما فعلنا في بداية المقال لإنشاء متغير دون تحديد قيمة له. func learnConcurrency() { // هنا نقوم بإنشاء متغير من نوع قناة وباسم c c := make(chan int) /* نبدأ بإنشاء ثلاثة دوال متزامنة للغة Go. الأعداد سيتم الزيادة عليهابالتزامن (وبالتوازي في حال كان الجهاز مُهيئاً لذلك). */ // كافة الإرسالات ستتجه لنفس القناة // كلمة go هنا تعني بدء دالة أو وظيفة جديدة go inc(0, c) go inc(10, c) go inc(-805, c) // ثم نقوم بعمل ثلاثة قراءات من نفس القناة وطباعة النتائج. /* لاحظ أنه لا يوجد تحديد ترتيب لوصول القراءات من القناة، ولاحظ أيضا أنه عند ظهور القناة على يمين العملية <- فهذا يعني أننا نقوم بقراءة واستقبال من القناة. */ fmt.Println(<-c, <-c, <-c) // قناة جديدة تحتوي على نص cs := make(chan string) // قناة تحتوي على قنوات نصية ccs := make(chan chan string) // إرسال قيمة 84 إلى القناة c go func() { c <- 84 }() // إرسال كلمة wordy للقناة cs go func() { cs <- "wordy" }() /* جملة Select تشبه جملة switch ولكنها في كل حالة تحتوي على عملية خاصة بقناة جاهزة للتواصل معها. */ select { // القيمة المُستلمة من القناة من الممكن أن تُحفظ في متغير. case i := <-c: fmt.Printf("it's a %T", i) case <-cs: fmt.Println("it's a string") // قناة فارغة ولكنها جاهزة للتواصل case <-ccs: fmt.Println("didn't happen.") } // برمجة الويب learnWebProgramming() } الويب نستطيع بدء خادوم ويب باستخدام دالة واحدة من حزمة http. نمرّر في المعامل الأول للدالة ListenAndServe عنوان TCP للاستماع له، والمعامل الثاني واجهة عبارة عن معالج http. func learnWebProgramming() { go func() { err := http.ListenAndServe(":8080", pair{}) // نطبع الأخطاء في حال وجودها. fmt.Println(err) }() requestServer() } // اجعل pair معالج http وذلك بواسطة تطبيق دالته الوحيدة المسماة ServeHTTP func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { // تتبع الدالة Write للحزمة http.ResponseWriter ونستخدمها لإرجاع رد لطلب http w.Write([]byte("You learned Go in Y minutes!")) } func requestServer() { resp, err := http.Get("http://localhost:8080") fmt.Println(err) defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) fmt.Printf("\nWebserver said: `%s`", string(body)) } ترجمة – بتصرّف – للمقال Learn X in Y minutes Where X=Go.
  5. في هذا المقال، نقدم لكم لمحة سريعة عن أساسيات لغة البرمجة روبي، ويعتبر هذا المقال مُخصص بالدرجة الأولى للمبتدئين في تعلم اللغة ولديهم أرضية مسبقة عن مفاهيم البرمجة بشكل عام. سنتناول في هذا المقال المواضيع التالية: كتابة التعليقات. المصفوفات. جمل التحكم. معالجة الخطأ. بناء الوظائف. جملة yield. الفئات. ملاحظة: ناتج تنفيذ الأمثلة والأوامر الموجودة في هذا المقال تقع بعد علامة #=> من كل نتيجة أو أمر. كتابة التعليقات # هذا تعليق =begin تعليق من أكثر من سطر =end قبل البدء، لا بد من التنويه أن كل شيء عبارة عن كائن في لغة روبي. الأرقام عبارة عن كائنات، والوظيفة class في السطر التالي تعيد نوع الكائن: 3.class #=> Fixnum 3.to_s #=> "3" العمليات الحسابية والثنائية 1 + 1 #=> 2 8 - 1 #=> 7 10 * 2 #=> 20 35 / 5 #=> 7 2**5 #=> 32 5 % 3 #=> 2 3 & 5 #=> 1 3 | 5 #=> 7 3 ^ 5 #=> 6 العمليات الرياضية سهلة الاستدعاء على مستوى الكائن: 1.+(3) #=> 4 10.* 5 #=> 50 بعض القيم تُعتبر كائنات مثل: nil # تشبه القيمة الفارغة في اللغات الأخرى true # صحيح منطقي false # خطأ منطقي nil.class #=> NilClass true.class #=> TrueClass false.class #=> FalseClass المساواة: 1 == 1 #=> true 2 == 1 #=> false اللامساواة: 1 != 1 #=> false 2 != 1 #=> true تُعتبر القيمة الفارغة مرادفة للقيمة المنطقية الخاطئة: !nil #=> true !false #=> true !0 #=> false المقارنات: 1 < 10 #=> true 1 > 10 #=> false 2 <= 2 #=> true 2 >= 2 #=> true عمليات المقارنة المُجمعة: 1 <=> 10 #=> -1 10 <=> 1 #=> 1 1 <=> 1 #=> 0 العمليات المنطقية: true && false #=> false true || false #=> true !true #=> false يوجد نسخة أخرى من العمليات المنطقية ولكن بتطبيق مفهوم الأولوية المنخفضة، مما يعني استخدامها كبناء للتحكم في التدفقات (Flow Control) وربط الجمل ببعضها حتى تقوم أحدها بإرجاع قيمة منطقية صحيحة أو خاطئة. فمثلا، في السطر التالي تُستدعى do_something_else في حال كان استدعاء do_something ناجحاً. do_something() and do_something_else() وهنا يُستدعى log_error في حال فشل استدعاء: do_someting do_something() or log_error() النصوص النصوص عبارة عن كائنات: 'I am a string'.class #=> String "I am a string too".class #=> String placeholder = 'use string interpolation' "I can #{placeholder} when using double quoted strings" #=> "I can use string interpolation when using double quoted strings" يُفضل استخدام علامة التنصيص المنفردة على المزدوجة وذلك قدر الإمكان. علامة التنصيص المزدوجة تُضيف بعض الحسابات الداخلية الزائدة، ومن الممكن جمع النصوص ببعضها بشرط عدم استخدام الأرقام. 'hello ' + 'world' #=> "hello world" 'hello ' + 3 #=> TypeError: can't convert Fixnum into String 'hello ' + 3.to_s #=> "hello 3" دمج النصوص مع العمليات: 'hello ' * 3 #=> "hello hello hello " الإضافة لنص: 'hello' << ' world' #=> "hello world" لطباعة نص وسطر في النهاية نستخدم وظيفة puts: puts "I'm printing!" #=> I'm printing! #=> nil طباعة نص دون سطر في النهاية: print "I'm printing!" #=> I'm printing! => nil المتغيرات تعريف المتغيرات: x = 25 #=> 25 x #=> 25 استخدام عملية المساواة تُرجع القيمة المستخدمة وهذا يعني أنك تستطيع إجراء عمليات مساواة متعددة كما المثال التالي: x = y = 10 #=> 10 x #=> 10 y #=> 10 من المتعارف عليه استخدام طريقة snake_case في تسمية المتغيرات: snake_case = true حاول أن تستخدم أسماء متغيرات ذات دلالة: path_to_project_root = '/good/name/' path = '/bad/name/' الرموز (Symbols) في لغة روبي عبارة عن كائنات، وهي ثابتة. وتُمَثِّل الرموز ثوابت من الممكن إعادة استخدامها ويتم تمثيلها داخليا بأرقام. وغالبا يتم استخدامها بدلا من النصوص لتوصيل قيم ذات معنى ومحددة: :pending.class #=> Symbol status = :pending status == :pending #=> true status == 'pending' #=> false status == :approved #=> false المصفوفات لتعريف مصفوفة نقوم بالتالي: array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] من الممكن أن تحتوي المصفوفة على عناصر ذات أنواع مختلفة: [1, 'hello', false] #=> [1, "hello", false] يتم فهرسة المصفوفات بطريقة أمامية: array[0] #=> 1 array.first #=> 1 array[12] #=> nil ومن الممكن فهرستها بطريقة عكسية: array[-1] #=> 5 array.last #=> 5 ومن الممكن تحديد فهرس البداية والنهاية للحصول على جزء أو شريحة من المصفوفة: array[2, 3] #=> [3, 4, 5] نستخدم وظيفة reverse لإجراء عملية عكس المصفوفة: a=[1,2,3] a.reverse! #=> [3,2,1] من الممكن أيضا أن نستخدم نطاقًا لإجراء عملية الاقتطاع من المصفوفة بالطريقة التالية: array[1..3] #=> [2, 3, 4] لإجراء عملية الإضافة على المصفوفة نقوم بالتالي: array << 6 #=> [1, 2, 3, 4, 5, 6] أو : array.push(6) #=> [1, 2, 3, 4, 5, 6] للتأكد من وجود قيمة في المصفوفة نستخدم الوظيفة include : array.include?(1) #=> true هاش Hash الهاش Hash في لغة روبي هو القاموس الرئيسي باستخدام المفتاح والقيمة، ولتعريف الهاش نستخدم الأقواس المزخرفة: hash = { 'color' => 'green', 'number' => 5 } hash.keys #=> ['color', 'number'] يتم البحث في الهاش باستخدام المفتاح بالطريقة التالية: hash['color'] #=> 'green' hash['number'] #=> 5 في حالة البحث في الهاش باستخدام مفتاح غير موجود فإن النتيجة المرجعة هي nil : hash['nothing here'] #=> nil بعد نسخة روبي 1.9 يوجد طريقة خاصة لاستخدام الرموز كمفاتيح للهاش: new_hash = { defcon: 3, action: true } new_hash.keys #=> [:defcon, :action] لفحص وجود مفتاح أو قيمة في الهاش نستخدم الطريقة التالية: new_hash.key?(:defcon) #=> true new_hash.value?(3) #=> true ملاحظة/ المصفوفات والهاش في الروبي قابلة للعد (Enumerable) ، وكلاهما يحتوي على مجموعة من الوظائف المفيدة. جمل التحكم جملة الشرط: if true 'if statement' elsif false 'else if, optional' else 'else, also optional' end جملة التكرار for: for counter in 1..5 puts "iteration #{counter}" end #=> iteration 1 #=> iteration 2 #=> iteration 3 #=> iteration 4 #=> iteration 5 على الرغم من وجود جملة التكرار وشيوعها، إلا أنه لا يوجد من يستخدمها، وبدلا من ذلك يجب عليك استخدام جملة each وتمرير كتلة من الشفرة البرمجية لها. هذه الكتلة من الشفرة البرمجية تُرادف lambdas أو الوظائف الوهمية. عند استخدام وظيفة each مع نطاق من الأرقام، فإن كتلة الشفرة البرمجية المُمَرَرَة لها تُنفذ مرة واحدة مع كل عنصر من النطاق. يُمرَّر عداد كمعامل لكتلة الشفرة البرمجية،وتُكتَب جملة each بالطريقة التالية: (1..5).each do |counter| puts "iteration #{counter}" end #=> iteration 1 #=> iteration 2 #=> iteration 3 #=> iteration 4 #=> iteration 5 نستطيع إحاطة كتلة الشفرة البرمجية بأقواس مزخرفة: (1..5).each { |counter| puts "iteration #{counter}" } نستطيع استخدام each للمرور على محتويات التراكيب مثل المصفوفات والهاش: array.each do |element| puts "#{element} is part of the array" end hash.each do |key, value| puts "#{key} is #{value}" end إذا كنت تريد الحصول على فهرس العنصر الذي تمر عليه في جملة each تستطيع استخدام جملة each_with_index وتعريف متغير الفهرس من خلالها. انظر المثال التالي: array.each_with_index do |element, index| puts "#{element} is number #{index} in the array" end counter = 1 while counter <= 5 do puts "iteration #{counter}" counter += 1 end #=> iteration 1 #=> iteration 2 #=> iteration 3 #=> iteration 4 #=> iteration 5 توجد مجموعة من الوظائف الأخرى لتنفيذ الحلقات Loops في لغة الروبي، فمثلا توجد map، reduce ، inject والقائمة تطول. Map تأخذ مصفوفة كمعامل، وتقوم بالمرور على عناصرها وإجراء عمليات عليها وترجعها في مصفوفة جديدة، كما المثال التالي: array = [1,2,3,4,5] doubled = array.map do |element| element * 2 end puts doubled #=> [2,4,6,8,10] puts array #=> [1,2,3,4,5] جملة case : grade = 'B' case grade when 'A' puts 'Way to go kiddo' when 'B' puts 'Better luck next time' when 'C' puts 'You can do better' when 'D' puts 'Scraping through' when 'F' puts 'You failed!' else puts 'Alternative grading system, eh?' end #=> "Better luck next time" نستطيع استخدام نطاق مع جملة case بالطريقة التالية: grade = 82 case grade when 90..100 puts 'Hooray!' when 80...90 puts 'OK job' else puts 'You failed!' end #=> "OK job" معالجة الخطأ begin raise NoMemoryError, 'You ran out of memory.' rescue NoMemoryError => exception_variable puts 'NoMemoryError was raised', exception_variable rescue RuntimeError => other_exception_variable puts 'RuntimeError was raised now' else puts 'This runs if no exceptions were thrown at all' ensure puts 'This code always runs no matter what' end بناء الوظائف والدوال def double(x) x * 2 end الوظائف ضمنيا تعيد قيمة آخر جملة في الوظيفة: double(2) #=> 4 الأقواس تُعتبر إضافية، ومن الممكن استدعاء الوظيفة من دونهم: double 3 #=> 6 double double 3 #=> 12 def sum(x, y) x + y end معاملات الوظائف يتم الفصل بينها بواسطة الفاصلة. sum 3, 4 #=> 7 sum sum(3, 4), 5 #=> 12 جملة yield كل الوظائف تمتلك ضمنيا معامل كتلة إضافي خاص بها، وتُستدعى بواسطة كلمة yield : def surround puts '{' yield puts '}' end surround { puts 'hello world' } # { # hello world # } تستطيع تمرير كتلة من الشفرة البرمجية للوظيفة، ونستخدم رمز & لحفظ عنوان كتلة الشفرة البرمجية المُمَرَرَة. def guests(&block) block.call 'some_argument' end تستطيع تمرير أكثر من معامل للوظيفة بشكل غير محدد باستخدام رمز *، وهذه المجموعة من المعاملات تتحول إلى مصفوفة والتي بدورك تستطيع المرور عليها باستخدام جملة each: def guests(*array) array.each { |guest| puts guest } end إذا كانت الوظيفة تُرجع مصفوفة، فإنك تستطيع استخدام المساواة المتعددة لأكثر من متغير في نفس الوقت (unpacking): def foods ['pancake', 'sandwich', 'quesadilla'] end breakfast, lunch, dinner = foods breakfast #=> 'pancake' dinner #=> 'quesadilla' من المتفق عليه أن كل الوظائف التي تعيد قيمة منطقية لابد أن تنتهي بعلامة استفهام عند استدعائها: 5.even? # false 5.odd? # true إذا كانت الوظيفة تنتهي بعلامة تعجب، فهذا يعني أن التغيير الذي يتم على المتغير أو العنصر يكون مباشرا على قيمته، أما بدون علامة تعجب، فإن العملية لا تؤثر على العنصر، ويتم إعادة التغيير في عنصر جديد. انظر للمثال التالي: company_name = "Dunder Mifflin" company_name.upcase #=> "DUNDER MIFFLIN" company_name #=> "Dunder Mifflin" company_name.upcase! # we're mutating company_name this time! company_name #=> "DUNDER MIFFLIN" الأصناف Classes تُعرَّف الأصناف باستخدام الكلمة المحجوزة class: class Human نعرّف في ما يلي متغيرًا على مستوى الصنف، وهو مُشارَك بين الكائنات المتولدة الخاصة بهذا الصنف: @@species = 'H. sapiens' الطريقة الأساسية للاستهلال Initialization : def initialize(name, age = 0) إعطاء قيمة المعامل “الاسم” للمتغير الخاص بالكائن المتولد من الفئة بنفس الاسم @name = name في حالة عدم تمرير معامل باسم “العمر” فإن القيمة التلقائية هي التي ستمرر للمتغير الخاص بالكائن المتولد: @age = age end وظيفة التعديل الأساسية (Setter): def name=(name) @name = name end وظيفة الاسترجاع الأساسية (Getter): def name @name end نستطيع تنفيذ وظيفتي التعديل والاسترجاع بواسطة attr_accessor كالتالي: attr_accessor :name ويمكن فصل العمليتين عن بعضهما. المُسترجِع :getter attr_reader :name المعدِّل setter: attr_writer :name للتمييز بين الوظائف الخاصة بالصنف، والوظائف الخاصة بالكائن المتولد من الصنف، نستخدم كلمة self، وهي خاصة لتعريف الوظائف على مستوى الفئة. def self.say(msg) puts msg end def species @@species end end تعريف كائنين من الصنف Human: jim = Human.new('Jim Halpert') dwight = Human.new('Dwight K. Schrute') استدعاء بعض الوظائف: jim.species #=> "H. sapiens" jim.name #=> "Jim Halpert" jim.name = "Jim Halpert II" #=> "Jim Halpert II" jim.name #=> "Jim Halpert II" dwight.species #=> "H. sapiens" dwight.name #=> "Dwight K. Schrute" استدعاء الوظيفة على مستوى الصنف: Human.say('Hi') #=> "Hi" يُعرَّف مجال المتغيرات في المكان التي عُرِّف فيه المتغيّر، والمتغيرات التي تبدأ ب علامة $ تكون على مستوى النطاق الواسع Global Variable: $var = "I'm a global var" defined? $var #=> "global-variable" المتغيرات التي تبدأ بعلامة @ تكون على مستوى الكائن المتولد: @var = "I'm an instance var" defined? @var #=> "instance-variable" المتغيرات التي تبدأ ب @@ تكون على مستوى الصنف: @@var = "I'm a class var" defined? @@var #=> "class variable" المتغيرات التي تبدأ بحرف كبير تكون ثوابتا: Var = "I'm a constant" defined? Var #=> "constant" المتغير الخاص بالصنف يتشاركه الصنف وكل الأصناف التي تريث منه: # base class class Human @@foo = 0 def self.foo @@foo end def self.foo=(value) @@foo = value end end # derived class class Worker < Human end Human.foo # 0 Worker.foo # 0 Human.foo = 2 # 2 Worker.foo # 2 المتغير الخاص بالكائن المتولد من الصنف غير مشارك أو مرئي في الأصناف التي ترث من الصنف الرئيسي: class Human @bar = 0 def self.bar @bar end def self.bar=(value) @bar = value end end class Doctor < Human end Human.bar # 0 Doctor.bar # nil عند استخدام عملية include لتضمين وحدة Module داخل صنف، فإن الوظائف الخاصة بالوحدة تكون مضمنة في الكائنات المتولدة من الصنف. وعند استخدام عملية extend للوحدة داخل صنف، فإن الوظائف الخاصة بالوحدة تكون مضمنة في نفس الصنف. module ModuleExample def foo 'foo' end end class Person include ModuleExample end class Book extend ModuleExample end Person.foo # => NoMethodError: undefined method `foo' for Person:Class Person.new.foo # => 'foo' Book.foo # => 'foo' Book.new.foo # => NoMethodError: undefined method `foo' تُنفَّذ دوال استرداد Callbacks عندما تُطبَق include أو extend على الوحدة : module ConcernExample def self.included(base) base.extend(ClassMethods) base.send(:include, InstanceMethods) end module ClassMethods def bar 'bar' end end module InstanceMethods def qux 'qux' end end end class Something include ConcernExample end Something.bar # => 'bar' Something.qux # => NoMethodError: undefined method `qux' Something.new.bar # => NoMethodError: undefined method `bar' Something.new.qux # => 'qux' ترجمة – بتصرّف – للمقال Learn X in Y minutes Where X=ruby.