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

مقدمة

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

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

لماذا ولماذا لا؟

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

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

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

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

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

1. يهتم المبرمج بكتابة كود المحرك / الأدوات وليس منطق اللعبة.
2. تم قضاء الوقت في كتابة محرك / أدوات اللعبة.
3. يحب المصممون اللعب بالأشياء. تمنحهم البرمجة النصية حرية تصميم المستويات والوظائف. كما أنه يمنحهم مزيدًا من المرونة لتجربة الأشياء التي عادة ما يحتاجون إليها مبرمجًا.
4. لست مضطرًا إلى إعادة التحويل البرمجي إذا كنت تريد تغيير وظائف اللعبة. فقط قم بتغيير النص.
5. تريد قطع الاتصال بين رمز الجهاز واللعبة. يجب أن يكونوا في جزأين منفصلين. بهذه الطريقة سيكون من الملائم استخدام المحرك للتسلسلات المستقبلية (آمل).

سأقدم بعض التوقعات هنا. على مدى السنوات الخمس المقبلة ، سيتعين على مصممي المستوى القيام بأكثر من مجرد بناء المستويات. يجب أن يكونوا قادرين على استخدام البرنامج النصي لمشاهد اللعبة. اتخذت العديد من الشركات المتطورة هذا النهج بالفعل. أيضًا ، يمكنك رؤية طريقة التكامل هذه في برامج تحرير مثل UnrealEd و Aurora toolset Bioware.

التوضيح والصراخ

آمل الآن أن تكون قد اشتريت بالفعل كلماتي وأردت تضمين مكون نصي في لعبتك. لذا فإن السؤال التالي هو: كيف تفعل هذا بحق الجحيم؟

ما سأستخدمه لمكون البرنامج النصي الخاص بي هو محرك نصي قابل للحقن لوا... في البداية ، سأقول إنني لست خبيرًا في Lua ، لكنها لغة بسيطة نسبيًا ولا تتطلب تعلمًا مملاً لإتقانها. بعض الأمثلة التي سأستعرضها لاحقًا واضحة جدًا. في نهاية هذا المستند ، سأقوم بتضمين بعض المواد المرجعية الإضافية. لكي نكون منصفين ، هناك لغات برمجة أخرى مثل Small و Simkin و Python و Perl. ومع ذلك ، فإن لوا لغة لطيفة ونظيفة. هذه حقا ميزة جيدة.

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

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

• لوكاسارتس
  • قاتمة fandango
  • الهروب من جزيرة القرد
• بايووير
  • بداية ليالي الشتاء

حسنًا ، هذا يكفي مع who-is-who لمطوري lua. يمكنك أن ترى هذا بنفسك على موقع lua.

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

1. الحصول على كود مترجم Lua.
2. تهيئة بيئة التطوير الخاصة بك.
3. بناء المترجم الفوري من الصفر.

مهلا ، أعتقد أنك قلت ما يكفي من التشدق؟

هل هذا كاف؟ لذلك دعونا نبدأ العمل. يمكنك الحصول على كود مصدر Lua من الموقع الرسمي. أود أيضًا أن أتوقف قليلاً عن الإشارة إلى أن هناك إصدارًا جديدًا من lua 5.0 في الأفق. لن أناقش هذا الإصدار في هذه المقالة. سأتعامل معها لاحقًا ، لكن في الوقت الحالي ، سنستخدم 4.0.1.

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

ضيفنا اليوم مقاتل حقيقي للجبهة الخفية. ربما تكون قد شاهدته في الألعاب (World of Warcraft أو Angry Birds أو X-Plane أو S.T.A.L.K.E.R.) أو منتجات Adobe (Lightroom) ، لكنك لم تفكر أبدًا في وجودها. في هذه الأثناء ، يبلغ عمر هذه اللغة بالفعل 25 عامًا ، وطوال هذا الوقت ، جعلت حياتنا الافتراضية أفضل قليلاً.

مرجع سريع

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

تعد الكتابة هنا ديناميكية ، ويتم استخدام البيانات الوصفية لتنفيذ الوراثة ، أي أنها أداة رائعة لتوسيع قدرات منتجك. علاوة على ذلك ، نظرًا لاكتنازها ، فهي مناسبة للاستخدام على أي منصة تقريبًا. احكم بنفسك: تربل لوا 5.3.4 يزن 296 كيلو بايت فقط (غير مضغوط - 1.1 ميغا بايت) ، المترجم (مكتوب بلغة C) لنظام Linux - من 182 إلى 246 كيلو بايت ، ومجموعة المكتبات القياسية - 421 كيلو بايت أخرى.

الرمز

في المظهر والقدرات ، يبدو Lua كمحاولة أخرى لإعادة صياغة JavaScript ، إن لم يكن لظهور الأخير بعد ذلك بعامين. انظر بنفسك:

لنبدأ بالطريقة التقليدية:

طباعة ("Hello World")

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

حقيقة الوظيفة (ن)
إذا كان n == 0 ثم
العودة 1
آخر
عودة ن * حقيقة (ن -1)
نهاية
نهاية

طباعة ("أدخل رقمًا:")
أ = io.read ("* رقم") - اقرأ رقمًا
طباعة (حقيقة (أ))

كل شيء واضح جدا. بالمناسبة ، يدعم Lua التخصيص الموازي:

وأخيرًا ، مثال بسيط إلى حد ما باستخدام المكتبات:

#تضمن
#تضمن
#تضمن
#تضمن
#تضمن

رئيسي Int (باطل) (
شار برتقالي
في الارهاب؛
lua_State * L = lua_open () ، / * يفتح Lua * /
luaopen_base (L) ؛ / * فتح المكتبة الاساسية * /
luaopen_table (L) ؛ / * يفتح مكتبة الجدول * /
luaopen_io (L) ؛ / * يفتح مكتبة الإدخال / الإخراج * /
luaopen_string (L) ، / * يفتح السلسلة lib. * /
luaopen_math (L) ، / * يفتح lib الرياضي. * /

بينما (fgets (buff، sizeof (buff)، stdin)! = NULL) (
خطأ = luaL_loadbuffer (L، buff، strlen (buff)، "line") ||
lua_pcall (L، 0، 0، 0) ؛
إذا (خطأ) (
fprintf (stderr، "٪ s"، lua_tostring (L، -1)) ؛
lua_pop (L ، 1) ؛ / * رسالة خطأ منبثقة من المكدس * /
}
}

Lua_close (L) ؛
العودة 0 ؛
}

المميزات والعيوب

إذن ما هو الجيد في لوا؟

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

بيئات التطوير

LDT (Lua Development Tools) لـ Eclipse - امتداد لواحد من أكثر IDEs شيوعًا ؛

ZeroBrane Studio عبارة عن بيئة متخصصة مكتوبة بلغة Lua ؛

Decoda ليس IDE الأكثر شيوعًا عبر الأنظمة الأساسية ، ولكنه سيعمل كبديل ؛

SciTE هو محرر جيد مع دعم Lua الكامل ؛

WoWUIDesigner - خمّن أي لعبة تساعد هذه البيئة في معالجة البرامج النصية ، بما في ذلك Lua؟

روابط مفيدة

http://www.lua.org/home.html - الموقع الرسمي الذي يحتوي على جميع المعلومات الضرورية ، والبرامج التعليمية ، والكتب ، والوثائق ، وحتى بعض الفكاهة المحددة ؛

http://tylerneylon.com/a/learn-lua/ هو برنامج تعليمي رائع من تايلر نيلون. مناسب للمبرمجين ذوي الخبرة الذين يعرفون اللغة الإنجليزية جيدًا (ومع ذلك ، لن تكون هناك مشاكل كبيرة في القاموس أيضًا) ويريدون فقط توسيع آفاقهم ؛

https://zserge.wordpress.com/2012/02/23/lua- لمدة 60 دقيقة / - أساسيات Lua في 60 دقيقة من مبرمج من الواضح أنه ليس غير مبال بهذه اللغة. بالروسية؛

http://lua-users.org/wiki/LuaTutorial - دروس ويكي

https://youtube.com/watch؟v=yI41OL0-DWM- مقاطع فيديو تعليمية على YouTube ستساعدك على فهم إعداد IDE والمبادئ الأساسية للغة بصريًا.

مخطوطات لوا

ليس للنص المكتوب بلغة Lua أي وظيفة خاصة يمكن من خلالها البدء في تنفيذه. يمكن اعتبار البرنامج النصي ببساطة على أنه مجموعة من الأوامر (التعليمات) التي يتم تنفيذها بدءًا من التعليمات الأولى.

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

العمل مع المتغيرات في Lua

تُستخدم المتغيرات لتخزين القيم أثناء تنفيذ البرنامج النصي.

أسماء متغيرة في لوا

يمكن أن تكون الأسماء المتغيرة (المعرفات) في Lua أي تسلسل من الأحرف والأرقام والشرطات السفلية التي لا تبدأ برقم.

ملاحظة

Lua حساس لحالة الأحرف ، لذا فإن abc و Abc و ABC هي أسماء مختلفة.

يوضح الجدول أدناه الكلمات المحجوزة بواسطة لغة Lua ولا يمكن استخدامها في أسماء المتغيرات:

وكسر تفعل elseif

إنهاء خطأ لوظيفة إذا

في لا شيء المحلي أو لا

كرر العودة ثم صحيح حتى

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

ما المتغيرات الموجودة في لوا؟

يمكن أن تكون المتغيرات في Lua عالمية أو محلية. إذا لم يتم الإعلان عن المتغير صراحة كمتغير محلي ، فإنه يعتبر عالميًا.

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

يظهر المتغير العام عندما يتم تخصيص القيمة الأولى له. قبل تعيين القيمة الأولى ، ينتج عن استدعاء المتغير الشامل صفر.

MsgBox (tostring (g)) -> لا شيء

MsgBox (tostring (g)) -> 1

يوجد متغير عام طالما أن بيئة تنفيذ البرنامج النصي موجودة ومتاحة لأي كود Lua يعمل في تلك البيئة.

إذا لزم الأمر ، يمكنك حذف متغير عام صراحةً عن طريق تعيين قيمة صفرية له.

g = 1 - أنشئ متغيرًا عامًا g بالقيمة 1

g = لا شيء - احذف المتغير العام g

MsgBox (tostring (g)) -> لا شيء

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

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

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

محلي أ - التصريح عن متغير محلي أ

local b = 1 - أعلن عن متغير محلي b ، عيّنه بالقيمة 1

محلي c ، d = 2 ، 3 - أعلن عن المتغيرات المحلية c و d ، وقم بتعيين القيمتين 2 و 3 لهما

يبدأ نطاق المتغير المحلي بعد الإعلان ويستمر حتى نهاية الكتلة.

ملحوظة

نطاق المتغير هو جزء من رمز البرنامج يمكنك من خلاله الوصول إلى القيمة المخزنة في متغير معين.

الكتلة تعني:

جسم هيكل التحكم (إذا ، إذن ، وإلا ، من أجل ، بينما ، كرر) ؛

هيئة وظيفية

جزء من التعليمات البرمجية المضمنة في الكلمات الرئيسية تفعل ... النهاية.

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

local i = 1 - المتغير i محلي داخل البرنامج النصي

عندما أنا<= a do - цикл от 1 до 5

local a = i ^ 2 - المتغير a محلي داخل حلقة while

MsgBox (a) -> 1، 4، 9، 16، 25

MsgBox (أ) ->

إذا كنت> 5 ثم

المحلي a - المتغير a محلي في الداخل إذن

MsgBox (أ) -> 10

MsgBox (أ) -> 5 (هنا إشارة إلى العالمية أ)

local a = 20 - المتغير a محلي داخل do-end

MsgBox (أ) -> 20

MsgBox (أ) -> 5 (هنا إشارة إلى العالمية أ)

ملاحظة

كلما كان ذلك ممكنًا ، يوصى باستخدام المتغيرات المحلية بدلاً من المتغيرات العامة. سيؤدي ذلك إلى تجنب "ازدحام" مساحة الاسم العالمية وتوفير أداء أفضل (نظرًا لأن الوصول إلى المتغيرات المحلية في Lua أسرع إلى حد ما من globals).

أنواع بيانات Lua

ما أنواع البيانات التي يدعمها Lua؟

يدعم Lua أنواع البيانات التالية:

1. لا شيء (لا شيء). يتوافق مع حقيقة أن المتغير ليس له قيمة. يتم تمثيل هذا النوع بقيمة واحدة ، لا شيء.

2. منطقي (منطقي). هذا النوع يتضمن القيم خطأ وصحيح.

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

3. رقم (رقمي). يعمل على تمثيل القيم الرقمية.

يمكن أن تحتوي الثوابت الرقمية على جزء كسري اختياري وترتيب عشري اختياري ، يتم تحديده بواسطة الأحرف "e" أو "E". يمكن تحديد الثوابت العددية الصحيحة بالنظام الست عشري باستخدام البادئة 0x.

أمثلة على الثوابت الرقمية الصالحة: 3 ، 3.0 ، 3.1415926 ، 314.16e-2 ، 0xff.

4. سلسلة (سلسلة). يعمل على تمثيل السلاسل.

يتم تحديد قيم السلسلة كتسلسل من الأحرف ، داخل علامتي اقتباس مفردة أو مزدوجة:

أ = "هذه سلسلة"

ب = "هذا هو السطر الثاني"

يمكن للسلاسل المضمنة بين علامتي اقتباس أن تفسر تسلسلات الهروب التي تشبه الحرف C (تسلسلات الإفلات) التي تبدأ بالحرف "\" (الشرطة المائلة للخلف):

\ ب (مسافة) ،

\ n (تغذية الخط) ،

\ r (عودة السطر) ؛

\ t (علامة تبويب أفقية) ،

\\ (شرطة مائلة للخلف) ؛

\ "" (اقتباس مزدوج)؛

\ "(اقتباس واحد).

ملاحظة

يمكن أيضًا تمثيل حرف في سلسلة برمز خاص به باستخدام تسلسل هروب:

حيث ddd هو تسلسل لا يزيد عن ثلاثة أرقام.

بالإضافة إلى علامات الاقتباس ، يمكن أيضًا استخدام الأقواس المربعة المزدوجة لتعريف سلسلة:

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

محلي أ = [] في Lua] =]

سيكون هناك مصطلح: "تعريف السلسلة [] في Lua"

5. الوظيفة. يمكن كتابة الوظائف في Lua إلى متغيرات ، وتمريرها كمعلمات إلى وظائف أخرى ، وإعادتها كنتيجة لتنفيذ الوظائف.

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

مزيد من التفاصيل - في المقالة "إنشاء الجداول في لوا"

7. Userdata (بيانات المستخدم). إنه نوع بيانات خاص. لا يمكن إنشاء قيم من هذا النوع أو تعديلها مباشرةً في برنامج Lua النصي.

يتم استخدام Userdata لتمثيل الأنواع الجديدة التي تم إنشاؤها في برنامج استدعاء البرنامج النصي أو في مكتبات مكتوبة في C. على سبيل المثال ، تستخدم مكتبات امتداد Lua لـ "CronosPRO" هذا النوع لتمثيل كائنات مثل:

بنوك البيانات (فئة البنك) ؛

قواعد البيانات (الفئة الأساسية) ؛

السجلات (سجل الفصل) ، إلخ.

8. الخيط (الخيط). يتوافق مع تدفق التنفيذ. لا يتم توصيل هذه التدفقات بأي شكل من الأشكال بنظام التشغيل ويتم دعمها حصريًا عن طريق Lua نفسها.

كيفية ضبط نوع المتغير في Lua؟

لا تحدد Lua نوع المتغير بشكل صريح. يتم تعيين نوع المتغير في الوقت الذي يتم فيه تعيين قيمة للمتغير. يمكن تخصيص قيمة لأي متغير من أي نوع (بغض النظر عن نوع القيمة التي كان يحتوي عليها سابقًا).

أ = 123 - المتغير أ من النوع الرقم

أ = "123" - الآن المتغير أ من نوع سلسلة

a = true - الآن المتغير a من النوع المنطقي

أ = () - الآن المتغير أ من نوع الجدول

ملاحظة

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

أ = () - إنشاء جدول. يتم وضع إشارة إلى الجدول في المتغير أ

ب = أ - يشير المتغير ب إلى نفس الجدول أ

أ = 10 - عنصر الجدول مع الفهرس 1 يتم تعيين القيمة 10

MsgBox (b) -> "10"

MsgBox (أ) -> "20"

باقي البيانات هي قيم فورية.

MsgBox (أ) -> "20"

MsgBox (b) -> "10"

كيف تحصل على نوع المتغير في لوا؟

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

t = type ("this is a string") - t تساوي "string"

t = type (123) - t يساوي "number"

t = type (type) - t is "function"

t = type (true) - t هي "منطقية"

t = type (nil) - t تساوي "nil"

t = type (CroApp.GetBank ()) - t يساوي "userdata"

كيفية تحويل نوع المتغير في لوا؟

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

أ = "10" + 2 - أ يساوي 12

أ = "10" + 2 - أ يساوي "10 + 2"

أ = "-5.3e-10" * "2" - أ يساوي -1.06e-09

أ = "سلسلة" + 2 - خطأ! لا يمكن تحويل "سلسلة" إلى رقم

يمكن تحويل أي قيمة بشكل صريح إلى سلسلة باستخدام وظيفة السلسلة القياسية.

أ = الخيط (10) - أ يساوي "10"

أ = سلسلة (صواب) - أ يساوي "صواب"

أ = سلسلة (لا شيء) - أ يساوي "لا شيء"

a = tostring ((= "هذا هو الحقل 1")) - a يساوي "table: 06DB1058"

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

أ = تصيير (10) - أ يساوي "10"

أ = تصيير (صواب) - أ يساوي "صواب"

أ = تصيير (لا شيء) - أ يساوي "لا شيء"

أ = تصيير ((= "هذا هو الحقل 1")) - أ يساوي "(=" هذا هو الحقل 1 ")"

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

أ = طن ("10") - أ يساوي "10"

أ = طن ("10" .. ". 5") - أ يساوي 10.5

أ = طن (صحيح) - أ "لا شيء"

أ = طن (لا شيء) - أ "لا شيء"

ترتيب التعليقات في لوا

يبدأ التعليق في Lua بعلامتين سالب (-) ويستمر حتى نهاية السطر.

محلي أ = 1 - تعليق سطر واحد

إذا كان هناك قوسين مربعين مفتوحين ([[)] يتبعان على الفور الأحرف "-" ، يكون التعليق متعدد الأسطر ويستمر حتى قوسين مربعين للإغلاق (]]).

محلي أ = 1 - [[متعدد الأسطر

تعليق ]]

يمكن أن تتداخل الأقواس المزدوجة في التعليقات. من أجل عدم الخلط بينهما ، تم إدراج علامة المساواة (=) بين الأقواس:

local a = [[شركة Kronos]] - [= [

local a = [[شركة Kronos]]

يحدد عدد الرموز "=" التداخل:

local a = [= [تعريف بعض السلاسل [] في لغة Lua] =] - [== [

local a = [= [تعريف بعض السلاسل [] في لغة Lua] =]

عمليات لوا

يمكن استخدام الأنواع التالية من العمليات في التعبيرات المكتوبة بلغة Lua:

1. العمليات الحسابية.

يدعم Lua العمليات الحسابية التالية:

+ (إضافة) ؛

- (الطرح) ؛

* (عمليه الضرب)؛

/ (قطاع)؛

^ (الأس) ؛

٪ (ما تبقى من التقسيم).

ملاحظة

تنطبق العمليات الحسابية على كل من الأرقام والسلاسل ، والتي يتم تحويلها في هذه الحالة إلى أرقام.

2. عمليات المقارنة.

يُسمح بعمليات المقارنة التالية في Lua:

== (يساوي) ؛

~ = (لا يساوي) ؛

< (меньше);

> (المزيد) ؛

<= (меньше или равно);

> = (أكبر أو يساوي).

ملاحظة

تقوم عمليات المقارنة دائمًا بإرجاع القيمة المنطقية "صواب أو خطأ".

لا تعمل قواعد تحويل الأرقام إلى سلاسل (والعكس صحيح) للمقارنات ، أي أن التعبير "0" == 0 ينتج عنه خطأ.

3. العمليات المنطقية.

تشمل العمليات المنطقية:

و (منطقي و).

يعيد عامل التشغيل and معامله الأول إذا كان خطأ أو لا شيء. وإلا فإن العملية ترجع المعامل الثاني (علاوة على ذلك ، يمكن أن يكون هذا المعامل من أي نوع).

أ = (لا شيء و 5) - أ لا شيء

أ == (خطأ و 5) - أ يساوي خطأ

أ == (4 و 5) - أ يساوي 5

أو (منطقي أو).

يُرجع عامل التشغيل أو المعامل الأول إذا لم يكن خطأ أو لا شيء ، وإلا فإنه يُرجع المعامل الثاني.

أ == (4 أو 5) - أ يساوي 4

أ == (خطأ أو 5) - أ يساوي 5

ملاحظة

يمكن للعمليات المنطقية و / أو إرجاع قيم من أي نوع.

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

أ == (4 أو f ()) - لن يتم استدعاء الوظيفة f ()

لا (منطقي لا).

عملية not ترجع دائمًا صواب أو خطأ.

4. تشغيل التسلسل.

لتسلسل (ربط) السلاسل ، استخدم العملية ... (نقطتان).

a = "Kronos" .. "-" .. "Inform" - سيحصل المتغير a على القيمة "Kronos-Inform"

ملاحظة

إذا كان أحد المعاملين أو كلاهما أرقامًا ، فسيتم تحويلهما إلى سلاسل.

أ = 0..1 - سيحصل المتغير أ على القيمة "01"

5. عملية الحصول على الطول.

يعرّف Lua عامل تشغيل الطول # الذي يمكن استخدامه للحصول على طول سلسلة.

أ = "سلسلة"

len = #a - len يساوي 6

len = # "سطر آخر" - len هو 10

ملاحظة

يمكنك أيضًا استخدام العملية # لمعرفة الحد الأقصى لفهرس (أو حجم) المصفوفة. مزيد من التفاصيل - في مقال "العمل مع المصفوفات في لوا".

أسبقية العملية في Lua

في Lua ، يتم تنفيذ العمليات وفقًا للأولوية التالية (بترتيب تنازلي):

2. not # - (أحادي)

6. < > <= >= ~= ==

استدعاء البرامج النصية من النماذج

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

عند بدء تشغيل النموذج ، يتم تحميل البرنامج النصي الخاص به في البيئة العالمية. عند حدوث حدث في نموذج أو عنصره ، يستدعي النظام وظيفة المعالج المرتبطة بهذا الحدث.

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

المحلي أ = _G.var

كتل البيان

مشغلي Lua الرئيسيين هم:

مهمة؛

عامل شرطي

مشغلي لتنظيم الحلقات.

يمكن دمج مجموعة من العبارات في كتلة (بيان مركب) باستخدام do… end build.

فعل - بداية الكتلة

<оператор1>- كتلة الجسم

<оператор2>

<операторN>

النهاية - نهاية الكتلة

تفتح الكتلة نطاقًا جديدًا يمكنك من خلاله تحديد المتغيرات المحلية.

أ = 5 - المتغير الشامل أ

local a = 20 - داخل المتغير المحلي do-end يتم تعريف a

MsgBox (أ) -> 20

MsgBox (أ) -> 5 (هنا تكون المكالمة بالفعل إلى العالمية أ)

عامل التخصيص لوا

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

أ = 1 - المتغير أ يتم تعيين القيمة 1

أ = ب + ج - المتغير أ يُخصص له مجموع قيم المتغيرين ب وج

a = f (x) - للمتغير a القيمة التي تُرجعها الدالة f (x)

يسمح Lua بما يسمى التخصيص المتعدد ، عندما تتلقى عدة متغيرات على يسار عامل التخصيص قيم العديد من التعبيرات المكتوبة على يمين مشغل التخصيص:

أ ، ب = 1.5 * ج - أ يساوي 1 ؛ ب يساوي 5 * ج

إذا كان هناك متغيرات أكثر من القيم ، فلا شيء يتم إسنادها إلى المتغيرات "الإضافية".

أ ، ب ، ج = 1 ، 2 - أ هو 1 ؛ ب هي 2 ؛ ج لا شيء

إذا كانت هناك قيم أكثر من المتغيرات ، فسيتم تجاهل القيم "الإضافية".

أ ، ب = 1 ، 2 ، 3 - أ هي 1 ؛ ب هي 2 ؛ القيمة 3 غير مستخدمة

يمكن استخدام التخصيص المتعدد لتبادل القيم بين المتغيرات:

أ = 10 ؛ ب = 20 - أ تساوي 10 ، ب تساوي 20

أ ، ب = ب ، أ - الآن أ يساوي 20 ، ب يساوي 10

العبارة الشرطية (إذا) في Lua

تختبر عبارة if ما إذا كان الشرط المحدد صحيحًا. إذا كان الشرط صحيحًا ، فسيتم تنفيذ جزء الكود الذي يلي الكلمة الأساسية (ثم المقطع). خلاف ذلك ، يتم تنفيذ الكود الذي يلي الكلمة الأساسية else (قسم else).

إذا أ> ب ثم

إرجاع a - إذا كانت a أكبر من b ، قم بإرجاع a

العودة ب - خلاف ذلك ، العودة ب

قسم آخر اختياري.

اذا كان< 0 then

a = 0 - إذا كانت a أقل من 0 ، فاضبط a على 0

بدلاً من عبارات if المتداخلة ، يمكنك استخدام بنية elseif. على سبيل المثال ، الكود التالي:

سيكون من الأسهل فهمه إذا قمت باستبداله بما يلي:

إرجاع "Ivan" - إذا كان a هو 1

elseif a == 2 ثم

إرجاع "Peter" - إذا كانت a هي 2

elseif a == 3 ثم

إرجاع "سيرجي" - إذا كانت a 3

إرجاع "لا يوجد مثل هذا اللاعب" - إذا لم يكن أي مما سبق

لوا أثناء التكرار

تم تصميم تعليمة while لتنظيم الحلقات بشرط مسبق ولها الشكل التالي:

في حين فعل

... - جسم الدورة

قبل كل تكرار للحلقة ، يتم فحص الشرط :

إذا كان الشرط خاطئًا ، تنتهي الحلقة ويتم نقل التحكم إلى العبارة الأولى التي تلي تعليمة while ؛

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

بينما أنا> 0 تفعل - حلقة من 10 إلى 1

t [i] = "الحقل" .. i

أ = (3 ، 5 ، 8 ، -6 ، 5)

بينما أنا> 0 - البحث عن قيمة سالبة في المصفوفة

إذا كان [i]< 0 then break end - если найдено, прерываем цикл

أنا = أنا - 1 - وإلا انتقل إلى العنصر التالي

إذا كنت> 0 ثم

MsgBox ("فهرس القيمة السالبة:" ..i)

MsgBox ("لا تحتوي الصفيف على قيم سالبة")

ملحوظة

حلقة مع شرط لاحق (كرر) في Lua

تم تصميم تعليمة التكرار لتنظيم الحلقات ذات الشرط اللاحق ولها الشكل التالي:

... - جسم الدورة

حتى

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

اجمع قيم المصفوفة أ حتى يتجاوز المجموع 10

أ = (3 ، 2 ، 5 ، 7 ، 9)

sum = sum + a [i]

حتى المجموع> 10

MsgBox (عناصر "Stacked" ..i .. ". المبلغ" ..sum)

يمكنك استخدام تعليمة break للخروج من الحلقة قبل اكتمالها.

ملحوظة

مزيد من التفاصيل حول ميزات استخدام عامل التشغيل break - في مقالة "عبارات break and return"

لوا للحلقات

تم تصميم تعليمة for لتنظيم الحلقات ويمكن كتابتها في شكلين:

بسيط (رقمي لـ) ؛

ممتد (عالمي).

الشكل البسيط لبيان for

الشكل البسيط لبيان for يبدو كما يلي:

بالنسبة إلى var = exp1 ، و exp2 ، و exp3

... - جسم الدورة

يتم تنفيذ جسم الحلقة لكل قيمة لمتغير الحلقة (العداد) var في النطاق من exp1 إلى exp2 ، مع الخطوة exp3.

ملحوظة

قد لا يتم تعيين الخطوة. في هذه الحالة ، يتم أخذها مساوية لـ 1.

بالنسبة إلى i = 1 ، 10 do - loop من 1 إلى 10 مع الخطوة 1

MsgBox ("i يساوي" ..i)

بالنسبة إلى i = 10 ، 1 ، -1 do - حلقة من 10 إلى 1 بخطوة -1

MsgBox ("i يساوي" ..i)

ملاحظة

يتم تقييم التعبيرات exp1 و exp2 و exp3 مرة واحدة فقط قبل بدء الحلقة. لذلك ، في المثال أدناه ، سيتم استدعاء الدالة f (x) لحساب الحد الأعلى للحلقة مرة واحدة فقط:

من أجل i = 1 ، f (x) do - حلقة من 1 إلى القيمة المعادة بواسطة الدالة f ()

MsgBox ("i يساوي" ..i)

متغير الحلقة هو محلي بالنسبة لتعليمة الحلقة وهو غير معرف في نهايته.

بالنسبة إلى i = 1 ، 10 do - loop من 1 إلى القيمة التي أرجعها f ()

MsgBox ("i يساوي" ..i)

MsgBox ("بعد الخروج من الحلقة ، أنا يساوي" ..i) - خطأ! أنا لا شيء

ملاحظة

لا يمكن تغيير قيمة متغير الحلقة داخل حلقة: عواقب مثل هذا التغيير لا يمكن التنبؤ بها.

للخروج من الحلقة قبل أن تنتهي ، استخدم تعليمة break.

أ = (3 ، 5 ، 8 ، -6 ، 5)

من أجل i = 1 ، # a do - ابحث عن قيمة سالبة في المصفوفة

إذا كان [i]< 0 then - если найдено...

الفهرس = i - تخزين فهرس القيمة التي تم العثور عليها ...

كسر - وكسر الحلقة

MsgBox ("فهرس القيمة السالبة:" ..index)

ملحوظة

مزيد من التفاصيل حول ميزات استخدام عامل التشغيل break - في المقالة "عبارات break and return")

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

لوا؟ ما هذا؟

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

لم؟

قد يكون Lua مفيدًا لك:

* إذا كنت لاعبًا (مكونات إضافية لـ World of Warcraft والعديد من الألعاب الأخرى)
* إذا كنت تكتب ألعابًا (غالبًا في الألعاب ، يكون المحرك مكتوبًا بلغة C / C ++ و AI - بلغة Lua)
* إذا كنت مبرمج نظام (يمكنك كتابة مكونات إضافية لـ nmap و wireshark و nginx وأدوات مساعدة أخرى في Lua)
* إذا كنت مطورًا مضمنًا (Lua سريع جدًا ومضغوط ويتطلب موارد قليلة جدًا)

1. تعلم البرمجة. على الأقل قليلا. لا يهم أي لغة.
2. قم بتثبيت Lua. للقيام بذلك ، قم بتنزيل الإصدار 5.2 من هنا (http://www.lua.org/download.html) ، أو ابحث عنه في المستودعات. سيعمل الإصدار 5.1 أيضًا ، لكن اعلم أنه قديم جدًا.

قم بتشغيل كل الأمثلة من المقالة في المحطة بأمر مثل "lua file.lua".

الإنطباعات الأولى

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

أول تطبيق lua: hello.lua اطبع "hello world" ؛ print ("goodbye world")

ماذا يمكن أن يقال بالفعل عن اللغة:

* تبدأ التعليقات على سطر واحد بشرطةتين "-"
* يمكن حذف الأقواس والفاصلة المنقوطة

عوامل تشغيل اللغة

مجموعة الشرطية والحلقات نموذجية جدًا:

العبارات الشرطية (قد لا يكون هناك فروع أخرى) إذا كانت a == 0 ثم طباعة ("a تساوي صفر") وإلا طباعة ("a ليست صفرًا") end - شكل مختصر if / elseif / end (بدلاً من switch / case) إذا كانت a == 0 ثم اطبع ("صفر") elseif a == 1 ثم اطبع ("one") elseif a == 2 ثم اطبع ("two") else print ("other") حلقة العداد لـ i = 1 ، 10 قم بطباعة (i) end - loop بشرط مسبق b = 5 بينما b> 0 do b = b - 1 end - loop مع كرر الشرط اللاحق b = b + 1 حتى b> = 5

فكر: ماذا يمكن أن تعني حلقة "for i = 1، 10، 2 ​​... end"؟

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

* مهمة: x = 0
* حسابي: + ، - ، * ، / ،٪ (باقي القسمة) ، ^ (الأس)
* منطقي: و ، أو لا
* المقارنة:> ،<, ==, <=, >= ، ~ = (لا يساوي ، نعم ، نعم ، بدلاً من المعتاد "! =")
* سلسلة السلسلة (عامل التشغيل "..") ، على سبيل المثال: s1 = "hello"؛ s2 = "العالم" ؛ s3 = s1..s2
* الطول / الحجم (عامل التشغيل #): s = "hello" ؛ a = #s ('a' ستكون 5).
* الحصول على عنصر بالفهرس ، على سبيل المثال: s

لفترة طويلة ، لم تكن هناك عمليات بت في اللغة ، ولكن في الإصدار 5.2 ظهرت مكتبة bit32 ، والتي تنفذها (كوظائف ، وليس كمشغلين).

أنواع البيانات

لقد كذبت عليك عندما قلت أن اللغة بها نوع بيانات واحد. لديه الكثير منهم (مثل كل لغة جادة):

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

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

والآن أهم شيء في اللغة هو الجداول.

الجداول

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

إذن ، هذا مثال لجدول كمصفوفة: أ = (1 ، 2 ، 3) - مصفوفة من 3 عناصر مطبوعة (أ) - ستخرج "2" ، لأن الفهارس تحسب من واحد - الجدول هو مجموعة متفرقة (لا تحتوي على جميع العناصر) أ = () - جدول فارغ أ = 1 أ = 5

فكر: ما المقصود بمصفوفة متفرقة؟

في المثال أعلاه ، يتصرف الجدول كمصفوفة ، لكن في الواقع - لدينا مفاتيح (فهارس) وقيم (عناصر مصفوفة). وفي الوقت نفسه ، يمكن أن تكون المفاتيح من أي نوع وليس مجرد أرقام:

A = () a ["hello"] = صحيح a ["world"] = false a = 1 - أو مثل هذا: a = (hello = 123، world = 456) print (a ["hello")) print ( a.hello) هو نفسه ["hello"] ، على الرغم من أنه يبدو كهيكل به حقول

بالمناسبة ، نظرًا لأن الجدول يحتوي على مفاتيح وقيم ، يمكنك تكرار جميع المفاتيح والقيم المقابلة لها في حلقة:

T = (a = 3، b = 4) للمفتاح ، القيمة في أزواج (t) قم بطباعة (مفتاح ، قيمة) - طباعة "a 3" ، ثم "b 4" النهاية

لكن ماذا عن الأشياء؟ سنتعرف عليهم بعد قليل ، أولاً - حول الوظائف.

المهام

فيما يلي مثال على دالة مشتركة.

وظيفة إضافة (أ ، ب) إرجاع أ + ب طباعة نهاية (إضافة (5 ، 3)) - ستطبع "8"

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

فكر: لماذا تريد إرجاع وسيطات متعددة؟

تبديل الوظائف (أ ، ب) إرجاع ب ، نهاية س ، ص = مبادلة (س ، ص) - بالمناسبة ، يمكن القيام بذلك بدون دالة: س ، ص = ص ، س - وإذا كانت الدالة ترجع عدة وسيطات ، - ولا تحتاجهم - تجاهلهم - متغير شرطة سفلية خاص "_" a، _، _، d = some_function ()

يمكن أن تأخذ الدوال عددًا متغيرًا من الوسائط:

في النموذج الأولي ، يتم كتابة العدد المتغير للوسيطات على هيئة مجموع دالة القطع (...) s = 0 لـ _ ، n في أزواج (arg) تفعل - في الوظيفة يشار إليها باسم الجدول "arg" s = s + n تُرجع النهاية مجموعًا نهائيًا (1 ، 2 ، 3) - تُرجع 6 مجموع (1 ، 2 ، 3 ، 4) - تُعيد 10

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

A = دالة (x) تُرجع x * 2 end - دالة تضرب في 2 b = دالة (x) تُرجع x + 1 end - تُطبق الدالة التي تزيد بمقدار 1 دالة (جدول ، f) نتيجة = () لـ k ، v في أزواج (جدول) هل النتيجة [k] = f (v) - استبدل العنصر ببعض الوظائف من نهاية هذا العنصر - فكر: ما تستدعي t = (1 ، 3 ، 5) سيعود تطبيق (t ، a) تطبيق ( ر ، ب)

الكائنات = وظائف + جداول

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

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

المصباح = (تشغيل = خطأ) وظيفة turn_on (l) l.on = وظيفة النهاية الحقيقية turn_off (l) l.on = نهاية خاطئة هي مجرد وظائف للعمل مع هيكل turn_on (lamp) turn_off (lamp)

وإذا قمنا بتحويل المصباح الكهربائي إلى كائن ، وقمنا بتحويل وظائف turn_off و turn_on إلى حقول الكائن ، نحصل على:

المصباح = (تشغيل = خطأ turn_on = الوظيفة (l) l.on = إيقاف تشغيل النهاية الحقيقية = الوظيفة (l) l.on = النهاية الخاطئة) lamp.turn_on (lamp) lamp.turn_off (lamp)

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

المصباح: turn_on () - المصباح الأكثر شيوعًا.

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

المصباح = (تشغيل = خطأ) - خلال فترة ، يجب تحديد الوسيطة الوظيفة lamp.turn_on (l) l.on = true end - خلال النقطتين ، ثم يتم تعيين الوسيطة ضمنيًا على أنها المتغير "self" - "self "- وهناك المصباح الذي تم استدعاء مصباح الوظيفة من أجله: turn_off () self.on = نهاية خاطئة

مثير للاهتمام؟

وظائف خاصة

بعض أسماء وظائف (طريقة) الجدول محجوزة ولها معنى خاص:

* __add (a، b)، __sub (a، b)، __div (a، b)، __mul (a، b)، __mod (a، b)، __pow (a، b) - تسمى عند إجراء العمليات الحسابية على جدول
* __unm (a) - عملية ناقص أحادية (عندما يكتبون شيئًا مثل "x = -x")
* __lt (a، b)، __le (a، b)، __eq (a، b) - احسب نتيجة المقارنة (<, <=, ==)
* __len (a) - تسمى عند إتمام "#a"
* __concat (a، b) - تسمى عند "a..b"
* __call (a، ...) - يسمى عند "a ()". المتغيرات هي وسيطات عند استدعائها
* __index (a، i) - استدعاء [i] بشرط عدم وجود مثل هذا العنصر
* __newindex (a، i، v) - إنشاء "a [i] = v"
* __gc (a) - عندما يتم التخلص من كائن من خلال جمع القمامة

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

ميراث

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

لدى Lua مفهوم جدول التعريف لهذا ، أي طاولات الأسلاف. يحتوي كل جدول على جدول أصلي واحد ، ويمكن للجدول الفرعي القيام بكل ما يمكن للأصل القيام به.

لنفترض أننا أنشأنا بالفعل كائن طاولة المصباح. ثم سيبدو المصباح الكهربائي الفائق كما يلي:

Superlamp = (السطوع = 100) - حدد مجموعة الجدول الأصلمتابل (superlamp ، مصباح) - وطرقها متاحة الآن superlamp: turn_on () superlamp: turn_off ()

توسيع الوظائف

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

S = getmetatable ("") - الحصول على الجدول الأصل للصف s .__ add = function (s1، s2) إرجاع s1..s2 end - تغيير الطريقة - تحقق من a = "hello" b = "world" print ( أ + ب) - ستكتب "helloworld"

في الواقع ، لا يزال بإمكاننا استبدال وظيفة الطباعة بـ "print = myfunction" ، ويمكن القيام بالعديد من عمليات القرصنة الأخرى.

النطاقات

المتغيرات عالمية ومحلية. عند الإنشاء ، تكون جميع المتغيرات في Lua عامة.

فكر: لماذا؟

لتحديد النطاق المحلي ، اكتب الكلمة الأساسية المحلية:

محلي x محلي var1 ، var2 = 5 ، 3

لا تنسى هذه الكلمة.

معالجة الخطأ

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

يتم طرح الأخطاء باستخدام دالة error (x). يمكن تمرير أي شيء كوسيطة (ما هو وثيق الصلة بالخطأ - وصف سلسلة ، رمز رقمي ، الكائن الذي حدث الخطأ به ، وما إلى ذلك)

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

الوظيفة f (x ، y) ... إذا ... ثم الخطأ ("فشل في القيام بشيء ما") ينتهي ... حالة النهاية ، يخطئ = pcall (f ، x ، y) - f: function ، xy: وسيطاتها إن لم يكن الوضع ثم - معالجة الخطأ يخطئ. في حالتنا ، يحتوي err على نهاية نص الخطأ

المكتبات القياسية

هناك العديد من المكتبات غير القياسية ، ويمكن العثور عليها في LuaForge و LuaRocks ومستودعات أخرى.

بين لوا ونون لوا

وماذا لو كانت وظائف المكتبات القياسية لا تكفي لنا؟ ماذا لو كان لدينا برنامج C الخاص بنا ، وأردنا استدعاء وظائفه من Lua؟ هناك آلية بسيطة للغاية لذلك.

لنفترض أننا نريد إنشاء دالة خاصة بنا تُرجع رقمًا عشوائيًا (يحتوي Lua على math.random () ، لكننا نريد أن نتعلم). سيتعين علينا كتابة الكود التالي في C:

#تضمن #تضمن #تضمن / * ما يجب فعله فعليًا عند استدعاء `rand (from، to)` * / static int librand_rand (lua_State * L) (int from، to؛ int x؛ from = lua_tonumber (L، 1)؛ / * المعلمة الأولى من الوظيفة * / to = lua_tonumber (L، 2)؛ / * المعلمة الثانية للوظيفة * / x = rand ()٪ (to - from + 1) + from؛ lua_pushnumber (L، x)؛ / * قيمة الإرجاع * / return 1 ؛ / * إرجاع وسيطة واحدة فقط * /) / * في Lua "rand" يتوافق مع وظيفة librand_rand () * / static const luaL_reg R = (("rand"، librand_rand)، (NULL، NULL) / * end قائمة الوظائف المصدرة * /) ؛ / * يتم استدعاؤه عند تحميل المكتبة * / LUALIB_API int luaopen_librand (lua_State * L) (luaL_openlib (L، "librand"، R، 0)؛ srand (time (NULL))؛ return 1؛ / * Success * /)

أولئك. يوفر لنا Lua وظائف للعمل مع أنواع البيانات ، لتلقي وسيطات الدالة وإرجاع النتائج. الوظائف قليلة ومتباعدة. نقوم الآن ببناء مكتبتنا كمكتبة ديناميكية ، ويمكننا استخدام وظيفة rand ():

عشوائي = يتطلب ("librand") - تحميل طباعة المكتبة (علامة تجارية عشوائية (1 ، 100)) طباعة (علامة تجارية عشوائية (0 ، 1))

ماذا لو أردنا الاتصال برمز Lua من برامجنا؟ ثم يجب على برامجنا إنشاء آلة افتراضية Lua ، حيث سيتم تنفيذ برامج Lua النصية. إنه أسهل بكثير:

#include "lua.h" #include "lauxlib.h" int main () (lua_State * L = lua_open ()؛ // إنشاء آلة افتراضية Lua luaL_openlibs (L) ؛ // تحميل المكتبة القياسية luaL_dofile (L، " rand. lua ") ؛ // تنفيذ البرنامج النصي lua_close (L) ؛ // أغلق Lua return 0 ؛)

كل شئ.

يمكنك الآن الكتابة بلغة لوا. إذا اكتشفت نقاطًا مثيرة للاهتمام حول Lua يمكن أن تنعكس في المقالة - اكتب!

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

السلسلة بأكملها لن تخضع لأي نظام. ستقدم الدروس بالتتابع عددًا من تراكيب اللغة بحيث يمكنك بالفعل كتابة برامجك بحلول الدرس الثالث أو الرابع. هدفي هو دفعك لتعلم اللغة بمفردك ، لمساعدتك على الشعور بها ، وليس شرحها من الألف إلى الياء - إذا كنت تريد إتقان اللغة تمامًا ، فاقرأ الدليل المرجعي (والذي ، وإن كان سيئًا ، هو مترجم إلى اللغة الروسية: http: //www.lua .ru / doc /). كلما أسرعت في الانتقال من الدروس "للدمى" على الويب لدراسة الدليل ، كان ذلك أفضل.

إذا كان هناك شيء غير واضح - تأكد من طرح سؤال في التعليقات ، وسأحاول أنا والأعضاء الآخرون مساعدتك.

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

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

1. قم بتنزيل توزيعة Lua الرسمية من أحد المواقع التي توفرها.

يمكن فقط تنزيل الكود المصدري للمترجم الفوري من موقع Lua الرسمي. ومع ذلك ، من خلال فحص http://lua.org/download.html في قسم الثنائيات ، قد تجد ارتباطات إلى مواقع بها ملفات قابلة للتنفيذ لنظام التشغيل Windows. واحد منهم: . قم بتنزيل أحد الأرشيفات من هناك (تطابق النظام الأساسي الخاص بك: Win32 أو Win64) وقم بفك ضغطه في مكان ما ، ويفضل أن يكون ذلك في دليل بمسار قصير: مثل C: \ lua. من الآن فصاعدًا ، سأفترض أنك تستخدم Windows وأن المترجم الفوري الخاص بك موجود.

يعد مستخدمو أنظمة التشغيل المستندة إلى Linux أسهل في هذا المعنى: فهم يحتاجون فقط إلى استخدام مدير الحزم وتثبيت Lua من المستودعات. في Debian و Ubuntu ، يتم ذلك باستخدام apt-get install lua ، وفي Fedora و Red Hat والمشتقات ، يتم ذلك باستخدام yum install lua. ومع ذلك ، لا تثق بي بشكل أعمى واستشر دليل نظام التشغيل الخاص بك لمعرفة كيفية القيام بذلك بالضبط.

2. استخدم مترجمًا فوريًا على الإنترنت.

يقع في http://www.lua.org/demo.html. في البداية ، قد يكون ذلك كافيًا ، ولكن في وقت لاحق ، عندما نتطرق إلى الوحدات ، سيتعين عليك استخدام الإصدار غير المتصل. يعد استخدام المترجم الفوري عبر الإنترنت أمرًا بسيطًا للغاية: أدخل البرنامج الخاص بك في النافذة مع النص وانقر فوق الزر "تشغيل". سيتم تنفيذ البرنامج ، ستظهر نافذة الإخراج مخرجات البرنامج ، بالإضافة إلى تقارير الأخطاء ، إن وجدت.

3. استخدم IDE.

على سبيل المثال ZeroBrane Studio: http://studio.zerobrane.com/. هناك آخرون - ابحث في الإنترنت.

يوجد الآن إصداران مختلفان قليلاً من Lua في التداول: 5.1 و 5.2. سأركز على أحدث إصدار - الإصدار 5.2 ، لكنني سأشير بالتأكيد إلى الاختلافات المهمة بينه وبين الإصدار 5.1 ، نظرًا لأن الأخير شائع جدًا أيضًا. بالمناسبة ، يقوم Lua 5.1 بتنفيذ التعليمات البرمجية مرة ونصف أسرع من Lua 5.2 ، لذلك أنت تعلم.

=== الدرس الأول ===

لذا ، لنبدأ. قم بإنشاء ملف main.lua في مجلد معزول عن الملفات الخارجية واكتب فيه:

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
- main.lua -
طباعة ("Hello world!")

ثم قم بتشغيل سطر الأوامر (لا تنسَ الانتقال إلى الدليل باستخدام main.lua باستخدام الأمر cd):

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
> C: \ lua \ lua.exe main.lua

رداً على ذلك ، سيصدر مترجم Lua:

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
مرحبا بالعالم!

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

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
طباعة (8) - بعض الأعداد العشرية
- سيخرج: 8

طباعة (0xDEADBEEF) - رقم سداسي عشري
- سيخرج: 3735928559

الطباعة ("0xDEADBEEF") عبارة عن سلسلة وليست رقمًا! هل ترى الاقتباسات؟
- سيخرج: 0xDEADBEEF

طباعة (1.35e-4) - رقم الفاصلة العائمة (رقم كسري)
- سوف ينتج 0.000135. يجب أن يُفهم 1.35e-4 على أنه "1.35 مضروبًا
- بعشر إلى الدرجة الرابعة ناقص "، إذا كان أحد لا يعلم.

طباعة ((198 * 99) -3 * 500 + 14/88) - تعبير
- سيتم عرض قيمة التعبير: 18102.159090909. ليس بديلا سيئا
- آلة حاسبة سطح المكتب!

طباعة (198/7 ، "الأسمدة" ، 2 ^ 9) - عدة معلمات عشوائية
- نوع. سيتم عرض قيم كل منهم ، مفصولة بعلامات
- نوافذ التبويب:
- 28.285714285714 سماد 512
- يرجى ملاحظة أنه لا يتم عرض عروض الأسعار حول الأسمدة!

الطباعة (1.35) هي رقمان ، وليست كسرًا عشريًا من 1.35!
- تستخدم الفاصلة لفصل المعلمات.
- سوف يخرج:
-- 1 35

علامة "-" ليست مجرد تقليد للشرطة التي يتم إدخالها من أجل الجمال. تشير علامة "-" في Lua إلى التعليقات: تلميحات للمبرمج يتجاهلها المترجم وتهدف إلى تسهيل فهم الكود. يمكنك محاولة الكتابة في البرنامج:

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
- طباعة ("لا شيء")

سيعتقد المترجم أنه تعليق ولن يتبع التعليمات.

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

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
طباعة "سلسلة واحدة فقط"

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

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
طباعة 2 - لن تنجح ، 2 - ليست سلسلة.
طباعة 2 * 2 + 6 - علاوة على ذلك لن تعمل

Str = "سلسلة !!" - يُخصص للمتغير str القيمة "string !!"
- اقرأ عن المتغيرات أدناه
طباعة str لن تعمل أيضًا.

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

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

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
<имя_переменной> = <выражение>

على سبيل المثال:

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
star = 8 - يقوم المتغير النجم الآن بتخزين الرقم 8
wars = "owl" - يحتوي متغير wars على السلسلة "owl"
jedi = 42/2 - في متغير جيد - رقم 21
luke = star * jedi - متغير luke هو الرقم 168 (نعم ، 21 ضرب 8)

يمكن أيضًا عرض قيم المتغيرات والتعبيرات معهم:

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
طباعة (ستار ، وورز ، جدي ، جيدي ستار + لوك)
- سوف يخرج:
- 8 بومة 21181

فقط لا تحاول إضافة المتغيرات star and wars - محاولة إضافة 8 إلى "owl" لن يفيدك!

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

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
وكسر تفعل elseif تنتهي
خطأ لوظيفة الانتقال إذا كان في
لا شيء محلي أو تكرار الإرجاع
ثم صحيح حتى حين

من خلال إنشاء متغير بأحد هذه الأسماء ، سوف تتسبب في حدوث خطأ في البرنامج ، ولن يعمل بالتأكيد. يرجى ملاحظة أنه في Lua 5.1 لا توجد كلمة مفتاحية goto ، ويمكنك تسمية متغير بهذه الطريقة ، لكن من الأفضل ألا تفعل ذلك.
لاحظ أيضًا أن أسماء المتغيرات حساسة لحالة الأحرف. هذا يعني أن foo و fOo و fOO و FOO هي أربعة متغيرات مختلفة ، لذلك إذا كتبت اسم متغير بأحرف صغيرة ثم كتبته لاحقًا بأحرف كبيرة ، فعلى الأرجح لن يعمل البرنامج بشكل صحيح.

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

حاول ، على سبيل المثال ، تشغيل برنامج مثل هذا:

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
- main.lua -
foo = "شريط"
طباعة (فو ، باز)
- سوف يخرج:
- شريط لا شيء

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

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
cool_var = لا شيء

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

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

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

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
2 + "سلسلة" ؛
6 + "14";
"مربع" - "vox" ؛
1 * "11 ب"
"148" * "1e6" ؛

3. اكتب برنامجًا يتبادل متغيرين. هذا هو:

200؟ "200px": "" + (this.scrollHeight + 5) + "px")؛ ">
أ = 6502
ب = 8086

اجعل a يساوي 8086 و b يساوي 6502. للقيام بذلك ، أنشئ متغيرًا ثالثًا وقم ببعض المقايضات البسيطة. تأكد من حل المشكلة بشكل صحيح عن طريق استدعاء الطباعة (أ ، ب) قبل التبادل وطباعة (أ ، ب) بعد.