ما هو الفرق بين اللغات المكتوبة القانونية والمبتونة بشكل ديناميكي؟

https://stackoverflow.com/questions/1517582

19-09-2019
|

سؤال

أسمع الكثير من وجود لغات البرمجة الجديدة مكتوبة ديناميكيا ولكن ما يعنيه فعلا عندما نقول أن اللغة مكتوبة ديناميكيا مقابل مكتوبة ثابتة؟

المحلول

مكتوبة ثابتة

لغة مكتوبة قانونيا إذا كان نوع المتغير معروف في وقت الترجمة. بالنسبة لبعض اللغات، هذا يعني أنك كما يجب أن يحدد مبرمج ما نوع كل متغير (على سبيل المثال: Java، C، C ++)؛ اللغات الأخرى تقدم شكلا من أشكال اكتب الاستدلال, ، القدرة على نظام النوع لاستنتاج نوع المتغير (على سبيل المثال: Ocaml، Haskell، Scala، Kotlin)

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

أمثلة: C، C ++، Java، Rust، GO، Scala

لغات مكتوبة ديناميكيا

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

أمثلة: بيرل، روبي، بيثون، PHP، جافا سكريبت

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

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

نصائح أخرى

لغات البرمجة المكتوبة ثابتة تفعل التحقق من نوع (أي عملية التحقق من وتطبيق قيود الأنواع) في وقت الترجمة في مقابل مدة العرض.

لغات البرمجة المكتوبة ديناميكيا تفعل نوع التدقيق في مدة العرض في مقابل وقت الترجمة.

فيما يلي مثال يتناقض مع كيفية التعامل مع Python (مكتوبة ديناميكيا) وتذهب (مكتوبة ثابتة) خطأ في النوع:

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

Python لا يكتب التحقق من وقت التشغيل، وبالتالي:

silly(2)

يدير بشكل جيد تماما، وتنتج الناتج المتوقع Hi. وبعد يتم رفع الخطأ فقط إذا تم ضرب الخط الإشكالي:

silly(-1)

ينتج عنه

TypeError: unsupported operand type(s) for +: 'int' and 'str'

لأنه تم تنفيذ الخط المعني بالفعل.

اذهب من ناحية أخرى لا يفحص النوع في وقت الترجمة:

package main

import ("fmt"
)

func silly(a int) {
    if (a > 0) {
        fmt.Println("Hi")
    } else {
        fmt.Println("3" + 5)
    }
}

func main() {
    silly(2)
}

لن تجميع أعلاه، مع الخطأ التالي:

invalid operation: "3" + 5 (mismatched types string and int)

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

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

String str = "Hello";  //variable str statically typed as string
str = 5;               //would throw an error since str is supposed to be a string only

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

على سبيل المثال في بيثون:

str = "Hello" # variable str is linked to a string value
str = 5       # now it is linked to an integer value; perfectly OK

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

لنلخص، اكتب يصف (أو يجب أن يوصف) المتغيرات باللغة بدلا من اللغة نفسها. كان يمكن استخدامه بشكل أفضل كما لغة ذات متغيرات مكتوبة ثابتة عكس لغة مع المتغيرات المكتوبة ديناميكيا IMHO.

اللغات المكتوبة بشكل ثابت محددة الآن لغات، وبالتالي، فإن المحامصين تحقق من الأنواع (جعل الشعور بالكمال الصحيح؟ كما لا يسمح بتغيير الأنواع لاحقا في وقت التشغيل).

يتم تفسير اللغات المكتوبة بشكل حيوي بشكل عام، وبالتالي اكتب الفحص (إن وجدت) يحدث وقت التشغيل عند استخدامها. هذا بالطبع يجلب بعض تكلفة الأداء، وهو أحد الأسباب اللغات الديناميكية (على سبيل المثال، بيثون، روبي، PHP) لا تقميز بأنها جيدة مثل تلك المكتوبة (Java، C #، إلخ). من منظور آخر، لغات مكتوبة ثابتة لديها تكلفة بدء التشغيل: يجعلك عادة ما تكتب المزيد من التعليمات البرمجية، وأصعب رمز. ولكن هذا يدفع لاحقا قبالة.

الشيء الجيد هو كلا الجانبين يتمتعون بميزات الاقتراض من الجانب الآخر. تتضمن اللغات المكتوبة المزيد من الميزات الديناميكية، على سبيل المثال، الأجداد والمكتبات الديناميكية في C #، واللغات الديناميكية بما في ذلك التحقق من نوع أكثر، أو اكتب التعليقات التوضيحية في Python، أو اختراق PHP، والتي عادة ما تكون الأساسية للغة وقابلة للاستخدام الطلب.

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

http://en.wikipedia.org/wiki/type_system.

الكتابة الثابتة

يقال إن لغة البرمجة تستخدم الكتابة الثابتة عند إجراء فحص النوع أثناء ترجمة الوقت بدلا من تشغيل وقت التشغيل. في الكتابة الساكنة، ترتبط الأنواع بمتغيرات غير قيم. تشمل اللغات المكتوبة بشكل ثابت ADA، C، C ++، C #، Jade، Java، Fortran، Haskell، ML، Pascal، PERL (فيما يتعلق بالتمييز، الصفائف، الصفيف، التجزئة، الروتينات الفرعية) و Scala. الكتابة الساكنة هي شكل محدود من التحقق من البرامج (انظر السلامة النوع): وفقا لذلك، فإنه يسمح بعد أن يتم القبض على العديد من الأخطاء من النوع مبكرا في دورة التطوير. يقوم لعبة الداما الثابتة بتقييم معلومات النوع فقط التي يمكن تحديدها في وقت ترجمة قد يكون تنفيذ البرنامج أكثر كفاءة (أي أسرع أو أخذ الذاكرة المنخفضة) عن طريق حذف الشيكات من نوع التشغيل وتمكين التحسينات الأخرى.

نظرا لأنهم يقومون بتقييم معلومات النوع أثناء التجميع، وبالتالي لا يفتقرون إلى معلومات النوع المتوفرة فقط عند وقت التشغيل، فإن لعبة الداما المحافظة عليها. سوف يرفضون بعض البرامج التي قد تكون تصرفت بشكل جيد في وقت التشغيل، ولكن لا يمكن تحديدها قانونيا أن تكون مكتوبة جيدا. على سبيل المثال، حتى لو كان التعبير دائما يقيم دائما في وقت التشغيل، وهو برنامج يحتوي على التعليمات البرمجية
if <complex test> then 42 else <type error>
سيتم رفضها على أنها غير مكتوبة، لأن التحليل الثابت لا يمكن أن يحدد أن الفرع الأخير لن يؤخذ. [1] يتحمل السلوك المحافظ لشبكات الداما المحافظة من النوع الثابت عند التقييم إلى FALSE بشكل غير منتظم: يمكن لمس المدقق من نوع ثابت اكتشاف أخطاء الكتابة في مسارات التعليمات البرمجية نادرا ما تستخدم. بدون التحقق من نوع ثابت، حتى اختبارات تغطية الكود مع تغطية الكود 100٪ قد تكون غير قادرة على العثور على هذه الأخطاء من النوع. قد تفشل اختبارات تغطية التعليمات البرمجية في اكتشاف أخطاء النوع هذه لأن مجموعة من جميع الأماكن التي يتم فيها إنشاء القيم وكل الأماكن التي يتم فيها استخدام قيمة معينة في الاعتبار.

الأكثر استخداما على نطاق واسع اللغات المكتوبة ثابتة لا تكتب بشكل رسمي. لديهم "الثغرات" في مواصفات لغة البرمجة تمكن المبرمجين لكتابة التعليمات البرمجية التي يتحتاج إلى التحقق من التحقق من قبل مدقق نوع ثابت وعالج مجموعة واسعة من المشاكل. على سبيل المثال، تحتوي Java ومعظم لغات أسلوب C على نوع Punning، ويحتوي Haskell على هذه الميزات مثل Unsafeperformio: قد تكون هذه العمليات غير آمنة في وقت التشغيل، حيث يمكن أن تسبب سلوك غير مرغوب فيه بسبب كتابة القيم غير صحيحة عند تشغيل البرنامج.

الطباعة الديناميكية

يقال إن لغة البرمجة مكتوبة ديناميكيا، أو فقط "ديناميكية"، عندما يتم تنفيذ غالبية فحص الكتابة في وقت التشغيل بدلا من وقت الترجمة. في الكتابة الديناميكية، ترتبط الأنواع بالقيم غير المتغيرات. تشمل اللغات المكتوبة ديناميكيا Groovy، JavaScript، LISP، LUA، الهدف، PERL (فيما يتعلق بأنواع المعرفة من قبل المستخدم ولكنها ليست مضمنة في الأنواع)، PHP، Prolog، Python، Ruby، Smalltalk و TCL. بالمقارنة مع الكتابة الثابتة، يمكن أن يكون الكتابة الديناميكية أكثر مرونة (على سبيل المثال عن طريق السماح ببرامج لتوليد أنواعها ووظائفها بناء على بيانات وقت التشغيل)، على الرغم من حساب عدد أقل من الضمانات البسيطة. وذلك لأن لغة مكتوبة ديناميكيا تقبل ومحاولات تنفيذ بعض البرامج التي قد يتم استبعادها غير صالحة بواسطة مدقق نوع ثابت.

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

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

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

مراجع

بيرس، بنيامين (2002). أنواع لغات البرمجة. ماساتشوستس للتكنولوجيا الصحافة. ISBN 0-262-16209-1.

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

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

ومع ذلك، كان علينا زيادة حساب التفاضل والتكامل Lambda غير المصمم بأرقام بدائية وعمليات حسابية، ثم يمكننا إجراء عمليات نونية، مثل إضافة شرطين لامبادا معا: (λx.x) + (λy.y). وبعد يمكن للمرء أن يجادل أن الشيء العاقل الوحيد الذي يجب القيام به هو الإشارة إلى وجود خطأ عند حدوث ذلك، ولكن يجب أن تكون قادرا على القيام بذلك، يجب وضع علامة كل قيمة بمؤشر يشير إلى ما إذا كان المصطلح مصطلح لامدا أو رقم. سيقوم مشغل الإضافة بعد ذلك بفحص ذلك في الواقع يتم وضع علامة على كلا الحجج كأرقام، وإذا لم تكن كذلك، فأشارة خطأ. لاحظ أن هذه العلامات هي ليس أنواع، لأن الأنواع هي خصائص للبرامج، وليس القيم التي تنتجها تلك البرامج.

لغة مكتوبة UNI التي يتم استدعاءها بشكل حيوي.

لغات مثل JavaScript، Python، و Ruby هي جميعها تمت كتابتها UNI. مرة أخرى، typeof المشغل في جافا سكريبت و type وظيفة في بيثون لها أسماء مضللة؛ يعيدون العلامات المرتبطة بالعملية وليس أنواعها. بصورة مماثلة، dynamic_cast في C ++ و instanceof في جافا تفعل ليس تفعل نوع الشيكات.

مترجمة مقابل

"عند ترجم التعليمات البرمجية المصدر"

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

طباعة

"عندما يتم فحص أنواع"

5 + '3' هو مثال لخطأ نوع في كتبت بقوة لغات مثل GO و Python، لأنها لا تسمح ب "نوع الإكراه" -> القدرة على قيمة تغيير النوع في سياقات معينة مثل دمج نوعين. مكتوبة ضعيفة اللغات، مثل JavaScript، لن ترمي خطأ من النوع (النتائج في '53').

ثابتة: فحص أنواع قبل وقت التشغيل
متحرك: أنواع فحصها على الطيران، أثناء التنفيذ

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

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

مثال على مثال بثون

ديناميكية، تفسيرها

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

silly(2)

نظرا لأن Python مفسر ومكتبتين ديناميكيا، فإنه يترجم فقط رمز الشيكات والكتب الذي يتم تنفيذه. ال else كتلة لا تنفذ أبدا، لذلك 5 + '3' لم ينظر حتى الآن!

ماذا لو كانت مكتوبة قانونيا؟

سيتم إلقاء خطأ نوع قبل تشغيل الرمز. لا يزال يؤدي التحقق من النوع قبل وقت التشغيل على الرغم من أنه يتم تفسيره.

ماذا لو تم تجميعها؟

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

اذهب

ثابت، جمعت

package main

import ("fmt"
)

func silly(a int) {
  if (a > 0) {
      fmt.Println("Hi")
  } else {
      fmt.Println("3" + 5)
  }
}

func main() {
  silly(2)
}

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

أداء

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

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

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

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