ما هو المفسر (Interpreter)؟

اكتب python3 hello.py فيظهر الناتج، لكن انظر في المجلد بعد ذلك: لم يُنشأ أي ملف برنامج جديد. البرنامج الذي عمل فعلًا هو python3 نفسه، أي مفسر Python. قرأ hello.py، وفهم معنى كل تعليمة، ونفّذها. شغّل السكربت مجددًا غدًا وسيقرأ المفسر الكود المصدري من البداية مرة أخرى.

كيف يعمل المفسر

يكرّر المفسر دورة واحدة حتى ينتهي البرنامج: خذ التعليمة التالية، افهم معناها، نفّذها، ثم انتقل إلى ما بعدها. ويحتفظ بمتغيرات البرنامج في ذاكرته الخاصة أثناء العمل، ولهذا يستطيع total = price * 3 استخدام price الذي أُسند قبل بضعة أسطر.

أوضح طريقة لرؤية ذلك هي الوضع التفاعلي، المسمّى REPL (اقرأ، قيّم، اطبع، كرّر). اكتب python3 بدون اسم ملف، وسيُنفَّذ كل سطر لحظة ضغطك على Enter:

>>> price = 4
>>> price * 3
12

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

import dis

source = "total = price * 3"
code = compile(source, "<example>", "exec")
dis.dis(code)

يطبع Python 3.12 ما يلي (تختلف الإصدارات الأخرى في التفاصيل):

  0           0 RESUME                   0

  1           2 LOAD_NAME                0 (price)
              4 LOAD_CONST               0 (3)
              6 BINARY_OP                5 (*)
             10 STORE_NAME               1 (total)
             12 RETURN_CONST             1 (None)

كل سطر من هذه الأسطر خطوة واحدة في حلقة المفسر: اجلب قيمة price، اجلب الثابت 3، اضربهما، خزّن النتيجة في total. لا شيء من ذلك لغة آلة؛ فالمفسر، وهو نفسه برنامج C مترجَم، هو من ينفّذ كل خطوة.

الأخطاء تظهر عند تنفيذ السطر

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

print("Step 1: starting")
print("Step 2: still fine")
print("Step 3:", 10 / 0)
print("Step 4: never reached")

Step 1: starting
Step 2: still fine
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

أما خطأ الصياغة فيتصرف بشكل مختلف، لأن CPython يترجم الملف كله إلى بايت كود قبل تشغيل أي جزء منه. غيّر السطر 3 إلى print("Step 3:" 10) (الفاصلة ناقصة) ولن يُطبع شيء على الإطلاق، ولا حتى Step 1:

SyntaxError: invalid syntax. Perhaps you forgot a comma?

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

المترجم مقابل المفسر

المترجم يحوّل البرنامج كله إلى ملف منفصل قبل تشغيله. أما المفسر فيشغّل البرنامج نفسه في كل مرة. والفروق العملية تنتج من ذلك:

فارق السرعة حقيقي في الحلقات الحسابية المكثفة: قد تعمل الحلقة نفسها أسرع بمرات كثيرة كبرنامج C مترجَم منها في CPython. أما البرامج التي تقضي معظم وقتها في انتظار الشبكة أو القرص أو المستخدم، فالفارق غالبًا أصغر من أن يُلاحظ.

كون اللغة مترجمة أو مفسرة ليس صفة في اللغة

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

• Python. يترجم CPython إلى بايت كود ثم يفسّره. ويضيف PyPy، وهو تطبيق آخر للغة، مترجم تنفيذ فوري (JIT) يحوّل الكود الأكثر تنفيذًا إلى لغة الآلة أثناء تشغيل البرنامج.
• Java. يترجم javac الكود المصدري إلى بايت كود مسبقًا. ثم تفسّر آلة Java الافتراضية هذا البايت كود، وتترجم الدوال الأكثر استخدامًا إلى لغة الآلة بتقنية JIT. ومنذ Java 11، يشغّل الأمر java Main.java ملفًا مصدريًا واحدًا مباشرة بعد ترجمته في الذاكرة أولًا.
• JavaScript. تستخدم المتصفحات وNode.js محركات مثل V8، تبدأ بتفسير الكود ثم تترجم الأجزاء الأكثر تنفيذًا إلى لغة الآلة أثناء عمل البرنامج.
• C وC++. تُترجَمان دائمًا تقريبًا قبل التشغيل باستخدام GCC أو Clang أو MSVC.

python3 app.py            # Python: interpreter, bytecode behind the scenes
node app.js               # JavaScript: V8 interprets, then JIT-compiles
javac Main.java           # Java step 1: compile to Main.class
java Main                 # Java step 2: the JVM runs the bytecode

وأيًّا كانت الطريقة، فالمفسر أو الآلة الافتراضية جزء من بيئة التشغيل الخاصة بالبرنامج: يجب أن يكون مثبتًا حيثما يعمل البرنامج.

مفاهيم خاطئة شائعة

• "المفسر يترجم كل سطر إلى لغة الآلة." المفسر التقليدي لا يُنتج لغة آلة لبرنامجك أبدًا. إنه يقرأ التعليمة وينفّذها باستخدام كود مترجَم مسبقًا داخل المفسر نفسه. أما إنتاج لغة الآلة وقت التشغيل فهو عمل مترجم JIT.
• "اللغات المفسرة ليس فيها خطوة ترجمة." CPython وYARV الخاص بلغة Ruby وPHP كلها تترجم إلى بايت كود أولًا. الخطوة تلقائية وغير مرئية، لذا يسهل ألا تلاحظها.
• "مفسرة تعني بطيئة." ترجمة JIT قلّصت جزءًا كبيرًا من الفارق. يشغّل V8 لغة JavaScript بسرعة تكفي لتطبيقات كبيرة مثل VS Code المبني على Electron.
• "Python هي المفسر." Python هي اللغة. أما CPython وPyPy وMicroPython فمفسرات مختلفة لها، وقد تختلف في السرعة وفي المكتبات التي تدعمها.

إلى أين بعد ذلك

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