Noteworthy Differences from other Languages

Noteworthy differences from MATLAB

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

• تُستخدم الأقواس المربعة لفهرسة مصفوفات جوليا، A[i,j].

• تُعتبر مصفوفات جوليا غير مُنسَخَة عند تعيينها إلى متغير آخر. بعد A = B، ستؤدي تغييرات العناصر في B إلى تعديل A أيضًا. لتجنب ذلك، استخدم A = copy(B).

• قيم جوليا لا تُنسخ عند تمريرها إلى دالة. إذا قامت دالة بتعديل مصفوفة، ستظهر التغييرات في المتصل.

• جوليا لا تنمو تلقائيًا المصفوفات في عبارة التعيين. بينما في MATLAB a(4) = 3.2 يمكن أن تنشئ المصفوفة a = [0 0 0 3.2] و a(5) = 7 يمكن أن تنمو إلى a = [0 0 0 3.2 7]، فإن العبارة المقابلة في جوليا a[5] = 7 ترمي خطأ إذا كان طول a أقل من 5 أو إذا كانت هذه العبارة هي الاستخدام الأول للمعرف a. تحتوي جوليا على push! و append!، والتي تنمو Vectors بكفاءة أكبر بكثير من a(end+1) = val في MATLAB.

• وحدة التخيل sqrt(-1) تمثل في جوليا كـ im، وليس i أو j كما في MATLAB.

• في جوليا، الأرقام الحرفية بدون نقطة عشرية (مثل 42) تُنشئ أعداد صحيحة بدلاً من أعداد النقطة العائمة. نتيجة لذلك، يمكن أن تؤدي بعض العمليات إلى حدوث خطأ في النطاق إذا كانت تتوقع عددًا عائمًا؛ على سبيل المثال، julia> a = -1; 2^a يؤدي إلى حدوث خطأ في النطاق، حيث أن النتيجة ليست عددًا صحيحًا (انظر the FAQ entry on domain errors لمزيد من التفاصيل).

• في جوليا، يتم إرجاع قيم متعددة وتعيينها كأزواج، مثل (a, b) = (1, 2) أو a, b = 1, 2. لا يوجد ما يعادل nargout في MATLAB، والذي يُستخدم غالبًا في MATLAB للقيام بأعمال اختيارية بناءً على عدد القيم المعادة، في جوليا. بدلاً من ذلك، يمكن للمستخدمين استخدام المعاملات الاختيارية ومعاملات الكلمات الرئيسية لتحقيق قدرات مماثلة.

• جوليا لديها مصفوفات حقيقية ذات بعد واحد. متجهات الأعمدة بحجم N، وليس Nx1. على سبيل المثال، rand(N) تصنع مصفوفة ذات بعد واحد.

• في جوليا، [x,y,z] ستقوم دائمًا بإنشاء مصفوفة مكونة من 3 عناصر تحتوي على x و y و z.

  • لدمج في البعد الأول ("الرأسي") استخدم إما vcat(x,y,z) أو افصل باستخدام الفواصل المنقوطة ([x; y; z]).
  • لدمج في البعد الثاني ("الأفقي") استخدم إما hcat(x,y,z) أو افصل باستخدام المسافات ([x y z]).
  • لإنشاء مصفوفات كتلية (عن طريق الدمج في البعدين الأولين)، استخدم إما hvcat أو اجمع المسافات والفواصل المنقوطة ([a b; c d]).

• في جوليا، a:b و a:b:c ينشئان كائنات من نوع AbstractRange. لإنشاء متجه كامل كما في MATLAB، استخدم collect(a:b). بشكل عام، لا حاجة لاستدعاء collect على الرغم من ذلك. سيتصرف كائن AbstractRange مثل مصفوفة عادية في معظم الحالات ولكنه أكثر كفاءة لأنه يحسب قيمه بشكل كسول. يتم استخدام هذا النمط من إنشاء كائنات متخصصة بدلاً من المصفوفات الكاملة بشكل متكرر، ويظهر أيضًا في وظائف مثل range، أو مع المكررات مثل enumerate و zip. يمكن استخدام الكائنات الخاصة في الغالب كما لو كانت مصفوفات عادية.

• تُعيد الدوال في جوليا القيم من آخر تعبير لها أو من كلمة return بدلاً من سرد أسماء المتغيرات التي يجب إرجاعها في تعريف الدالة (انظر The return Keyword لمزيد من التفاصيل).

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

• في جوليا، يتم تنفيذ التخفيضات مثل sum، prod، و maximum على كل عنصر من عناصر المصفوفة عند استدعائها بحجة واحدة، كما في sum(A)، حتى لو كانت A تحتوي على أكثر من بعد.

• في جوليا، يجب استخدام الأقواس لاستدعاء دالة بدون وسائط، مثل في rand().

• جوليا تنصح بعدم استخدام الفواصل المنقوطة لإنهاء العبارات. نتائج العبارات لا تُطبع تلقائيًا (باستثناء عند الموجه التفاعلي)، ولا تحتاج أسطر الكود إلى أن تنتهي بفواصل منقوطة. println أو @printf يمكن استخدامها لطباعة مخرجات محددة.

• في جوليا، إذا كانت A و B مصفوفات، فإن عمليات المقارنة المنطقية مثل A == B لا ترجع مصفوفة من القيم البوليانية. بدلاً من ذلك، استخدم A .== B، وبالمثل بالنسبة لمشغلات البوليان الأخرى مثل <، >.

• في جوليا، تقوم العوامل &، |، و ⊻ (xor) بتنفيذ العمليات البتية المعادلة لـ and، or، و xor على التوالي في MATLAB، ولها أسبقية مشابهة لعوامل البت في بايثون (على عكس C). يمكنها العمل على القيم الفردية أو بشكل عنصر بعنصر عبر المصفوفات ويمكن استخدامها لدمج المصفوفات المنطقية، لكن لاحظ الفرق في ترتيب العمليات: قد تكون الأقواس مطلوبة (على سبيل المثال، لاختيار العناصر من A التي تساوي 1 أو 2 استخدم (A .== 1) .| (A .== 2)).

• في جوليا، يمكن تمرير عناصر مجموعة كوسائط إلى دالة باستخدام عامل التوسيع ...، كما في xs=[1,2]; f(xs...).

• تُرجع دالة svd في جوليا القيم الفردية كمتجه بدلاً من مصفوفة قطرية كثيفة.

• في جوليا، ... لا يُستخدم لاستكمال أسطر الكود. بدلاً من ذلك، يتم استكمال التعبيرات غير المكتملة تلقائيًا إلى السطر التالي.

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

• لا تدعم structs في جوليا إضافة حقول ديناميكيًا في وقت التشغيل، على عكس classes في ماتلاب. بدلاً من ذلك، استخدم Dict. الـ Dict في جوليا ليس مرتبًا.

• في جوليا، يحتوي كل وحدة على نطاق/مساحة اسم عالمية خاصة بها، بينما في ماتلاب يوجد نطاق عالمي واحد فقط.

• في MATLAB، تعتبر طريقة إلغاء القيم غير المرغوب فيها باستخدام الفهرسة المنطقية، مثل التعبير x(x>3) أو في العبارة x(x>3) = [] لتعديل x في المكان. في المقابل، توفر Julia الدوال ذات الترتيب الأعلى filter و filter!، مما يسمح للمستخدمين بكتابة filter(z->z>3, x) و filter!(z->z>3, x) كبدائل للترجمات المقابلة x[x.>3] و x = x[x.>3]. استخدام 4d61726b646f776e2e436f64652822222c202266696c746572212229_40726566 يقلل من استخدام المصفوفات المؤقتة.

• التماثل لاستخراج (أو "إلغاء الإشارة") جميع عناصر مصفوفة الخلايا، على سبيل المثال في vertcat(A{:}) في MATLAB، يُكتب باستخدام عامل التوسيع في جوليا، على سبيل المثال كـ vcat(A...).

• في جوليا، تقوم دالة adjoint بأداء النقل المرافق؛ في ماتلاب، توفر adjoint "المرافق" أو المرافق الكلاسيكي، وهو النقل للمصفوفة من العوامل.

• في جوليا، يتم تقييم a^b^c كـ a^(b^c) بينما في ماتلاب يكون (a^b)^c.

Noteworthy differences from R

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

• تحتوي علامات الاقتباس المفردة في جوليا على أحرف، وليس سلاسل.

• يمكن لجوليا إنشاء سلاسل فرعية عن طريق الفهرسة في السلاسل. في R، يجب تحويل السلاسل إلى متجهات حرفية قبل إنشاء السلاسل الفرعية.

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

• في جوليا، يتم تحديد المتغيرات المتغيرة باستخدام عامل التوسيع ...، الذي يأتي دائمًا بعد اسم متغير محدد، على عكس R، حيث يمكن أن يحدث ... في عزلة.

• في جوليا، النسبة المئوية هي mod(a, b)، وليس a %% b. % في جوليا هو عامل الباقي.

• تقوم جوليا بإنشاء المتجهات باستخدام الأقواس. [1, 2, 3] في جوليا تعادل c(1, 2, 3) في R.

• في جوليا، ليست جميع هياكل البيانات تدعم الفهرسة المنطقية. علاوة على ذلك، يتم دعم الفهرسة المنطقية في جوليا فقط مع المتجهات التي لها طول يساوي الكائن الذي يتم فهرسته. على سبيل المثال:

  • في R، c(1, 2, 3, 4)[c(TRUE, FALSE)] يعادل c(1, 3).
  • في R، c(1, 2, 3, 4)[c(TRUE, FALSE, TRUE, FALSE)] يعادل c(1, 3).
  • في جوليا، [1, 2, 3, 4][[true, false]] يرمي BoundsError.
  • في جوليا، [1, 2, 3, 4][[true, false, true, false]] ينتج [1, 3].

• مثل العديد من اللغات، لا تسمح جوليا دائمًا بالعمليات على المتجهات ذات الأطوال المختلفة، على عكس R حيث تحتاج المتجهات فقط إلى مشاركة نطاق فهارس مشترك. على سبيل المثال، c(1, 2, 3, 4) + c(1, 2) هو R صالح ولكن المعادل [1, 2, 3, 4] + [1, 2] سيتسبب في حدوث خطأ في جوليا.

• تسمح جوليا بفاصلة اختيارية في النهاية عندما لا تغير تلك الفاصلة معنى الكود. يمكن أن يسبب هذا ارتباكًا بين مستخدمي R عند الفهرسة في المصفوفات. على سبيل المثال، x[1,] في R ستعيد الصف الأول من مصفوفة؛ في جوليا، ومع ذلك، يتم تجاهل الفاصلة، لذا x[1,] == x[1]، وستعيد العنصر الأول. لاستخراج صف، تأكد من استخدام :، كما في x[1,:].

• تأخذ دالة map في جوليا الدالة أولاً، ثم المعاملات، على عكس lapply(<structure>, function, ...) في R. وبالمثل، فإن المعادل لجوليا لـ apply(X, MARGIN, FUN, ...) في R هو mapslices حيث تكون الدالة هي المعامل الأول.

• تطبيق متعدد المتغيرات في R، على سبيل المثال mapply(choose, 11:13, 1:3)، يمكن كتابته كـ broadcast(binomial, 11:13, 1:3) في جوليا. وبالمثل، تقدم جوليا صيغة نقطية أقصر لتعميم الدوال binomial.(11:13, 1:3).

• تستخدم جوليا end للدلالة على نهاية كتل الشرط، مثل if، وكتل الحلقات، مثل while/ for، والدوال. بدلاً من جملة if ( cond ) statement ذات السطر الواحد، تسمح جوليا بجمل من الشكل if cond; statement; end، cond && statement و !cond || statement. يجب أن تكون جمل التعيين في الصيغتين الأخيرتين مغلفة صراحةً بين قوسين، مثل cond && (x = value).

• في جوليا، <- و <<- و -> ليست مشغلات تعيين.

• تقوم -> في جوليا بإنشاء دالة مجهولة.

• يمكن لمشغل * في جوليا إجراء ضرب المصفوفات، على عكس R. إذا كانت A و B مصفوفتين، فإن A * B تشير إلى ضرب المصفوفات في جوليا، وهو ما يعادل A %*% B في R. في R، ستؤدي هذه الصيغة نفسها إلى إجراء عملية ضرب عنصرية (هادامارد). للحصول على عملية الضرب العنصري، تحتاج إلى كتابة A .* B في جوليا.

• تقوم جوليا بإجراء تحويل المصفوفات باستخدام دالة transpose والتحويل المرافق باستخدام العامل ' أو دالة adjoint. وبالتالي، فإن transpose(A) في جوليا تعادل t(A) في R. بالإضافة إلى ذلك، يتم توفير تحويل غير تكراري في جوليا بواسطة دالة permutedims.

• جوليا لا تتطلب أقواسًا عند كتابة عبارات if أو حلقات for/while: استخدم for i in [1, 2, 3] بدلاً من for (i in c(1, 2, 3)) و if i == 1 بدلاً من if (i == 1).

• تتعامل جوليا مع الأرقام 0 و 1 على أنهما ليسا من نوع Boolean. لا يمكنك كتابة if (1) في جوليا، لأن جمل if تقبل فقط القيم البوليانية. بدلاً من ذلك، يمكنك كتابة if true، if Bool(1)، أو if 1==1.

• جوليا لا توفر nrow و ncol. بدلاً من ذلك، استخدم size(M, 1) لـ nrow(M) و size(M, 2) لـ ncol(M).

• تولي جوليا اهتمامًا خاصًا لتمييز الأعداد الفردية، والمتجهات، والمصفوفات. في R، 1 و c(1) هما نفس الشيء. في جوليا، لا يمكن استخدامهما بالتبادل.

• جوليا diag و diagm ليستا مثل R.

• لا يمكن لجوليا تعيين نتائج استدعاءات الدوال على الجانب الأيسر من عملية التعيين: لا يمكنك كتابة diag(M) = fill(1, n).

• جوليا تنصح بعدم ملء مساحة الأسماء الرئيسية بالوظائف. معظم الوظائف الإحصائية لجوليا موجودة في packages تحت JuliaStats organization. على سبيل المثال:

  • تُقدّم الدوال المتعلقة بتوزيعات الاحتمالات من قبل Distributions package.
  • يوفر DataFrames package إطارات بيانات.
  • تُقدَّم النماذج الخطية المعممة بواسطة GLM package.

• تقدم جوليا التوائم وجداول التجزئة الحقيقية، ولكن لا تقدم قوائم على طراز R. عند إرجاع عناصر متعددة، يجب عليك عادةً استخدام زوج أو زوج مسمى: بدلاً من list(a = 1, b = 2)، استخدم (1, 2) أو (a=1, b=2).

• تشجع جوليا المستخدمين على كتابة أنواعهم الخاصة، والتي تكون أسهل في الاستخدام من كائنات S3 أو S4 في R. يعني نظام التوزيع المتعدد في جوليا أن table(x::TypeA) و table(x::TypeB) تعمل مثل table.TypeA(x) و table.TypeB(x) في R.

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

• في جوليا، يتم دمج المتجهات والمصفوفات باستخدام hcat، vcat و hvcat، وليس c، rbind و cbind كما في R.

• في جوليا، النطاق مثل a:b ليس اختصارًا لمتجه كما في R، بل هو كائن متخصص من نوع AbstractRange يُستخدم للتكرار. لتحويل النطاق إلى متجه، استخدم collect(a:b).

• يتمتع عامل : بأسبقية مختلفة في R وJulia. على وجه الخصوص، في Julia، تتمتع عوامل الحساب بأسبقية أعلى من عامل :، بينما العكس هو الصحيح في R. على سبيل المثال، 1:n-1 في Julia يعادل 1:(n-1) في R.

• جوليا max و min هما المعادلان لـ pmax و pmin على التوالي في R، لكن يجب أن تكون كلا الحجتين بنفس الأبعاد. بينما maximum و minimum تحل محل max و min في R، هناك اختلافات مهمة.

• تختلف دوال sum، prod، maximum، و minimum في جوليا عن نظيراتها في R. جميعها تقبل وسيط كلمة مفتاحية اختياري dims، الذي يشير إلى الأبعاد التي يتم تنفيذ العملية عليها. على سبيل المثال، دع A = [1 2; 3 4] في جوليا و B <- rbind(c(1,2),c(3,4)) تكون نفس المصفوفة في R. ثم sum(A) يعطي نفس النتيجة مثل sum(B)، لكن sum(A, dims=1) هو متجه صف يحتوي على المجموع عبر كل عمود و sum(A, dims=2) هو متجه عمود يحتوي على المجموع عبر كل صف. هذا يتناقض مع سلوك R، حيث توفر دوال منفصلة colSums(B) و rowSums(B) هذه الوظائف. إذا كان وسيط كلمة dims المفتاحية هو متجه، فإنه يحدد جميع الأبعاد التي يتم فيها تنفيذ المجموع، مع الاحتفاظ بأبعاد المصفوفة المجمعة، على سبيل المثال sum(A, dims=(1,2)) == hcat(10). يجب ملاحظة أنه لا يوجد فحص للأخطاء فيما يتعلق بالوسيط الثاني.

• جوليا لديها العديد من الدوال التي يمكن أن تغير معطياتها. على سبيل المثال، لديها كل من sort و sort!.

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

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

• جوليا لا تدعم نوع NULL. أقرب مكافئ هو nothing، لكنه يتصرف كقيمة عددية بدلاً من كقائمة. استخدم x === nothing بدلاً من is.null(x).

• في جوليا، يتم تمثيل القيم المفقودة بواسطة كائن missing بدلاً من NA. استخدم ismissing(x) (أو ismissing.(x) لعملية عنصر بعنصر على المتجهات) بدلاً من is.na(x). تُستخدم دالة skipmissing بشكل عام بدلاً من na.rm=TRUE (على الرغم من أنه في بعض الحالات الخاصة تأخذ الدوال وسيط skipmissing).

• تفتقر جوليا إلى ما يعادل assign أو get في R.

• في جوليا، return لا تتطلب أقواس.

• في R، تعتبر طريقة إلغاء القيم غير المرغوب فيها طريقة تعبيرية باستخدام الفهرسة المنطقية، مثل التعبير x[x>3] أو في العبارة x = x[x>3] لتعديل x في المكان. في المقابل، توفر Julia الدوال من الدرجة العليا filter و filter!، مما يسمح للمستخدمين بكتابة filter(z->z>3, x) و filter!(z->z>3, x) كبدائل للترجمات المقابلة x[x.>3] و x = x[x.>3]. استخدام 4d61726b646f776e2e436f64652822222c202266696c746572212229_40726566 يقلل من استخدام المصفوفات المؤقتة.

Noteworthy differences from Python

• تُنهي كتل for و if و while في جوليا بكلمة end. مستوى المسافة البادئة ليس له دلالة كما هو الحال في بايثون. على عكس بايثون، لا تحتوي جوليا على كلمة pass.
• تُشير السلاسل النصية إلى علامات الاقتباس المزدوجة ("text") في جوليا (مع ثلاث علامات اقتباس مزدوجة للسلاسل النصية متعددة الأسطر)، بينما في بايثون يمكن الإشارة إليها إما بعلامات اقتباس مفردة ('text') أو علامات اقتباس مزدوجة ("text"). تُستخدم علامات الاقتباس المفردة للأحرف في جوليا ('c').
• ت concatenation السلاسل يتم باستخدام * في جوليا، وليس + كما في بايثون. بشكل مشابه، يتم تكرار السلاسل باستخدام ^، وليس *. الت concatenation الضمني للسلاسل النصية مثلما في بايثون (على سبيل المثال، 'ab' 'cd' == 'abcd') لا يتم في جوليا.
• قوائم بايثون - مرنة ولكن بطيئة - تتوافق مع نوع Vector{Any} في جوليا أو بشكل أكثر عمومية Vector{T} حيث T هو نوع عنصر غير محدد. يمكن تمثيل المصفوفات "السريعة" مثل مصفوفات NumPy التي تخزن العناصر في مكانها (أي أن dtype هو np.float64، [('f1', np.uint64), ('f2', np.int32)]، إلخ) بواسطة Array{T} حيث T هو نوع عنصر محدد وغير قابل للتغيير. يشمل ذلك الأنواع المدمجة مثل Float64، Int32، Int64 ولكن أيضًا أنواع أكثر تعقيدًا مثل Tuple{UInt64,Float64} والعديد من الأنواع المعرفة من قبل المستخدم أيضًا.
• في جوليا، يكون فهرسة المصفوفات والسلاسل النصية، إلخ، مبنية على الرقم 1 وليس 0.
• تتضمن فهرسة الشريحة في جوليا العنصر الأخير، على عكس بايثون. a[2:3] في جوليا هو a[1:3] في بايثون.
• على عكس بايثون، تسمح جوليا AbstractArrays with arbitrary indexes. يجب كتابة التفسير الخاص لبايثون للترتيب السالب، a[-1] و a[-2] كـ a[end] و a[end-1] في جوليا.
• تتطلب جوليا end للفهرسة حتى العنصر الأخير. x[1:] في بايثون يعادل x[2:end] في جوليا.
• في جوليا، : قبل أي كائن ينشئ Symbol أو يقتبس تعبيرًا؛ لذا، x[:5] هو نفسه x[5]. إذا كنت تريد الحصول على أول n عناصر من مصفوفة، فاستخدم فهرسة النطاق.
• تستخدم فهرسة النطاق في جوليا التنسيق x[start:step:stop]، بينما يستخدم بايثون التنسيق x[start:(stop+1):step]. وبالتالي، فإن x[0:10:2] في بايثون يعادل x[1:2:10] في جوليا. وبالمثل، فإن x[::-1] في بايثون، الذي يشير إلى المصفوفة المعكوسة، يعادل x[end:-1:1] في جوليا.
• في جوليا، يمكن إنشاء النطاقات بشكل مستقل كـ start:step:stop، نفس الصيغة التي تستخدم في فهرسة المصفوفات. كما أن دالة range مدعومة أيضًا.
• في جوليا، يشير فهرسة مصفوفة باستخدام مصفوفات مثل X[[1,2], [1,3]] إلى مصفوفة فرعية تحتوي على تقاطعات الصفين الأول والثاني مع العمودين الأول والثالث. في بايثون، X[[1,2], [1,3]] تشير إلى متجه يحتوي على قيم الخلية [1,1] و [2,3] في المصفوفة. X[[1,2], [1,3]] في جوليا يعادل X[np.ix_([0,1],[0,2])] في بايثون. X[[0,1], [0,2]] في بايثون تعادل X[[CartesianIndex(1,1), CartesianIndex(2,3)]] في جوليا.
• جوليا ليس لديها بناء استمرارية الأسطر: إذا كان في نهاية السطر، المدخل حتى الآن هو تعبير كامل، فإنه يعتبر مكتملًا؛ وإلا فإن المدخل يستمر. إحدى الطرق لإجبار تعبير على الاستمرار هي لفه بين قوسين.
• تعتبر مصفوفات جوليا مرتبة حسب الأعمدة (مرتبة وفق فورتران) بينما تعتبر مصفوفات NumPy مرتبة حسب الصفوف (مرتبة وفق C) بشكل افتراضي. للحصول على أداء مثالي عند التكرار على المصفوفات، يجب عكس ترتيب الحلقات في جوليا بالنسبة إلى NumPy (انظر relevant section of Performance Tips).
• تحديثات المشغلين في جوليا (مثل +=، -=، ...) ليست في المكان بينما في NumPy هي كذلك. هذا يعني أن A = [1, 1]; B = A; B += [3, 3] لا يغير القيم في A، بل يعيد ربط الاسم B بنتيجة الجانب الأيمن B = B + 3، وهو مصفوفة جديدة. لاستخدام عملية في المكان، استخدم B .+= 3 (انظر أيضًا dot operators)، الحلقات الصريحة، أو InplaceOps.jl.
• تقوم جوليا بتقييم القيم الافتراضية لوسائط الدالة في كل مرة يتم فيها استدعاء الطريقة، على عكس بايثون حيث يتم تقييم القيم الافتراضية مرة واحدة فقط عند تعريف الدالة. على سبيل المثال، الدالة f(x=rand()) = x تعيد رقمًا عشوائيًا جديدًا في كل مرة يتم استدعاؤها بدون وسيط. من ناحية أخرى، الدالة g(x=[1,2]) = push!(x,3) تعيد [1,2,3] في كل مرة يتم استدعاؤها كـ g().
• في جوليا، يجب تمرير الوسائط الرئيسية باستخدام الكلمات الرئيسية، على عكس بايثون حيث يكون من الممكن عادةً تمريرها بشكل موضعي. إن محاولة تمرير وسيط رئيسي بشكل موضعي تؤدي إلى تغيير توقيع الطريقة مما يؤدي إلى MethodError أو استدعاء الطريقة الخاطئة.
• في جوليا % هو عامل الباقي، بينما في بايثون هو العامل المودول.
• في جوليا، النوع المستخدم عادةً Int يتوافق مع نوع العدد الصحيح الآلي (Int32 أو Int64)، على عكس بايثون، حيث int هو عدد صحيح بطول غير محدد. هذا يعني أنه في جوليا، سيحدث overflow لنوع Int، بحيث 2^64 == 0. إذا كنت بحاجة إلى قيم أكبر، استخدم نوعًا مناسبًا آخر، مثل Int128، BigInt أو نوع نقطة عائمة مثل Float64.
• وحدة التخيل sqrt(-1) تمثل في جوليا كـ im، وليس j كما في بايثون.
• في جوليا، عامل الأس هو ^، وليس ** كما في بايثون.
• تستخدم جوليا nothing من النوع Nothing لتمثيل قيمة فارغة، بينما تستخدم بايثون None من النوع NoneType.
• في جوليا، تعتبر العمليات القياسية على نوع المصفوفة عمليات مصفوفة، بينما في بايثون، تعتبر العمليات القياسية عمليات عنصرية. عندما تكون كل من A و B مصفوفتين، فإن A * B في جوليا ينفذ ضرب المصفوفات، وليس الضرب العنصري كما في بايثون. A * B في جوليا يعادل A @ B في بايثون، بينما A * B في بايثون يعادل A .* B في جوليا.
• يُعيد المشغل المرافق ' في جوليا المرافق لعنصر (تمثيل كسول لعنصر صف)، بينما يُعيد مشغل النقل .T على عنصر في بايثون العنصر الأصلي (غير عملية).
• في جوليا، قد تحتوي الدالة على عدة تنفيذات ملموسة (تسمى طرق)، والتي يتم اختيارها عبر التوزيع المتعدد بناءً على أنواع جميع المعاملات في الاستدعاء، مقارنةً بالدوال في بايثون، التي تحتوي على تنفيذ واحد فقط ولا تحتوي على تعددية الأشكال (على عكس استدعاءات طرق بايثون التي تستخدم بناء جملة مختلف وتسمح بالتوزيع بناءً على المستلم للطريقة).
• لا توجد فصول في جوليا. بدلاً من ذلك، هناك هياكل (قابلة للتغيير أو غير قابلة للتغيير)، تحتوي على بيانات ولكن لا تحتوي على طرق.
• استدعاء طريقة من مثيل فئة في بايثون (x = MyClass(*args); x.f(y)) يتوافق مع استدعاء دالة في جوليا، على سبيل المثال x = MyType(args...); f(x, y). بشكل عام، التوزيع المتعدد أكثر مرونة وقوة من نظام الفئات في بايثون.
• يمكن أن تحتوي هياكل جوليا على نوع واحد مجرد فقط كنوع أعلى، في حين يمكن أن ترث فئات بايثون من واحد أو أكثر (مجردة أو ملموسة) من الفئات العليا.
• هيكل البرنامج المنطقي لجوليا (الحزم والوحدات) مستقل عن هيكل الملفات، في حين أن هيكل كود بايثون محدد من خلال الدلائل (الحزم) والملفات (الوحدات).
• في جوليا، من المعتاد تقسيم نصوص الوحدات الكبيرة إلى ملفات متعددة، دون إدخال وحدة جديدة لكل ملف. يتم إعادة تجميع الكود داخل وحدة واحدة في ملف رئيسي عبر include. بينما المعادل في بايثون (exec) ليس شائعًا لهذا الاستخدام (سوف يقوم بهدوء بتجاوز التعريفات السابقة)، يتم تعريف برامج جوليا كوحدة على مستوى module باستخدام using أو import، والتي سيتم تنفيذها مرة واحدة فقط عند الحاجة لأول مرة - مثل include في بايثون. داخل تلك الوحدات، يتم تحميل الملفات الفردية التي تشكل تلك الوحدة باستخدام include من خلال سردها مرة واحدة بالترتيب المقصود.
• عامل الثلاثي x > 0 ? 1 : -1 في جوليا يتوافق مع تعبير شرطي في بايثون 1 if x > 0 else -1.
• في جوليا، يشير الرمز @ إلى ماكرو، بينما في بايثون يشير إلى ديكور.
• يتم التعامل مع الاستثناءات في جوليا باستخدام try — catch — finally، بدلاً من try — except — finally. على عكس بايثون، لا يُنصح باستخدام معالجة الاستثناءات كجزء من سير العمل العادي في جوليا (مقارنةً ببايثون، جوليا أسرع في تدفق التحكم العادي ولكن أبطأ في التقاط الاستثناءات).
• في جوليا، الحلقات سريعة، ولا حاجة لكتابة كود "موجه نحو المتجهات" لأسباب تتعلق بالأداء.
• كن حذرًا مع المتغيرات العالمية غير الثابتة في جوليا، خاصة في الحلقات الضيقة. نظرًا لأنك يمكنك كتابة كود قريب من المعدن في جوليا (على عكس بايثون)، يمكن أن يكون تأثير المتغيرات العالمية كبيرًا (انظر Performance Tips).
• في جوليا، يتم التقريب والقص بشكل صريح. يجب أن يكون int(3.7) في بايثون هو floor(Int, 3.7) أو Int(floor(3.7)) ويميز عن round(Int, 3.7). ترجع floor(x) و round(x) بمفردهما قيمة صحيحة من نفس نوع x بدلاً من أن ترجع دائمًا Int.
• في جوليا، التحليل صريح. float("3.7") في بايثون سيكون parse(Float64, "3.7") في جوليا.
• في بايثون، يمكن استخدام معظم القيم في السياقات المنطقية (على سبيل المثال، if "a": يعني أن الكتلة التالية يتم تنفيذها، و if "": يعني أنه لا يتم تنفيذها). في جوليا، تحتاج إلى تحويل صريح إلى Bool (على سبيل المثال، if "a" يثير استثناء). إذا كنت تريد اختبار سلسلة غير فارغة في جوليا، يجب أن تكتب صراحة if !isempty(""). ربما من المدهش، في بايثون if "False" و bool("False") كلاهما يقيم إلى True (لأن "False" هي سلسلة غير فارغة)؛ في جوليا، parse(Bool, "false") تعيد false.
• في جوليا، يتم تقديم نطاق محلي جديد بواسطة معظم كتل الشيفرة، بما في ذلك الحلقات و try — catch — finally. لاحظ أن الفهم (القائمة، المولد، إلخ) يقدم نطاقًا محليًا جديدًا في كل من بايثون وجوليا، في حين أن كتل if لا تقدم نطاقًا محليًا جديدًا في كلا اللغتين.

Noteworthy differences from C/C++

• تُستخدم الأقواس المربعة لفهرسة مصفوفات جوليا، ويمكن أن تحتوي على أكثر من بُعد A[i,j]. هذه الصيغة ليست مجرد سكر نحوي للإشارة إلى مؤشر أو عنوان كما في C/C++. انظر the manual entry about array construction.
• في جوليا، يكون فهرسة المصفوفات والسلاسل النصية، إلخ، مبنية على الرقم 1 وليس على الرقم 0.
• المصفوفات في جوليا لا تُنسخ عند تعيينها إلى متغير آخر. بعد A = B، ستؤدي تغييرات العناصر في B إلى تعديل A أيضًا. لا تعمل عوامل التحديث مثل += في المكان، بل هي معادلة لـ A = A + B التي تعيد ربط الجانب الأيسر بنتيجة تعبير الجانب الأيمن.
• تعتبر مصفوفات جوليا مرتبة حسب الأعمدة (مرتبة وفقًا لفورتران) بينما تكون مصفوفات C/C++ مرتبة حسب الصفوف بشكل افتراضي. للحصول على أداء مثالي عند التكرار على المصفوفات، يجب عكس ترتيب الحلقات في جوليا مقارنةً بـ C/C++ (انظر relevant section of Performance Tips).
• لا تُنسخ قيم جوليا عند تعيينها أو تمريرها إلى دالة. إذا قامت دالة بتعديل مصفوفة، فستكون التغييرات مرئية في المتصل.
• في جوليا، المسافات البيضاء لها دلالة، على عكس C/C++، لذا يجب توخي الحذر عند إضافة/إزالة المسافات البيضاء من برنامج جوليا.
• في جوليا، الأرقام الحرفية بدون نقطة عشرية (مثل 42) تُنشئ أعداد صحيحة موقعة، من النوع Int، ولكن الحروف التي تكون كبيرة جدًا بحيث لا تتناسب مع حجم كلمة الآلة سيتم ترقيتها تلقائيًا إلى نوع أكبر، مثل Int64 (إذا كان Int هو Int32)، أو Int128، أو النوع الكبير بشكل تعسفي BigInt. لا توجد لاحقات حرفية عددية، مثل L، LL، U، UL، ULL للإشارة إلى الموقعة و/أو غير الموقعة. الأعداد العشرية دائمًا موقعة، والأعداد السداسية عشر (التي تبدأ بـ 0x مثل C/C++)، غير موقعة، ما لم تكن تشفر أكثر من 128 بت، وفي هذه الحالة تكون من النوع BigInt. الأعداد السداسية عشر أيضًا، على عكس C/C++/Java وعلى عكس الأعداد العشرية في جوليا، لها نوع يعتمد على طول الحرف، بما في ذلك الأصفار البادئة. على سبيل المثال، 0x0 و 0x00 لهما نوع UInt8، و 0x000 و 0x0000 لهما نوع UInt16، ثم الحروف التي تحتوي على 5 إلى 8 أرقام سداسية عشر لها نوع UInt32، و9 إلى 16 رقم سداسي عشر نوع UInt64، و17 إلى 32 رقم سداسي عشر نوع UInt128، وأكثر من 32 رقم سداسي عشر نوع BigInt. يجب أخذ ذلك في الاعتبار عند تعريف الأقنعة السداسية عشر، على سبيل المثال ~0xf == 0xf0 يختلف كثيرًا عن ~0x000f == 0xfff0. يتم التعبير عن الأعداد العائمة 64 بت Float64 و32 بت Float32 كـ 1.0 و 1.0f0 على التوالي. يتم تقريب الأعداد العائمة (وليس ترقيتها إلى نوع BigFloat) إذا لم يكن بالإمكان تمثيلها بدقة. الأعداد العائمة أقرب في السلوك إلى C/C++. الأعداد الثمانية (المقدمة بـ 0o) والأعداد الثنائية (المقدمة بـ 0b) تُعامل أيضًا كغير موقعة (أو BigInt لأكثر من 128 بت).
• في جوليا، يُرجع عامل القسمة / رقمًا عشريًا عندما يكون كلا العاملين من نوع صحيح. لأداء القسمة الصحيحة، استخدم div أو ÷.
• فهرسة Array باستخدام أنواع النقاط العائمة تعتبر عادةً خطأ في جوليا. المعادل لجملة C a[i / 2] في جوليا هو a[i ÷ 2 + 1]، حيث أن i من نوع صحيح.
• يمكن تحديد السلاسل النصية باستخدام إما " أو """، يمكن أن تحتوي السلاسل المحددة بـ """ على أحرف " دون الحاجة إلى اقتباسها مثل "\"" . يمكن أن تحتوي السلاسل النصية على قيم متغيرات أخرى أو تعبيرات مدمجة فيها، مما يشير إليه $variablename أو $(expression)، والذي يقوم بتقييم اسم المتغير أو التعبير في سياق الدالة.
• // يشير إلى رقم Rational، وليس تعليقًا من سطر واحد (الذي هو # في جوليا)
• #= يشير إلى بداية تعليق متعدد الأسطر، و =# ينهيه.
• تُعيد الدوال في جوليا القيم من آخر تعبير (أو تعبيرات) لها أو من الكلمة الرئيسية return. يمكن إرجاع قيم متعددة من الدوال وتعيينها كأزواج مرتبة، على سبيل المثال (a, b) = myfunction() أو a, b = myfunction()، بدلاً من الاضطرار إلى تمرير مؤشرات للقيم كما يتعين القيام به في C/C++ (أي a = myfunction(&b)).
• جوليا لا تتطلب استخدام الفواصل المنقوطة لإنهاء العبارات. نتائج التعبيرات لا تُطبع تلقائيًا (باستثناء عند الموجه التفاعلي، أي REPL)، ولا تحتاج أسطر الكود إلى الانتهاء بفواصل منقوطة. println أو @printf يمكن استخدامها لطباعة مخرجات محددة. في REPL، يمكن استخدام ; لكتم المخرجات. ; لها أيضًا معنى مختلف داخل [ ]، وهو شيء يجب الانتباه له. يمكن استخدام ; لفصل التعبيرات في سطر واحد، لكنها ليست ضرورية بشكل صارم في العديد من الحالات، وهي أكثر مساعدة في تحسين القراءة.
• في جوليا، يقوم العامل ⊻ (xor) بتنفيذ عملية XOR بت bitwise، أي ^ في C/C++. أيضًا، لا تمتلك عوامل التشغيل بت bitwise نفس أسبقية C/C++، لذا قد تكون الأقواس مطلوبة.
• جوليا ^ هو الأس (pow)، وليس XOR بت bitwise كما في C/C++ (استخدم ⊻، أو xor، في جوليا)
• تحتوي جوليا على عمليتي إزاحة لليمين، >> و >>>. تقوم >> بإجراء إزاحة حسابية، بينما تقوم >>> دائمًا بإجراء إزاحة منطقية، على عكس C/C++، حيث يعتمد معنى >> على نوع القيمة التي يتم إزاحتها.
• تقوم -> في جوليا بإنشاء دالة مجهولة، ولا تصل إلى عضو عبر مؤشر.
• جوليا لا تتطلب أقواسًا عند كتابة عبارات if أو حلقات for/while: استخدم for i in [1, 2, 3] بدلاً من for (int i=1; i <= 3; i++) و if i == 1 بدلاً من if (i == 1).
• تتعامل جوليا مع الأرقام 0 و 1 على أنهما ليسا من نوع Boolean. لا يمكنك كتابة if (1) في جوليا، لأن جمل if تقبل فقط القيم البوليانية. بدلاً من ذلك، يمكنك كتابة if true، if Bool(1)، أو if 1==1.
• تستخدم جوليا end للدلالة على نهاية كتل الشرط، مثل if، وكتل الحلقات، مثل while/ for، والدوال. بدلاً من جملة if ( cond ) statement ذات السطر الواحد، تسمح جوليا بجمل من الشكل if cond; statement; end، cond && statement و !cond || statement. يجب أن تكون جمل التعيين في الصيغتين الأخيرتين مغلفة صراحةً بين قوسين، مثل cond && (x = value)، بسبب أسبقية العمليات.
• جوليا ليس لديها بناء استمرارية الأسطر: إذا كان في نهاية السطر، التعبير المدخل حتى الآن هو تعبير كامل، فإنه يعتبر مكتملًا؛ وإلا فإن الإدخال يستمر. إحدى الطرق لإجبار التعبير على الاستمرار هي لفه بين قوسين.
• تعمل الماكرو في جوليا على التعبيرات المفسرة، بدلاً من نص البرنامج، مما يسمح لها بإجراء تحويلات معقدة على كود جوليا. تبدأ أسماء الماكرو بحرف @، ولها كل من صيغة تشبه الدالة، @mymacro(arg1, arg2, arg3)، وصيغة تشبه العبارة، @mymacro arg1 arg2 arg3. الأشكال قابلة للتبادل؛ الشكل الذي يشبه الدالة مفيد بشكل خاص إذا ظهرت الماكرو داخل تعبير آخر، وغالبًا ما يكون أوضح. غالبًا ما تُستخدم الصيغة التي تشبه العبارة لتوضيح الكتل، كما في بناء for الموزع: @distributed for i in 1:n; #= body =#; end. حيث قد يكون من غير الواضح نهاية بناء الماكرو، استخدم الشكل الذي يشبه الدالة.
• جوليا لديها نوع تعداد، يتم التعبير عنه باستخدام الماكرو @enum(name, value1, value2, ...) على سبيل المثال: @enum(Fruit, banana=1, apple, pear)
• بموجب الاتفاق، فإن الدوال التي تعدل معطياتها تحتوي على ! في نهاية الاسم، على سبيل المثال push!.
• في C++، بشكل افتراضي، لديك إرسال ثابت، أي أنك بحاجة إلى وضع علامة على دالة كـ virtual، من أجل الحصول على إرسال ديناميكي. من ناحية أخرى، في جوليا، كل دالة "افتراضية" (على الرغم من أن هذا أكثر عمومية من ذلك لأن الدوال يتم إرسالها بناءً على كل نوع من أنواع المعاملات، وليس فقط this، باستخدام قاعدة الإعلان الأكثر تحديدًا).

Julia ⇔ C/C++: Namespaces

• C/C++ namespaces تتوافق تقريبًا مع modules في Julia.

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

• using MyNamespace::myfun (C++) يتوافق تقريبًا مع import MyModule: myfun (Julia).

• using namespace MyNamespace (C++) يتوافق تقريبًا مع using MyModule (Julia)

  • في جوليا، فقط الرموز التي تم تصديرها متاحة للوحدة المستدعية.
  • في C++، العناصر الموجودة فقط في ملفات الرأس (العامة) المضمنة متاحة.

• تحذير: كلمات المفتاح import/using (جوليا) أيضًا تقوم بتحميل الوحدات (انظر أدناه).

• تحذير: import/using (جوليا) يعمل فقط على مستوى النطاق العالمي (modules)

  • في C++، using namespace X يعمل ضمن نطاقات عشوائية (مثل: نطاق الدالة).

Julia ⇔ C/C++: Module loading

• عندما تفكر في "مكتبة" C/C++، فمن المحتمل أنك تبحث عن "حزمة" جوليا.

  • تحذير: غالبًا ما تحتوي مكتبات C/C++ على عدة "وحدات برمجية" بينما تحتوي "حزم" جوليا عادةً على واحدة.
  • تذكير: modules في جوليا هي نطاقات عالمية (ليست بالضرورة "وحدات برمجية").

• بدلاً من بناء/make السكربتات، تستخدم جوليا "بيئات المشاريع" (تسمى أحيانًا "مشروع" أو "بيئة").

  • تحتاج البرامج النصية للبناء فقط للتطبيقات الأكثر تعقيدًا (مثل تلك التي تحتاج إلى تجميع أو تنزيل تنفيذات C/C++).
  • لتطوير تطبيق أو مشروع في جوليا، يمكنك تهيئة دليل الجذر الخاص به كـ "بيئة مشروع"، وتخزين الشيفرة/الحزم الخاصة بالتطبيق هناك. يوفر ذلك تحكمًا جيدًا في تبعيات المشروع، وإمكانية إعادة الإنتاج في المستقبل.
  • تتم إضافة الحزم المتاحة إلى "بيئة المشروع" باستخدام دالة Pkg.add() أو وضع REPL الخاص بـ Pkg. (هذا لا يحمّل الحزمة المذكورة، مع ذلك).
  • قائمة الحزم المتاحة (التبعيات المباشرة) لبيئة المشروع محفوظة في ملف Project.toml.
  • تُولَّد معلومات الاعتماد الكاملة لبيئة المشروع تلقائيًا وتُحفظ في ملف Manifest.toml بواسطة Pkg.resolve().

• الحزم ("وحدات البرمجيات") المتاحة لـ "بيئة المشروع" يتم تحميلها باستخدام import أو using.

  • في C/C++، تستخدم #include <moduleheader> للحصول على إعلانات الكائنات/الدوال، وتربط المكتبات عند بناء البرنامج التنفيذي.
  • في جوليا، استدعاء using/import مرة أخرى يجلب الوحدة الموجودة إلى النطاق، ولكنه لا يقوم بتحميلها مرة أخرى (مشابه لإضافة #pragma once غير القياسي في C/C++).

• مستودعات الحزم المعتمدة على الدليل (جوليا) يمكن جعلها متاحة عن طريق إضافة مسارات المستودعات إلى مصفوفة Base.LOAD_PATH.

  • الحزم من المستودعات المعتمدة على الدليل لا تتطلب أداة Pkg.add() قبل تحميلها باستخدام import أو using. إنها متاحة ببساطة للمشروع.
  • تعتبر مستودعات الحزم المعتمدة على الدليل هي أسرع حل لتطوير مكتبات محلية من "وحدات البرمجيات".

Julia ⇔ C/C++: Assembling modules

• في C/C++، يتم تجميع ملفات .c/.cpp وإضافتها إلى مكتبة باستخدام سكريبتات البناء/make.

  • في جوليا، import [PkgName]/using [PkgName] تعبيرات تقوم بتحميل [PkgName].jl الموجود في الدليل الفرعي [PkgName]/src/ الخاص بالحزمة.
  • بدوره، [PkgName].jl عادةً ما يحمل الملفات المصدرية المرتبطة من خلال استدعاءات إلى include "[someotherfile].jl".

• include "./path/to/somefile.jl" (جوليا) مشابه جدًا لـ #include "./path/to/somefile.jl" (C/C++).

  • ومع ذلك include "..." (جوليا) لا يُستخدم لتضمين ملفات الرأس (غير مطلوب).
  • لا تستخدم include "..." (جوليا) لتحميل الشيفرة من "وحدات البرمجيات" الأخرى (استخدم import/using بدلاً من ذلك).
  • include "path/to/some/module.jl" (جوليا) سيقوم بإنشاء نسخ متعددة من نفس الكود في وحدات مختلفة (مما ينشئ أنواعًا متميزة (وما إلى ذلك) بنفس الأسماء المتطابقة).
  • include "somefile.jl" يُستخدم عادةً لتجميع ملفات متعددة داخل نفس حزمة جوليا ("وحدة البرمجيات"). لذلك، من السهل نسبيًا التأكد من أن الملفات يتم included مرة واحدة فقط (لا يوجد ارتباك بسبب #ifdef).

Julia ⇔ C/C++: Module interface

• C++ تعرض الواجهات باستخدام ملفات ".h"/".hpp" "عامة" بينما تحدد وحدات جوليا modules الرموز المحددة التي تهدف إلى مستخدميها كـ public أو exported.

  • غالبًا ما تضيف وحدات جوليا modules ببساطة وظائف جديدة من خلال إنشاء "طرق" جديدة لدوال موجودة (مثل: Base.push!).
  • لذلك لا يمكن لمطوري حزم جوليا الاعتماد على ملفات الرأس لوثائق الواجهة.
  • تُوصف الواجهات لحزم جوليا عادةً باستخدام سلاسل الوثائق، README.md، صفحات الويب الثابتة، ...

• بعض المطورين يختارون عدم تصدير جميع الرموز المطلوبة لاستخدام حزمة/وحدة معينة، ولكن يجب عليهم مع ذلك وضع علامة على الرموز غير المصدرة التي تواجه المستخدمين على أنها عامة.

  • قد يُتوقع من المستخدمين الوصول إلى هذه المكونات عن طريق تأهيل الوظائف/الهياكل/... باسم الحزمة/الوحدة (مثل: MyModule.run_this_task(...)).

Julia ⇔ C/C++: Quick reference

• The Julia package manager supports registering multiple packages from a single Git repository.<br> * This allows users to house a library of related packages in a single repository.<br> ** Julia registries are primarily designed to provide versioning \& distribution of packages.<br> ** Custom package registries can be used to create a type of module library.

Noteworthy differences from Common Lisp

• تستخدم جوليا الفهرسة القائمة على 1 للمصفوفات بشكل افتراضي، ويمكنها أيضًا التعامل مع index offsets.

• تشارك الدوال والمتغيرات نفس مساحة الأسماء ("Lisp-1").

• هناك نوع Pair، لكنه ليس مخصصًا للاستخدام كـ COMMON-LISP:CONS. يمكن استخدام مجموعات قابلة للتكرار مختلفة بالتبادل في معظم أجزاء اللغة (مثل التمديد، المجموعات، إلخ). تعتبر Tuples الأقرب إلى قوائم Common Lisp لمجموعات قصيرة من العناصر غير المتجانسة. استخدم NamedTuples بدلاً من القوائم المرتبطة. بالنسبة للمجموعات الأكبر من الأنواع المتجانسة، يجب استخدام Arrays و Dicts.

• تتضمن سير العمل النموذجي لجوليا للتجريب أيضًا التلاعب المستمر بالصورة، والذي يتم تنفيذه باستخدام حزمة Revise.jl.

• لأداء أفضل، تفضل جوليا أن تكون العمليات لديها type stability. بينما يقوم Common Lisp بإخفاء العمليات الأساسية عن الآلة، تلتزم جوليا بالاقتراب منها. على سبيل المثال:

  • القسمة الصحيحة باستخدام / دائمًا ما تعيد نتيجة عائمة، حتى لو كانت الحسابات دقيقة.

    • // دائمًا ما يُرجع نتيجة عقلانية
    • ÷ دائمًا ما يُرجع نتيجة صحيحة (مقصوصة)

  • تدعم الأعداد الكبيرة، لكن التحويل ليس تلقائيًا؛ الأعداد الصحيحة العادية overflow.

  • الأعداد المركبة مدعومة، ولكن للحصول على نتائج مركبة، you need complex inputs.

  • هناك أنواع متعددة من الأنواع المركبة والعددية، مع أنواع مكونات مختلفة.

• يمكن أن تكون الوحدات (المساحات الاسمية) هرمية. import و using لهما دور مزدوج: حيث يقومان بتحميل الكود وجعله متاحًا في المساحة الاسمية. من الممكن استخدام import لاسم الوحدة فقط (ما يعادل تقريبًا ASDF:LOAD-OP). لا تحتاج أسماء الفتحات إلى أن يتم تصديرها بشكل منفصل. لا يمكن تعيين المتغيرات العالمية من خارج الوحدة (باستثناء استخدام eval(mod, :(var = val)) كوسيلة للهروب).

• تبدأ الماكروز بـ @، وهي ليست مدمجة بسلاسة في اللغة مثل Common Lisp؛ وبالتالي، فإن استخدام الماكروز ليس شائعًا كما هو الحال في الأخيرة. تدعم اللغة شكلًا من أشكال النظافة لـ macros. بسبب اختلاف بناء الجملة السطحي، لا يوجد ما يعادل COMMON-LISP:&BODY.

• جميع الدوال عامة وتستخدم التوزيع المتعدد. لا يتعين أن تتبع قوائم المعاملات نفس القالب، مما يؤدي إلى أسلوب قوي (انظر do). يتم التعامل مع المعاملات الاختيارية ومعاملات الكلمات الرئيسية بشكل مختلف. لا يتم حل التداخلات في الطرق كما هو الحال في نظام كائنات Common Lisp، مما يستلزم تعريف طريقة أكثر تحديدًا للتقاطع.

• الرموز لا تنتمي إلى أي حزمة، ولا تحتوي على أي قيم في حد ذاتها. M.var يقيم الرمز var في الوحدة M.

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