Essentials

exit(code=0)

أوقف البرنامج مع رمز خروج. رمز الخروج الافتراضي هو صفر، مما يدل على أن البرنامج اكتمل بنجاح. في جلسة تفاعلية، يمكن استدعاء exit() باستخدام اختصار لوحة المفاتيح ^D.

atexit(f)

قم بتسجيل دالة ذات صفر أو واحد من المعاملات f() ليتم استدعاؤها عند خروج العملية. يتم استدعاء روابط atexit() بترتيب آخر في أول خارج (LIFO) وتعمل قبل المنهيات الخاصة بالكائنات.

إذا كانت هناك طريقة معرفة لـ f تأخذ معامل صحيح واحد، فسيتم استدعاؤها كـ f(n::Int32)، حيث n هو رمز الخروج الحالي، وإلا سيتم استدعاؤها كـ f().

يسمح لروابط الخروج باستدعاء exit(n)، وفي هذه الحالة ستخرج Julia برمز الخروج n (بدلاً من رمز الخروج الأصلي). إذا استدعت أكثر من رابط خروج exit(n)، فستخرج Julia برمز الخروج الذي يتوافق مع آخر رابط خروج تم استدعاؤه والذي يستدعي exit(n). (نظرًا لأن روابط الخروج تُستدعى بترتيب LIFO، فإن "آخر استدعاء" يعادل "الأول المسجل").

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

isinteractive() -> Bool

حدد ما إذا كانت جوليا تعمل في جلسة تفاعلية.

Base.summarysize(obj; exclude=Union{...}, chargeall=Union{...}) -> Int

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

الوسائط الرئيسية

• exclude: يحدد أنواع الكائنات التي يجب استبعادها من التجوال.
• chargeall: يحدد أنواع الكائنات التي يجب دائمًا احتساب حجم جميع حقولها، حتى لو كانت تلك الحقول ستستبعد عادةً.

انظر أيضًا sizeof.

أمثلة

julia> Base.summarysize(1.0)
8

julia> Base.summarysize(Ref(rand(100)))
848

julia> sizeof(Ref(rand(100)))
8

__precompile__(isprecompilable::Bool)

حدد ما إذا كان الملف الذي يستدعي هذه الدالة قابلًا للتجميع المسبق، مع الافتراضي إلى true. إذا كان الوحدة أو الملف ليس قابلًا للتجميع المسبق بشكل آمن، يجب أن يستدعي __precompile__(false) من أجل إلقاء خطأ إذا حاولت جوليا تجميعه مسبقًا.

Base.include([mapexpr::Function,] m::Module, path::AbstractString)

قم بتقييم محتويات ملف المصدر المدخل في النطاق العالمي للوحدة m. كل وحدة (باستثناء تلك المعرفة باستخدام baremodule) لديها تعريف خاص بها لـ include مع حذف وسيط m، والذي يقوم بتقييم الملف في تلك الوحدة. يُرجع نتيجة آخر تعبير تم تقييمه من ملف الإدخال. أثناء التضمين، يتم تعيين مسار تضمين محلي للمهمة إلى الدليل الذي يحتوي على الملف. ستبحث المكالمات المتداخلة لـ include بالنسبة لذلك المسار. تُستخدم هذه الوظيفة عادةً لتحميل المصدر بشكل تفاعلي، أو لدمج الملفات في الحزم التي تم تقسيمها إلى ملفات مصدر متعددة.

يمكن استخدام الوسيط الأول الاختياري mapexpr لتحويل الكود المضمن قبل تقييمه: لكل تعبير تم تحليله expr في path، تقوم وظيفة include فعليًا بتقييم mapexpr(expr). إذا تم حذفها، فإن mapexpr الافتراضي هو identity.

include([mapexpr::Function,] path::AbstractString)

قم بتقييم محتويات ملف المصدر المدخل في النطاق العالمي للوحدة المحتوية. كل وحدة (باستثناء تلك المعرفة باستخدام baremodule) لديها تعريف خاص بها لـ include، والذي يقوم بتقييم الملف في تلك الوحدة. يُرجع نتيجة آخر تعبير تم تقييمه في ملف الإدخال. أثناء التضمين، يتم تعيين مسار تضمين محلي للمهمة إلى الدليل الذي يحتوي على الملف. ستبحث الاستدعاءات المتداخلة لـ include بالنسبة لذلك المسار. تُستخدم هذه الوظيفة عادةً لتحميل المصدر بشكل تفاعلي، أو لدمج الملفات في الحزم التي تم تقسيمها إلى ملفات مصدر متعددة. يتم تطبيع الوسيطة path باستخدام normpath والتي ستحل رموز المسار النسبية مثل .. وتحول / إلى فاصل المسار المناسب.

يمكن استخدام الوسيطة الأولى الاختيارية mapexpr لتحويل الكود المضمن قبل تقييمه: لكل تعبير تم تحليله expr في path، تقوم وظيفة include فعليًا بتقييم mapexpr(expr). إذا تم حذفها، فإن mapexpr الافتراضي هو identity.

استخدم Base.include لتقييم ملف في وحدة أخرى.

include_string([mapexpr::Function,] m::Module, code::AbstractString, filename::AbstractString="string")

مثل include، باستثناء أنه يقرأ الكود من السلسلة المعطاة بدلاً من ملف.

يمكن استخدام الوسيط الأول الاختياري mapexpr لتحويل الكود المضمن قبل تقييمه: لكل تعبير تم تحليله expr في code، تقوم دالة include_string فعليًا بتقييم mapexpr(expr). إذا تم حذفها، فإن mapexpr يكون افتراضيًا على identity.

include_dependency(path::AbstractString; track_content::Bool=true)

في وحدة، أعلن أن الملف أو الدليل أو الرابط الرمزي المحدد بواسطة path (نسبي أو مطلق) هو اعتماد للتجميع المسبق؛ أي، إذا كان track_content=true، ستحتاج الوحدة إلى إعادة التجميع إذا تغير محتوى path (إذا كان path دليلاً، فإن المحتوى يساوي join(readdir(path))). إذا كان track_content=false، يتم تفعيل إعادة التجميع عندما يتغير وقت التعديل mtime لـ path.

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

__init__

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

أمثلة

const foo_data_ptr = Ref{Ptr{Cvoid}}(0)
function __init__()
    ccall((:foo_init, :libfoo), Cvoid, ())
    foo_data_ptr[] = ccall((:foo_data, :libfoo), Ptr{Cvoid}, ())
    nothing
end

which(f, types)

يُرجع الطريقة لـ f (كائن Method) التي سيتم استدعاؤها للوسائط من الأنواع المعطاة types.

إذا كانت types نوعًا مجردًا، فسيتم إرجاع الطريقة التي سيتم استدعاؤها بواسطة invoke.

انظر أيضًا: parentmodule, @which، و @edit.

methods(f, [types], [module])

ارجع جدول الطرق لـ f.

إذا تم تحديد types، ارجع مصفوفة من الطرق التي تتطابق أنواعها. إذا تم تحديد module، ارجع مصفوفة من الطرق المعرفة في تلك الوحدة. يمكن أيضًا تحديد قائمة من الوحدات كمصفوفة.

انظر أيضًا: which، @which و methodswith.

@show exs...

يظهر تعبيرًا أو أكثر، ونتائجها، إلى stdout، ويعيد آخر نتيجة.

انظر أيضًا: show، @info، println.

أمثلة

julia> x = @show 1+2
1 + 2 = 3
3

julia> @show x^2 x/2;
x ^ 2 = 9
x / 2 = 1.5

ans

متغير يشير إلى آخر قيمة تم حسابها، يتم استيراده تلقائيًا إلى موجه التفاعل.

err

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

active_project()

إرجاع مسار ملف Project.toml النشط. انظر أيضًا Base.set_active_project.

set_active_project(projfile::Union{AbstractString,Nothing})

قم بتعيين ملف Project.toml النشط إلى projfile. انظر أيضًا Base.active_project.

module

module يعلن عن Module، وهو مساحة عمل متغيرة عالمية منفصلة. داخل وحدة، يمكنك التحكم في الأسماء من الوحدات الأخرى التي تكون مرئية (عبر الاستيراد)، وتحديد أي من أسمائك مقصود بها أن تكون عامة (عبر export و public). تسمح لك الوحدات بإنشاء تعريفات على المستوى الأعلى دون القلق بشأن تعارض الأسماء عندما يتم استخدام كودك مع كود شخص آخر. راجع قسم الدليل حول الوحدات لمزيد من التفاصيل.

أمثلة

module Foo
import Base.show
export MyType, foo

struct MyType
    x
end

bar(x) = 2x
foo(a::MyType) = bar(a.x) + 1
show(io::IO, a::MyType) = print(io, "MyType $(a.x)")
end

export

export يُستخدم داخل الوحدات لإخبار جوليا بأي الأسماء يجب أن تكون متاحة للمستخدم. على سبيل المثال: export foo يجعل الاسم foo متاحًا عند using الوحدة. راجع قسم الدليل حول الوحدات للحصول على التفاصيل.

public

public يُستخدم داخل الوحدات لإخبار جوليا بأي الأسماء هي جزء من واجهة برمجة التطبيقات العامة للوحدة. على سبيل المثال: public foo تشير إلى أن الاسم foo هو عام، دون جعله متاحًا عند using الوحدة. راجع قسم الدليل حول الوحدات للحصول على التفاصيل.

import

import Foo سيقوم بتحميل الوحدة أو الحزمة Foo. يمكن الوصول إلى الأسماء من الوحدة المستوردة Foo باستخدام صيغة النقطة (على سبيل المثال Foo.foo للوصول إلى الاسم foo). راجع القسم الخاص بالوحدات للحصول على التفاصيل.

using

using Foo سيقوم بتحميل الوحدة أو الحزمة Foo ويجعل أسماءها export متاحة للاستخدام المباشر. يمكن أيضًا استخدام الأسماء عبر بناء جملة النقطة (على سبيل المثال Foo.foo للوصول إلى الاسم foo)، سواء كانت exported أم لا. راجع قسم الدليل حول الوحدات للحصول على التفاصيل.

as

as يُستخدم ككلمة رئيسية لإعادة تسمية مُعرف تم جلبه إلى النطاق بواسطة import أو using، بغرض تجاوز تعارض الأسماء وكذلك لتقصير الأسماء. (خارج عبارات import أو using، as ليست كلمة رئيسية ويمكن استخدامها كمُعرف عادي.)

import LinearAlgebra as LA يجلب مكتبة LinearAlgebra القياسية المستوردة إلى النطاق كـ LA.

import LinearAlgebra: eigen as eig, cholesky as chol يجلب طرق eigen و cholesky من LinearAlgebra إلى النطاق كـ eig و chol على التوالي.

as يعمل مع using فقط عندما يتم جلب مُعرفات فردية إلى النطاق. على سبيل المثال، using LinearAlgebra: eigen as eig أو using LinearAlgebra: eigen as eig, cholesky as chol يعمل، لكن using LinearAlgebra as LA هو بناء جملة غير صالح، لأنه غير منطقي إعادة تسمية جميع الأسماء المصدرة من LinearAlgebra إلى LA.

baremodule

baremodule يعلن عن وحدة لا تحتوي على using Base أو تعريفات محلية لـ eval و include. ومع ذلك، فإنه لا يزال يستورد Core. بعبارة أخرى،

module Mod

...

end

يعادل

baremodule Mod

using Base

eval(x) = Core.eval(Mod, x)
include(p) = Base.include(Mod, p)

...

end

function

تُعرَف الدوال باستخدام الكلمة المفتاحية function:

function add(a, b)
    return a + b
end

أو باستخدام صيغة مختصرة:

add(a, b) = a + b

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

macro

macro يُعرّف طريقة لإدراج الشيفرة المُولّدة في برنامج. يقوم الماكرو بربط تسلسل من تعبيرات الوسائط بتعبير مُرجع، ويتم استبدال التعبير الناتج مباشرة في البرنامج في النقطة التي يتم فيها استدعاء الماكرو. تُعتبر الماكروز وسيلة لتشغيل الشيفرة المُولّدة دون الحاجة لاستدعاء eval، حيث تصبح الشيفرة المُولّدة ببساطة جزءًا من البرنامج المحيط. قد تتضمن وسائط الماكرو تعبيرات، قيم حرفية، ورموز. يمكن تعريف الماكروز لعدد متغير من الوسائط (varargs)، لكنها لا تقبل وسائط الكلمات الرئيسية. كل ماكرو يحصل أيضًا بشكل ضمني على الوسائط __source__، التي تحتوي على رقم السطر واسم الملف الذي تم استدعاء الماكرو منه، و __module__، الذي هو الوحدة التي يتم توسيع الماكرو فيها.

راجع قسم الدليل حول Metaprogramming لمزيد من المعلومات حول كيفية كتابة ماكرو.

أمثلة

julia> macro sayhello(name)
           return :( println("Hello, ", $name, "!") )
       end
@sayhello (macro with 1 method)

julia> @sayhello "Charlie"
Hello, Charlie!

julia> macro saylots(x...)
           return :( println("Say: ", $(x...)) )
       end
@saylots (macro with 1 method)

julia> @saylots "hey " "there " "friend"
Say: hey there friend

return

return x يؤدي إلى خروج الدالة المحيطة مبكرًا، مع تمرير القيمة المعطاة x إلى المتصل بها. return بمفردها بدون قيمة تعادل return nothing (انظر nothing).

function compare(a, b)
    a == b && return "equal to"
    a < b ? "less than" : "greater than"
end

بشكل عام، يمكنك وضع عبارة return في أي مكان داخل جسم الدالة، بما في ذلك داخل الحلقات أو الشروط المتداخلة بعمق، ولكن كن حذرًا مع كتل do. على سبيل المثال:

function test1(xs)
    for x in xs
        iseven(x) && return 2x
    end
end

function test2(xs)
    map(xs) do x
        iseven(x) && return 2x
        x
    end
end

في المثال الأول، تقوم عبارة return بالخروج من test1 بمجرد أن تصادف عددًا زوجيًا، لذا فإن test1([5,6,7]) تعيد 12.

قد تتوقع أن المثال الثاني سيتصرف بنفس الطريقة، ولكن في الواقع، فإن return هناك تخرج فقط من الدالة الداخلية (داخل كتلة do) وتعيد قيمة إلى map. لذا فإن test2([5,6,7]) تعيد [5,12,7].

عند استخدامها في تعبير على المستوى الأعلى (أي خارج أي دالة)، فإن return تتسبب في إنهاء التعبير الحالي على المستوى الأعلى بالكامل مبكرًا.

افعل

أنشئ دالة مجهولة ومررها كأول وسيط لاستدعاء دالة. على سبيل المثال:

map(1:10) do x
    2x
end

يعادل map(x->2x, 1:10).

استخدم وسائط متعددة كما يلي:

map(1:10, 11:20) do x, y
    x + y
end

begin

begin...end يدل على كتلة من الشيفرة.

begin
    println("Hello, ")
    println("World!")
end

عادةً لن تكون begin ضرورية، حيث أن الكلمات الرئيسية مثل function و let تبدأ بشكل ضمني كتل الشيفرة. انظر أيضًا ;.

يمكن أيضًا استخدام begin عند الفهرسة لتمثيل الفهرس الأول لمجموعة أو الفهرس الأول بعدد من أبعاد مصفوفة. على سبيل المثال، a[begin] هو العنصر الأول من مصفوفة a.

أمثلة

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> A[begin, :]
2-element Array{Int64,1}:
 1
 2

end

end يشير إلى نهاية كتلة من التعبيرات، على سبيل المثال module، struct، mutable struct، begin، let، for إلخ.

يمكن أيضًا استخدام end عند الفهرسة لتمثيل آخر فهرس لمجموعة أو آخر فهرس بعدد من أبعاد مصفوفة.

أمثلة

julia> A = [1 2; 3 4]
2×2 Array{Int64, 2}:
 1  2
 3  4

julia> A[end, :]
2-element Array{Int64, 1}:
 3
 4

let

تقوم كتل let بإنشاء نطاق صعب جديد وتقديم ارتباطات محلية جديدة بشكل اختياري.

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

let var1 = value1, var2, var3 = value3
    code
end

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

بالمقابل، تقوم كتل begin أيضًا بتجميع تعبيرات متعددة معًا ولكنها لا تقدم نطاقًا أو تحتوي على بناء جملة تعيين خاص.

أمثلة

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

julia> function test_outer_x()
           x = 0
           map(1:3) do _
               x += 1
               return ()->x
           end
       end
test_outer_x (generic function with 1 method)

julia> [f() for f in test_outer_x()]
3-element Vector{Int64}:
 3
 3
 3

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

julia> function test_let_x()
           x = 0
           map(1:3) do _
               x += 1
               let x = x
                   return ()->x
               end
           end
       end
test_let_x (generic function with 1 method)

julia> [f() for f in test_let_x()]
3-element Vector{Int64}:
 1
 2
 3

تتصرف جميع الإنشاءات النطاقية التي تقدم متغيرات محلية جديدة بهذه الطريقة عند تشغيلها بشكل متكرر؛ السمة المميزة لـ let هي قدرتها على إعلان locals جديدة بشكل مختصر قد تظلل المتغيرات الخارجية بنفس الاسم. على سبيل المثال، يؤدي استخدام وسيط دالة do مباشرة إلى التقاط ثلاث متغيرات متميزة:

julia> function test_do_x()
           map(1:3) do x
               return ()->x
           end
       end
test_do_x (generic function with 1 method)

julia> [f() for f in test_do_x()]
3-element Vector{Int64}:
 1
 2
 3

if/elseif/else

if/elseif/else يقوم بإجراء تقييم شرطي، مما يسمح لأجزاء من الشيفرة أن تُقيّم أو لا تُقيّم اعتمادًا على قيمة تعبير بولي. إليك بنية صياغة الشرط if/elseif/else:

if x < y
    println("x أقل من y")
elseif x > y
    println("x أكبر من y")
else
    println("x يساوي y")
end

إذا كان تعبير الشرط x < y صحيحًا، فإن الكتلة المقابلة تُقيّم؛ وإلا يتم تقييم تعبير الشرط x > y، وإذا كان صحيحًا، يتم تقييم الكتلة المقابلة؛ إذا لم يكن أي من التعبيرين صحيحًا، يتم تقييم كتلة else. كتل elseif و else اختيارية، ويمكن استخدام العديد من كتل elseif كما هو مرغوب.

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

julia> if 1 end
ERROR: TypeError: non-boolean (Int64) used in boolean context

لـ

لـ الحلقات تقيم كتلة من العبارات بشكل متكرر أثناء التكرار على تسلسل من القيم.

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

أمثلة

julia> لـ i في [1, 4, 0]
           println(i)
       end
1
4
0

بينما

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

أمثلة

julia> i = 1
1

julia> بينما i < 5
           println(i)
           global i += 1
       end
1
2
3
4

break

اخرج من الحلقة على الفور.

أمثلة

julia> i = 0
0

julia> while true
           global i += 1
           i > 5 && break
           println(i)
       end
1
2
3
4
5

تابع

تخطى بقية تكرار الحلقة الحالية.

أمثلة

julia> for i = 1:6
           iseven(i) && continue
           println(i)
       end
1
3
5

try/catch

عبارة try/catch تسمح بالتقاط الأخطاء (الاستثناءات) التي يتم طرحها بواسطة throw بحيث يمكن أن تستمر تنفيذ البرنامج. على سبيل المثال، الكود التالي يحاول كتابة ملف، ولكنه يحذر المستخدم ويتابع بدلاً من إنهاء التنفيذ إذا لم يكن بالإمكان كتابة الملف:

try
    open("/danger", "w") do f
        println(f, "Hello")
    end
catch
    @warn "Could not write file."
end

أو، عندما لا يمكن قراءة الملف في متغير:

lines = try
    open("/danger", "r") do f
        readlines(f)
    end
catch
    @warn "File not found."
end

تقوم الصيغة catch e (حيث e هو أي متغير) بتعيين كائن الاستثناء الذي تم طرحه إلى المتغير المعطى داخل كتلة catch.

تكمن قوة بناء try/catch في القدرة على فك حساب متداخل بعمق على الفور إلى مستوى أعلى بكثير في مكدس الدوال المستدعية.

أخيرًا

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

f = open("file")
try
    operate_on_file(f)
finally
    close(f)
end

عندما يغادر التحكم كتلة try (على سبيل المثال، بسبب return، أو مجرد الانتهاء بشكل طبيعي)، سيتم تنفيذ close(f). إذا خرجت كتلة try بسبب استثناء، سيستمر الاستثناء في الانتشار. يمكن دمج كتلة catch مع try و finally أيضًا. في هذه الحالة، ستعمل كتلة finally بعد أن تتعامل catch مع الخطأ.

quote

quote ينشئ كائنات تعبير متعددة في كتلة دون استخدام المُنشئ الصريح Expr. على سبيل المثال:

ex = quote
    x = 1
    y = 2
    x + y
end

على عكس الوسائل الأخرى للاقتباس، :( ... )، هذه الصيغة تُدخل عناصر QuoteNode إلى شجرة التعبير، والتي يجب أخذها في الاعتبار عند التلاعب مباشرة بالشجرة. لأغراض أخرى، يتم التعامل مع :( ... ) و quote .. end ككتل متطابقة.

محلي

محلي يقدم متغير محلي جديد. راجع قسم الدليل حول نطاق المتغيرات لمزيد من المعلومات.

أمثلة

julia> function foo(n)
           x = 0
           for i = 1:n
               local x # تقديم x محلي في الحلقة
               x = i
           end
           x
       end
foo (دالة عامة تحتوي على 1 طريقة)

julia> foo(10)
0

global

global x يجعل x في النطاق الحالي ونطاقاته الداخلية تشير إلى المتغير العالمي بالاسم نفسه. راجع manual section on variable scoping لمزيد من المعلومات.

أمثلة

julia> z = 3
3

julia> function foo()
           global z = 6 # استخدم المتغير z المعرف خارج foo
       end
foo (generic function with 1 method)

julia> foo()
6

julia> z
6

لـ `for outer`

إعادة استخدام متغير محلي موجود للتكرار في حلقة for.

انظر إلى قسم الدليل حول نطاق المتغيرات لمزيد من المعلومات.

انظر أيضًا for.

أمثلة

julia> function f()
           i = 0
           for i = 1:3
               # فارغ
           end
           return i
       end;

julia> f()
0

julia> function f()
           i = 0
           for outer i = 1:3
               # فارغ
           end
           return i
       end;

julia> f()
3

julia> i = 0 # متغير عالمي
       for outer i = 1:3
       end
ERROR: syntax: no outer local variable declaration exists for "for outer"
[...]

const

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

const x = 5

يمكن إعلان متغيرات متعددة ضمن const واحد:

const y, z = 7, 11

لاحظ أن const ينطبق فقط على عملية = واحدة، لذلك const x = y = 1 يُعلن أن x ثابت ولكن ليس y. من ناحية أخرى، const x = const y = 1 يُعلن أن كلا من x و y ثابتين.

لاحظ أن "ثبات" المتغير لا يمتد إلى الحاويات القابلة للتغيير؛ فقط الارتباط بين المتغير وقيمته هو الثابت. إذا كان x مصفوفة أو قاموس (على سبيل المثال) يمكنك still تعديل، إضافة، أو إزالة عناصر.

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

struct

أكثر أنواع البيانات استخدامًا في جوليا هو الهيكل (struct)، الذي يتم تحديده كاسم ومجموعة من الحقول.

struct Point
    x
    y
end

يمكن أن تحتوي الحقول على قيود نوعية، والتي يمكن أن تكون معلمة:

struct Point{X}
    x::X
    y::Float64
end

يمكن أيضًا للهيكل أن يعلن عن نوع سوبر تجريدي عبر بناء جملة <::

struct Point <: AbstractPoint
    x
    y
end

الـ structs غير قابلة للتغيير بشكل افتراضي؛ لا يمكن تعديل مثيل من هذه الأنواع بعد الإنشاء. استخدم mutable struct بدلاً من ذلك للإعلان عن نوع يمكن تعديل مثيلاته.

راجع قسم الدليل حول Composite Types لمزيد من التفاصيل، مثل كيفية تعريف المنشئات.

mutable struct

mutable struct مشابه لـ struct، ولكنه يسمح أيضًا بتعيين حقول النوع بعد الإنشاء.

يمكن وضع علامة على الحقول الفردية في هيكل قابل للتغيير كـ const لجعلها غير قابلة للتغيير:

mutable struct Baz
    a::Int
    const b::Float64
end

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

@kwdef typedef

هذه ماكرو مساعد يقوم تلقائيًا بتعريف مُنشئ يعتمد على الكلمات الرئيسية لنوع البيانات المُعلن عنه في التعبير typedef، والذي يجب أن يكون تعبير struct أو mutable struct. يتم توفير الوسيط الافتراضي عن طريق إعلان الحقول بالشكل field::T = default أو field = default. إذا لم يتم توفير افتراضي، فإن وسيط الكلمة الرئيسية يصبح وسيطًا مطلوبًا في مُنشئ النوع الناتج.

لا يزال يمكن تعريف المُنشئات الداخلية، ولكن يجب أن يقبل واحد على الأقل الوسائط بنفس شكل المُنشئ الداخلي الافتراضي (أي وسيط موضعي واحد لكل حقل) لكي يعمل بشكل صحيح مع المُنشئ الخارجي المعتمد على الكلمات الرئيسية.

أمثلة

julia> @kwdef struct Foo
           a::Int = 1         # الافتراضي المحدد
           b::String          # كلمة رئيسية مطلوبة
       end
Foo

julia> Foo(b="hi")
Foo(1, "hi")

julia> Foo()
ERROR: UndefKeywordError: الوسيط الكلمة الرئيسية `b` غير مُعين
Stacktrace:
[...]

نوع مجرد

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

abstract type Number end
abstract type Real <: Number end

Number ليس له نوع أعلى، بينما Real هو نوع مجرد فرعي من Number.

نوع بدائي

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

primitive type Char 32 end
primitive type Bool <: Integer 8 end

الرقم بعد الاسم يشير إلى عدد بتات التخزين التي يتطلبها النوع. حاليًا، يتم دعم الأحجام التي هي مضاعفات لـ 8 بت فقط. إعلان Bool يظهر كيف يمكن إعلان نوع بدائي ليكون اختياريًا نوعًا فرعيًا من نوع أعلى.

where

تُنشئ الكلمة الرئيسية where نوع UnionAll، والذي يمكن اعتباره اتحادًا متكررًا لأنواع أخرى، على جميع قيم متغير ما. على سبيل المثال، Vector{T} where T<:Real يتضمن جميع Vectors حيث نوع العنصر هو نوع من الأرقام Real.

يكون الحد الافتراضي للمتغير هو Any إذا تم حذفه:

Vector{T} where T    # اختصار لـ `where T<:Any`

يمكن أن تحتوي المتغيرات أيضًا على حدود دنيا:

Vector{T} where T>:Int
Vector{T} where Int<:T<:Real

هناك أيضًا صياغة مختصرة للتعبيرات المتداخلة where. على سبيل المثال، هذا:

Pair{T, S} where S<:Array{T} where T<:Number

يمكن اختصاره إلى:

Pair{T, S} where {T<:Number, S<:Array{T}}

توجد هذه الصيغة غالبًا في توقيعات الطرق.

لاحظ أنه في هذه الصيغة، يتم سرد المتغيرات من الخارج إلى الداخل. يتطابق هذا مع الترتيب الذي يتم فيه استبدال المتغيرات عندما يتم "تطبيق" نوع على قيم المعلمات باستخدام الصيغة T{p1, p2, ...}.

...

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

أمثلة

julia> add(xs...) = reduce(+, xs)
add (generic function with 1 method)

julia> add(1, 2, 3, 4, 5)
15

julia> add([1, 2, 3]...)
6

julia> add(7, 1:100..., 1000:1100...)
111107

;

; له دور مشابه في جوليا كما هو الحال في العديد من لغات C-like، ويستخدم لتحديد نهاية العبارة السابقة.

; ليس ضروريًا في نهاية السطر، ولكن يمكن استخدامه لفصل العبارات في سطر واحد أو لدمج العبارات في تعبير واحد.

إضافة ; في نهاية سطر في REPL ستمنع طباعة نتيجة ذلك التعبير.

في إعلانات الدوال، وبدلاً من ذلك في الاستدعاءات، ; تفصل بين المعاملات العادية والكلمات الرئيسية.

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

يمكن استخدام ; في الموضع الأول داخل الأقواس لإنشاء مجموعة مسماة. نفس بناء الجملة (; ...) على الجانب الأيسر من تعيين يسمح بتفكيك الخصائص.

في REPL القياسي، كتابة ; في سطر فارغ ستبدل إلى وضع الشل.

أمثلة

julia> function foo()
           x = "Hello, "; x *= "World!"
           return x
       end
foo (generic function with 1 method)

julia> bar() = (x = "Hello, Mars!"; return x)
bar (generic function with 1 method)

julia> foo();

julia> bar()
"Hello, Mars!"

julia> function plot(x, y; style="solid", width=1, color="black")
           ###
       end

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> [1; 3;; 2; 4;;; 10*A]
2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  2
 3  4

[:, :, 2] =
 10  20
 30  40

julia> [2; 3;;;]
2×1×1 Array{Int64, 3}:
[:, :, 1] =
 2
 3

julia> nt = (; x=1) # بدون الـ ; أو فاصلة متبقية، سيؤدي هذا إلى تعيين x
(x = 1,)

julia> key = :a; c = 3;

julia> nt2 = (; key => 1, b=2, c, nt.x)
(a = 1, b = 2, c = 3, x = 1)

julia> (; b, x) = nt2; # تعيين المتغيرات b و x باستخدام تفكيك الخصائص

julia> b, x
(2, 1)

julia> ; # عند كتابة ;، يتغير الموجه (في المكان) إلى: shell>
shell> echo hello
hello

=

= هو عامل التعيين.

• بالنسبة للمتغير a والتعبير b، فإن a = b يجعل a تشير إلى قيمة b.
• بالنسبة للدوال f(x)، فإن f(x) = x يحدد دالة جديدة ثابتة f، أو يضيف طريقة جديدة إلى f إذا كانت f معرفة بالفعل؛ هذا الاستخدام يعادل function f(x); x; end.
• a[i] = v يستدعي setindex!(a,v,i).
• a.b = c يستدعي setproperty!(a,:b,c).
• داخل استدعاء دالة، f(a=b) يمرر b كقيمة للوسيط المسمى a.
• داخل الأقواس مع الفواصل، (a=1,) ينشئ NamedTuple.

أمثلة

تعيين a إلى b لا ينشئ نسخة من b؛ بدلاً من ذلك استخدم copy أو deepcopy.

julia> b = [1]; a = b; b[1] = 2; a
1-element Array{Int64, 1}:
 2

julia> b = [1]; a = copy(b); b[1] = 2; a
1-element Array{Int64, 1}:
 1

المجموعات المرسلة إلى الدوال لا تُنسخ أيضًا. يمكن للدوال تعديل (تغيير) محتويات الكائنات التي تشير إليها وسائطها. (أسماء الدوال التي تفعل ذلك تُضاف إليها عادةً علامة '!' في النهاية.)

julia> function f!(x); x[:] .+= 1; end
f! (generic function with 1 method)

julia> a = [1]; f!(a); a
1-element Array{Int64, 1}:
 2

يمكن أن تعمل عملية التعيين على متغيرات متعددة بالتوازي، تأخذ القيم من كائن قابل للتكرار:

julia> a, b = 4, 5
(4, 5)

julia> a, b = 1:3
1:3

julia> a, b
(1, 2)

يمكن أن تعمل عملية التعيين على متغيرات متعددة بالتسلسل، وستعيد قيمة التعبير الأيمن الأكثر:

julia> a = [1]; b = [2]; c = [3]; a = b = c
1-element Array{Int64, 1}:
 3

julia> b[1] = 2; a, b, c
([2], [2], [2])

التعيين في مؤشرات خارج الحدود لا ينمو مجموعة. إذا كانت المجموعة Vector يمكن أن تنمو بدلاً من ذلك باستخدام push! أو append!.

julia> a = [1, 1]; a[3] = 2
ERROR: BoundsError: attempt to access 2-element Array{Int64, 1} at index [3]
[...]

julia> push!(a, 2, 3)
4-element Array{Int64, 1}:
 1
 1
 2
 3

تعيين [] لا يلغي العناصر من مجموعة؛ بدلاً من ذلك استخدم filter!.

julia> a = collect(1:3); a[a .<= 1] = []
ERROR: DimensionMismatch: tried to assign 0 elements to 1 destinations
[...]

julia> filter!(x -> x > 1, a) # in-place & thus more efficient than a = a[a .> 1]
2-element Array{Int64, 1}:
 2
 3

a ? b : c

صيغة مختصرة للشرطيات؛ اقرأ "إذا كان a، قم بتقييم b وإلا قم بتقييم c". يُعرف أيضًا باسم المشغل الثلاثي.

هذه الصيغة تعادل if a; b else c end، ولكن غالبًا ما تُستخدم لتسليط الضوء على القيمة b-أو-c التي تُستخدم كجزء من تعبير أكبر، بدلاً من الآثار الجانبية التي قد تترتب على تقييم b أو c.

راجع قسم الدليل حول تدفق التحكم لمزيد من التفاصيل.

أمثلة

julia> x = 1; y = 2;

julia> x > y ? println("x is larger") : println("x is not larger")
x is not larger

julia> x > y ? "x is larger" : x == y ? "x and y are equal" : "y is larger"
"y is larger"

Main

Main هو الوحدة العليا، ويبدأ جوليا مع تعيين Main كالوحدة الحالية. المتغيرات المعرفة عند الموجه تذهب في Main، و varinfo يسرد المتغيرات في Main.

julia> @__MODULE__
Main

النواة

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

Base

مكتبة الأساس في جوليا. Base هو وحدة تحتوي على الوظائف الأساسية (محتويات base/). جميع الوحدات تحتوي ضمنيًا على using Base، حيث أن هذا مطلوب في الغالبية العظمى من الحالات.

Base.Broadcast

وحدة تحتوي على تنفيذ البث.

المستندات

يوفر نموذج Docs ماكرو @doc الذي يمكن استخدامه لتعيين واسترجاع بيانات التعريف الوثائقية لكائنات جوليا.

يرجى الاطلاع على قسم الدليل حول التوثيق لمزيد من المعلومات.

طرق العمل مع المكررات.

واجهة لـ libc، مكتبة C القياسية.

وظائف ملائمة للبرمجة الميتا.

أدوات لجمع ومعالجة تتبع المكدس. تُستخدم بشكل أساسي لبناء الأخطاء.

قدم طرقًا لاسترجاع المعلومات حول الأجهزة ونظام التشغيل.

دعم تعدد الخيوط.

Base.GC

وحدة تحتوي على أدوات جمع القمامة.

===(x,y) -> Bool
≡(x,y) -> Bool

حدد ما إذا كان x و y متطابقين، بمعنى أنه لا يمكن لأي برنامج تمييزهما. أولاً، تتم مقارنة أنواع x و y. إذا كانت تلك متطابقة، تتم مقارنة الكائنات القابلة للتغيير حسب العنوان في الذاكرة، بينما تتم مقارنة الكائنات غير القابلة للتغيير (مثل الأرقام) حسب المحتويات على مستوى البت. تُسمى هذه الدالة أحيانًا "egal". إنها دائمًا تعيد قيمة Bool.

أمثلة

julia> a = [1, 2]; b = [1, 2];

julia> a == b
true

julia> a === b
false

julia> a === a
true

isa(x, type) -> Bool

حدد ما إذا كان x من النوع المعطى type. يمكن أيضًا استخدامه كعامل بيني، على سبيل المثال x isa type.

أمثلة

julia> isa(1, Int)
true

julia> isa(1, Matrix)
false

julia> isa(1, Char)
false

julia> isa(1, Number)
true

julia> 1 isa Number
true

isequal(x, y) -> Bool

مماثل لـ ==، باستثناء معالجة أرقام النقطة العائمة والقيم المفقودة. تعالج isequal جميع قيم NaN العائمة على أنها متساوية مع بعضها البعض، وتعامل -0.0 على أنها غير متساوية مع 0.0، وmissing على أنها متساوية مع missing. تعيد دائمًا قيمة Bool.

isequal هي علاقة تساوي - فهي انعكاسية (=== تعني isequal)، متناظرة (isequal(a, b) تعني isequal(b, a)) وانتقالية (isequal(a, b) و isequal(b, c) تعني isequal(a, c)).

التنفيذ

تقوم التنفيذ الافتراضي لـ isequal باستدعاء ==، لذا فإن النوع الذي لا يتضمن قيم النقطة العائمة يحتاج عمومًا فقط إلى تعريف ==.

تعتبر isequal دالة المقارنة المستخدمة في جداول التجزئة (Dict). يجب أن تعني isequal(x,y) أن hash(x) == hash(y).

هذا يعني عادةً أن الأنواع التي توجد لها طريقة مخصصة لـ == أو isequal يجب أن تنفذ طريقة hash المقابلة (والعكس صحيح). عادةً ما تنفذ المجموعات isequal عن طريق استدعاء isequal بشكل متكرر على جميع المحتويات.

علاوة على ذلك، ترتبط isequal بـ isless، ويعملان معًا لتعريف ترتيب ثابت كلي، حيث يجب أن يكون واحد فقط من isequal(x, y)، isless(x, y)، أو isless(y, x) هو true (والاثنان الآخران false).

عادةً لا تحتاج الأنواع العددية إلى تنفيذ isequal بشكل منفصل عن ==، ما لم تمثل أرقام النقطة العائمة القابلة لتنفيذ أكثر كفاءة من تلك المقدمة كخيار عام (استنادًا إلى isnan، signbit، و ==).

أمثلة

julia> isequal([1., NaN], [1., NaN])
true

julia> [1., NaN] == [1., NaN]
false

julia> 0.0 == -0.0
true

julia> isequal(0.0, -0.0)
false

julia> missing == missing
missing

julia> isequal(missing, missing)
true

isequal(x)

أنشئ دالة تقارن وسيطها بـ x باستخدام isequal، أي دالة تعادل y -> isequal(y, x).

الدالة المعادة من نوع Base.Fix2{typeof(isequal)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

isless(x, y)

اختبر ما إذا كان x أقل من y، وفقًا لترتيب إجمالي ثابت (محدد مع isequal). isless غير معرف للأزواج (x, y) من جميع الأنواع. ومع ذلك، إذا تم تعريفه، فمن المتوقع أن يفي بما يلي:

• إذا كان isless(x, y) معرفًا، فإن isless(y, x) و isequal(x, y) معرفتان أيضًا، وواحد فقط من تلك الثلاثة يعطي true.
• العلاقة التي يحددها isless هي علاقة انتقالية، أي أن isless(x, y) && isless(y, z) تعني isless(x, z).

القيم التي عادة ما تكون غير مرتبة، مثل NaN، مرتبة بعد القيم العادية. القيم missing مرتبة أخيرًا.

هذا هو المقارنة الافتراضية المستخدمة بواسطة sort!.

التنفيذ

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

أمثلة

julia> isless(1, 3)
true

julia> isless("Red", "Blue")
false

isunordered(x)

ارجع true إذا كان x قيمة لا يمكن ترتيبها وفقًا لـ <، مثل NaN أو missing.

القيم التي تقيم إلى true مع هذه الدالة قد تكون قابلة للترتيب بالنسبة لترتيبات أخرى مثل isless.

ifelse(condition::Bool, x, y)

ارجع x إذا كانت condition true، وإلا ارجع y. هذا يختلف عن ? أو if في أنه دالة عادية، لذا يتم تقييم جميع المعاملات أولاً. في بعض الحالات، يمكن أن يؤدي استخدام ifelse بدلاً من عبارة if إلى القضاء على الفرع في الشيفرة المولدة وتوفير أداء أعلى في الحلقات الضيقة.

أمثلة

julia> ifelse(1 > 2, 1, 2)
2

typeassert(x, type)

ارمي TypeError ما لم يكن x isa type. الصيغة x::type تستدعي هذه الدالة.

أمثلة

julia> typeassert(2.5, Int)
ERROR: TypeError: in typeassert, expected Int64, got a value of type Float64
Stacktrace:
[...]

typeof(x)

احصل على النوع المحدد لـ x.

انظر أيضًا eltype.

أمثلة

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

julia> M = [1 2; 3.5 4];

julia> typeof(M)
Matrix{Float64} (alias for Array{Float64, 2})

tuple(xs...)

قم بإنشاء مجموعة من الكائنات المعطاة.

انظر أيضًا Tuple, ntuple, NamedTuple.

أمثلة

julia> tuple(1, 'b', pi)
(1, 'b', π)

julia> ans === (1, 'b', π)
true

julia> Tuple(Real[1, 2, pi])  # يأخذ مجموعة
(1, 2, π)

ntuple(f, n::Integer)

أنشئ مجموعة بطول n، مع حساب كل عنصر كـ f(i)، حيث i هو فهرس العنصر.

أمثلة

julia> ntuple(i -> 2*i, 4)
(2, 4, 6, 8)

ntuple(f, ::Val{N})

أنشئ مجموعة بطول N، حيث يتم حساب كل عنصر كـ f(i)، حيث i هو فهرس العنصر. من خلال أخذ وسيط Val(N)، من الممكن أن تقوم هذه النسخة من ntuple بتوليد كود أكثر كفاءة من النسخة التي تأخذ الطول كعدد صحيح. ولكن ntuple(f, N) تفضل على ntuple(f, Val(N)) في الحالات التي لا يمكن فيها تحديد N في وقت الترجمة.

أمثلة

julia> ntuple(i -> 2*i, Val(4))
(2, 4, 6, 8)

objectid(x) -> UInt

احصل على قيمة تجزئة لـ x بناءً على هوية الكائن.

إذا كان x === y فإن objectid(x) == objectid(y)، وعادةً عندما x !== y، فإن objectid(x) != objectid(y).

انظر أيضًا hash، IdDict.

hash(x[, h::UInt]) -> UInt

احسب رمز هاش صحيح بحيث isequal(x,y) تعني hash(x)==hash(y). الحجة الثانية الاختيارية h هي رمز هاش آخر ليتم مزجه مع النتيجة.

يجب على الأنواع الجديدة تنفيذ الشكل ذو الحجتين، عادةً عن طريق استدعاء طريقة hash ذات الحجتين بشكل متكرر من أجل مزج هاشات المحتويات مع بعضها البعض (ومع h). عادةً، يجب على أي نوع ينفذ hash أيضًا تنفيذ == الخاصة به (ومن ثم isequal) لضمان الخاصية المذكورة أعلاه.

قد تتغير قيمة الهاش عند بدء عملية جوليا جديدة.

julia> a = hash(10)
0x95ea2955abd45275

julia> hash(10, a) # استخدم فقط ناتج دالة هاش أخرى كالحجة الثانية
0xd42bad54a8575b16

انظر أيضًا: objectid, Dict, Set.

finalizer(f, x)

قم بتسجيل دالة f(x) ليتم استدعاؤها عندما لا توجد مراجع قابلة للوصول من البرنامج إلى x، وأعد x. يجب أن يكون نوع x هو mutable struct، وإلا ستقوم الدالة بإلقاء استثناء.

يجب ألا تتسبب f في تبديل المهام، مما يستبعد معظم عمليات الإدخال/الإخراج مثل println. قد يكون استخدام الماكرو @async (لتأجيل تبديل السياق إلى خارج المنهي) أو ccall لاستدعاء دوال الإدخال/الإخراج في C مباشرة مفيدًا لأغراض التصحيح.

لاحظ أنه لا يوجد عمر عالمي مضمون لتنفيذ f. قد يتم استدعاؤها في العمر العالمي الذي تم فيه تسجيل المنهي أو أي عمر عالمي لاحق.

أمثلة

finalizer(my_mutable_struct) do x
    @async println("Finalizing $x.")
end

finalizer(my_mutable_struct) do x
    ccall(:jl_safe_printf, Cvoid, (Cstring, Cstring), "Finalizing %s.", repr(x))
end

يمكن تسجيل منهي عند إنشاء الكائن. في المثال التالي، لاحظ أننا نعتمد ضمنيًا على المنهي لإرجاع الهيكل القابل للتغيير x الذي تم إنشاؤه حديثًا.

mutable struct MyMutableStruct
    bar
    function MyMutableStruct(bar)
        x = new(bar)
        f(t) = @async println("Finalizing $t.")
        finalizer(f, x)
    end
end

finalize(x)

قم بتشغيل المنهيات المسجلة للكائن x على الفور.

copy(x)

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

انظر أيضًا copy!, copyto!, deepcopy.

deepcopy(x)

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

بينما لا يكون ذلك ضروريًا عادةً، يمكن لأنواع المستخدمين المحددة تجاوز سلوك deepcopy الافتراضي عن طريق تعريف نسخة متخصصة من الدالة deepcopy_internal(x::T, dict::IdDict) (التي لا ينبغي استخدامها بخلاف ذلك)، حيث T هو النوع الذي سيتم تخصيصه، و dict يتتبع الكائنات التي تم نسخها حتى الآن ضمن الاستدعاء المتكرر. ضمن التعريف، يجب استخدام deepcopy_internal بدلاً من deepcopy، ويجب تحديث متغير dict حسب الاقتضاء قبل الإرجاع.

getproperty(value, name::Symbol)
getproperty(value, name::Symbol, order::Symbol)

الصيغة a.b تستدعي getproperty(a, :b). الصيغة @atomic order a.b تستدعي getproperty(a, :b, :order) والصيغة @atomic a.b تستدعي getproperty(a, :b, :sequentially_consistent).

أمثلة

julia> struct MyType{T <: Number}
           x::T
       end

julia> function Base.getproperty(obj::MyType, sym::Symbol)
           if sym === :special
               return obj.x + 1
           else # fallback to getfield
               return getfield(obj, sym)
           end
       end

julia> obj = MyType(1);

julia> obj.special
2

julia> obj.x
1

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

انظر أيضًا getfield، propertynames و setproperty!.

setproperty!(value, name::Symbol, x)
setproperty!(value, name::Symbol, x, order::Symbol)

تستدعي الصيغة a.b = c الدالة setproperty!(a, :b, c). تستدعي الصيغة @atomic order a.b = c الدالة setproperty!(a, :b, c, :order) وتستدعي الصيغة @atomic a.b = c الدالة setproperty!(a, :b, c, :sequentially_consistent).

انظر أيضًا setfield!, propertynames و getproperty.

replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

قم بإجراء عملية مقارنة وتبديل على x.f من expected إلى desired، وفقًا لـ egal. يمكن استخدام الصيغة @atomicreplace x.f expected => desired بدلاً من شكل استدعاء الدالة.

انظر أيضًا replacefield! setproperty!, setpropertyonce!.

swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)

الصيغة @atomic a.b, _ = c, a.b تعيد (c, swapproperty!(a, :b, c, :sequentially_consistent))، حيث يجب أن يكون هناك تعبير getproperty مشترك بين الجانبين.

انظر أيضًا swapfield! و setproperty!.

modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)

تقوم الصيغة @atomic op(x.f, v) (ومكافئها @atomic x.f op v) بإرجاع modifyproperty!(x, :f, op, v, :sequentially_consistent), حيث يجب أن تكون الحجة الأولى تعبير getproperty ويتم تعديلها بشكل ذري.

يجب أن تعيد استدعاء op(getproperty(x, f), v) قيمة يمكن تخزينها في الحقل f من الكائن x بشكل افتراضي. على وجه الخصوص، على عكس السلوك الافتراضي لـ setproperty!, لا يتم استدعاء دالة convert تلقائيًا.

انظر أيضًا modifyfield! و setproperty!.

setpropertyonce!(x, f::Symbol, value, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

قم بإجراء عملية مقارنة وتبديل على x.f لتعيينها إلى value إذا كانت غير محددة مسبقًا. يمكن استخدام الصيغة @atomiconce x.f = value بدلاً من شكل استدعاء الدالة.

انظر أيضًا setfieldonce!, setproperty!, replaceproperty!.

propertynames(x, private=false)

احصل على مجموعة أو متجه من الخصائص (x.property) لكائن x. عادةً ما يكون هذا هو نفسه كما في fieldnames(typeof(x))، ولكن الأنواع التي تعيد تعريف getproperty يجب عمومًا أن تعيد تعريف propertynames أيضًا للحصول على خصائص مثيل من النوع.

قد تُرجع propertynames(x) أسماء الخصائص "العامة" فقط التي هي جزء من واجهة x الموثقة. إذا كنت تريد أيضًا أن تُرجع أسماء الخصائص "الخاصة" المخصصة للاستخدام الداخلي، مرر true كوسيط ثانٍ اختياري. يُظهر إكمال علامة التبويب في REPL على x. فقط الخصائص private=false.

انظر أيضًا: hasproperty، hasfield.

hasproperty(x, s::Symbol)

إرجاع قيمة منطقية تشير إلى ما إذا كان الكائن x لديه s كواحدة من خصائصه الخاصة.

انظر أيضًا: propertynames, hasfield.

getfield(value, name::Symbol, [order::Symbol])
getfield(value, i::Int, [order::Symbol])

استخرج حقلًا من value المركب بواسطة الاسم أو الموضع. يمكن تحديد ترتيب للعملية بشكل اختياري. إذا تم إعلان الحقل كـ @atomic، يُوصى بشدة أن يكون التحديد متوافقًا مع التخزين في ذلك الموقع. خلاف ذلك، إذا لم يتم إعلانه كـ @atomic، يجب أن تكون هذه المعلمة :not_atomic إذا تم تحديدها. انظر أيضًا getproperty و fieldnames.

أمثلة

julia> a = 1//2
1//2

julia> getfield(a, :num)
1

julia> a.num
1

julia> getfield(a, 1)
1

setfield!(value, name::Symbol, x, [order::Symbol])
setfield!(value, i::Int, x, [order::Symbol])

قم بتعيين x إلى حقل مسمى في value من نوع مركب. يجب أن يكون value قابلاً للتغيير ويجب أن يكون x من نوع فرعي لـ fieldtype(typeof(value), name). بالإضافة إلى ذلك، يمكن تحديد ترتيب لهذه العملية. إذا تم إعلان الحقل كـ @atomic، فإن هذا التحديد إلزامي. خلاف ذلك، إذا لم يتم إعلانه كـ @atomic، يجب أن يكون :not_atomic إذا تم تحديده. انظر أيضًا setproperty!.

أمثلة

julia> mutable struct MyMutableStruct
           field::Int
       end

julia> a = MyMutableStruct(1);

julia> setfield!(a, :field, 2);

julia> getfield(a, :field)
2

julia> a = 1//2
1//2

julia> setfield!(a, :num, 3);
ERROR: setfield!: immutable struct of type Rational cannot be changed

modifyfield!(value, name::Symbol, op, x, [order::Symbol]) -> Pair
modifyfield!(value, i::Int, op, x, [order::Symbol]) -> Pair

قم بتنفيذ العمليات بشكل ذري للحصول على حقل وتعيينه بعد تطبيق الدالة op.

y = getfield(value, name)
z = op(y, x)
setfield!(value, name, z)
return y => z

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

replacefield!(value, name::Symbol, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)
replacefield!(value, i::Int, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)

قم بتنفيذ العمليات بشكل ذري للحصول على وتعيين حقل بشكل شرطي إلى قيمة معينة.

y = getfield(value, name, fail_order)
ok = y === expected
if ok
    setfield!(value, name, desired, success_order)
end
return (; old = y, success = ok)

إذا كان مدعومًا من قبل الأجهزة، فقد يتم تحسين ذلك إلى تعليمات الأجهزة المناسبة، وإلا فسيستخدم حلقة.

swapfield!(value, name::Symbol, x, [order::Symbol])
swapfield!(value, i::Int, x, [order::Symbol])

قم بتنفيذ العمليات بشكل ذري للحصول على وتعيين حقل في نفس الوقت:

y = getfield(value, name)
setfield!(value, name, x)
return y

setfieldonce!(value, name::Union{Int,Symbol}, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool

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

ok = !isdefined(value, name, fail_order)
if ok
    setfield!(value, name, desired, success_order)
end
return ok

isdefined(m::Module, s::Symbol, [order::Symbol])
isdefined(object, s::Symbol, [order::Symbol])
isdefined(object, index::Int, [order::Symbol])

يختبر ما إذا كانت متغير عالمي أو حقل كائن محدد. يمكن أن تكون المعاملات وحدة ورمز أو كائن مركب واسم حقل (كرمز) أو فهرس. يمكن تحديد ترتيب للعملية بشكل اختياري. إذا تم إعلان الحقل @atomic، يُوصى بشدة بأن تكون المواصفة متوافقة مع التخزين في ذلك الموقع. خلاف ذلك، إذا لم يتم إعلانه كـ @atomic، يجب أن تكون هذه المعلمة :not_atomic إذا تم تحديدها.

لاختبار ما إذا كان عنصر مصفوفة محددًا، استخدم isassigned بدلاً من ذلك.

انظر أيضًا @isdefined.

أمثلة

julia> isdefined(Base, :sum)
true

julia> isdefined(Base, :NonExistentMethod)
false

julia> a = 1//2;

julia> isdefined(a, 2)
true

julia> isdefined(a, 3)
false

julia> isdefined(a, :num)
true

julia> isdefined(a, :numerator)
false

@isdefined s -> Bool

يختبر ما إذا كانت المتغير s معرفًا في النطاق الحالي.

انظر أيضًا isdefined لخصائص الحقول وisassigned لفهارس المصفوفات أو haskey للت mappings الأخرى.

أمثلة

julia> @isdefined newvar
false

julia> newvar = 1
1

julia> @isdefined newvar
true

julia> function f()
           println(@isdefined x)
           x = 3
           println(@isdefined x)
       end
f (generic function with 1 method)

julia> f()
false
true

convert(T, x)

قم بتحويل x إلى قيمة من النوع T.

إذا كان T من نوع Integer، سيتم رفع InexactError إذا لم يكن x قابلاً للتمثيل بواسطة T، على سبيل المثال إذا لم يكن x ذو قيمة صحيحة، أو كان خارج النطاق المدعوم بواسطة T.

أمثلة

julia> convert(Int, 3.0)
3

julia> convert(Int, 3.5)
ERROR: InexactError: Int64(3.5)
Stacktrace:
[...]

إذا كان T من نوع AbstractFloat، فسيعيد أقرب قيمة إلى x قابلة للتمثيل بواسطة T. يتم اعتبار Inf كواحد ulp أكبر من floatmax(T) لأغراض تحديد الأقرب.

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125

إذا كان T من نوع مجموعة و x مجموعة، قد يكون ناتج convert(T, x) متطابقًا مع كل أو جزء من x.

julia> x = Int[1, 2, 3];

julia> y = convert(Vector{Int}, x);

julia> y === x
true

انظر أيضًا: round، trunc، oftype، reinterpret. ```

promote(xs...)

قم بتحويل جميع المعاملات إلى نوع مشترك، وأعدها جميعًا (كـ tuple). إذا لم يكن بالإمكان تحويل أي معاملات، يتم رفع خطأ.

انظر أيضًا: promote_type، promote_rule.

أمثلة

julia> promote(Int8(1), Float16(4.5), Float32(4.1))
(1.0f0, 4.5f0, 4.1f0)

julia> promote_type(Int8, Float16, Float32)
Float32

julia> reduce(Base.promote_typejoin, (Int8, Float16, Float32))
Real

julia> promote(1, "x")
ERROR: promotion of types Int64 and String failed to change any arguments
[...]

julia> promote_type(Int, String)
Any

oftype(x, y)

قم بتحويل y إلى نوع x أي convert(typeof(x), y).

أمثلة

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0

widen(x)

إذا كانت x نوعًا، فإنها تعيد نوعًا "أكبر"، يتم تعريفه بحيث تضمن العمليات الحسابية + و - عدم حدوث تجاوز أو فقدان الدقة لأي مجموعة من القيم التي يمكن أن يحملها النوع x.

بالنسبة لأنواع الأعداد الصحيحة ذات الحجم الثابت التي تقل عن 128 بت، ستعيد widen نوعًا يحتوي على ضعف عدد البتات.

إذا كانت x قيمة، يتم تحويلها إلى widen(typeof(x)).

أمثلة

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

دالة الهوية. تعيد وسيطها.

انظر أيضًا: one، oneunit، و I من LinearAlgebra.

أمثلة

julia> identity("Well, what did you expect?")
"Well, what did you expect?"

WeakRef(x)

w = WeakRef(x) ينشئ مرجع ضعيف للقيمة جوليا x: على الرغم من أن w يحتوي على مرجع لـ x، إلا أنه لا يمنع x من أن يتم جمعه بواسطة جامع القمامة. w.value إما أن تكون x (إذا لم يتم جمع x بواسطة جامع القمامة بعد) أو nothing (إذا تم جمع x بواسطة جامع القمامة).

julia> x = "a string"
"a string"

julia> w = WeakRef(x)
WeakRef("a string")

julia> GC.gc()

julia> w           # يتم الحفاظ على المرجع عبر `x`
WeakRef("a string")

julia> x = nothing # مسح المرجع

julia> GC.gc()

julia> w
WeakRef(nothing)

supertype(T::DataType)

إرجاع السوبرتايب لنوع البيانات T.

أمثلة

julia> supertype(Int32)
Signed

Core.Type{T}

Core.Type هو نوع مجرد يحتوي على جميع كائنات النوع كحالات له. الحالة الوحيدة لنوع الوحدة Core.Type{T} هي الكائن T.

أمثلة

julia> isa(Type{Float64}, Type)
true

julia> isa(Float64, Type)
true

julia> isa(Real, Type{Float64})
false

julia> isa(Real, Type{Real})
true

DataType <: Type{T}

DataType يمثل الأنواع المعلنة صراحةً التي لها أسماء، والأنواع العليا المعلنة صراحةً، و، اختيارياً، المعلمات. كل قيمة ملموسة في النظام هي مثيل من نوع DataType.

أمثلة

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType

<:(T1, T2)

عامل النوع الفرعي: يُرجع true إذا وفقط إذا كانت جميع قيم النوع T1 هي أيضًا من النوع T2.

أمثلة

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

julia> Matrix{Float64} <: Matrix{AbstractFloat}
false

>:(T1, T2)

عامل السوبرتايب، يعادل T2 <: T1.

typejoin(T, S, ...)

إرجاع أقرب سلف مشترك للأنواع T و S، أي أضيق نوع يرثان منه كلاهما. يتكرر على المتغيرات الإضافية.

أمثلة

julia> typejoin(Int, Float64)
Real

julia> typejoin(Int, Float64, ComplexF32)
Number

typeintersect(T::Type, S::Type)

احسب نوعًا يحتوي على تقاطع T و S. عادةً ما سيكون هذا هو أصغر نوع من هذا القبيل أو نوع قريب منه.

حالة خاصة حيث يتم ضمان السلوك الدقيق: عندما يكون T <: S، فإن typeintersect(S, T) == T == typeintersect(T, S).

promote_type(type1, type2, ...)

تشير الترقية إلى تحويل قيم الأنواع المختلطة إلى نوع مشترك واحد. تمثل promote_type سلوك الترقية الافتراضي في جوليا عندما يتم إعطاء المشغلين (عادةً رياضيين) معاملات من أنواع مختلفة. تحاول promote_type عمومًا إرجاع نوع يمكنه على الأقل تقريب معظم قيم أي من نوع الإدخال دون توسيع مفرط. يتم التسامح مع بعض الفقد؛ على سبيل المثال، تعيد promote_type(Int64, Float64) Float64 على الرغم من أنه بشكل صارم، لا يمكن تمثيل جميع قيم Int64 بدقة كقيم Float64.

انظر أيضًا: promote, promote_typejoin, promote_rule.

أمثلة

julia> promote_type(Int64, Float64)
Float64

julia> promote_type(Int32, Int64)
Int64

julia> promote_type(Float32, BigInt)
BigFloat

julia> promote_type(Int16, Float16)
Float16

julia> promote_type(Int64, Float16)
Float16

julia> promote_type(Int8, UInt16)
UInt16

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

promote_rule(type1, type2)

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

promote_typejoin(T, S)

احسب نوعًا يحتوي على كل من T و S، والذي يمكن أن يكون إما والدًا لكلا النوعين، أو Union إذا كان ذلك مناسبًا. يتراجع إلى typejoin.

انظر أيضًا promote، promote_type.

أمثلة

julia> Base.promote_typejoin(Int, Float64)
Real

julia> Base.promote_type(Int, Float64)
Float64

isdispatchtuple(T)

حدد ما إذا كان النوع T هو نوع "ورقة" من التوابل، مما يعني أنه يمكن أن يظهر كنوع في التوزيع وليس له أنواع فرعية (أو أنواع عليا) يمكن أن تظهر في استدعاء. إذا لم يكن T نوعًا، فقم بإرجاع false.

ismutable(v) -> Bool

ارجع true إذا وفقط إذا كانت القيمة v قابلة للتغيير. انظر Mutable Composite Types لمناقشة عدم القابلية للتغيير. لاحظ أن هذه الدالة تعمل على القيم، لذا إذا أعطيتها DataType، ستخبرك أن قيمة من هذا النوع قابلة للتغيير.

!!! ملاحظة لأسباب تقنية، ترجع ismutable true لقيم من أنواع خاصة معينة (على سبيل المثال String و Symbol) على الرغم من أنه لا يمكن تغييرها بطريقة مسموح بها.

انظر أيضًا isbits، isstructtype.

أمثلة

julia> ismutable(1)
false

julia> ismutable([1,2])
true

!!! توافق "جوليا 1.5" تتطلب هذه الدالة على الأقل جوليا 1.5.

isimmutable(v) -> Bool

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

أمثلة

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

ismutabletype(T) -> Bool

حدد ما إذا كان النوع T قد تم إعلانه كنوع قابل للتغيير (أي باستخدام الكلمة الرئيسية mutable struct). إذا لم يكن T نوعًا، فقم بإرجاع false.

isabstracttype(T)

حدد ما إذا كان النوع T قد تم إعلانه كنوع مجرد (أي باستخدام بناء جملة abstract type). لاحظ أن هذا ليس نفيًا لـ isconcretetype(T). إذا لم يكن T نوعًا، فقم بإرجاع false.

أمثلة

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

isprimitivetype(T) -> Bool

حدد ما إذا كان النوع T قد تم إعلانه كنوع بدائي (أي باستخدام بناء جملة primitive type). إذا لم يكن T نوعًا، فقم بإرجاع false.

Base.issingletontype(T)

حدد ما إذا كان النوع T لديه بالضبط مثيل واحد ممكن؛ على سبيل المثال، نوع هيكل بدون حقول باستثناء قيم مفردة أخرى. إذا لم يكن T نوعًا ملموسًا، فقم بإرجاع false.

isstructtype(T) -> Bool

حدد ما إذا كان النوع T قد تم إعلانه كنوع هيكل (أي باستخدام الكلمة الرئيسية struct أو mutable struct). إذا لم يكن T نوعًا، فقم بإرجاع false.

nameof(t::DataType) -> Symbol

احصل على اسم نوع البيانات (الذي قد يكون مغلفًا بـ UnionAll) كرمز، بدون وحدة الوالد.

أمثلة

julia> module Foo
           struct S{T}
           end
       end
Foo

julia> nameof(Foo.S{T} where T)
:S

fieldnames(x::DataType)

احصل على مجموعة تحتوي على أسماء حقول DataType.

انظر أيضًا propertynames، hasfield.

أمثلة

julia> fieldnames(Rational)
(:num, :den)

julia> fieldnames(typeof(1+im))
(:re, :im)

fieldname(x::DataType, i::Integer)

احصل على اسم الحقل i من DataType.

أمثلة

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

fieldtype(T, name::Symbol | index::Int)

حدد نوع الحقل المعلن (المحدد بالاسم أو الفهرس) في نوع البيانات المركب T.

أمثلة

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

fieldtypes(T::Type)

أنواع الحقول المعلنة لجميع الحقول في نوع البيانات المركب T كـ tuple.

أمثلة

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtypes(Foo)
(Int64, String)

fieldcount(t::Type)

احصل على عدد الحقول التي سيكون لدى مثيل من النوع المعطى. يتم طرح خطأ إذا كان النوع مجردًا جدًا لتحديد ذلك.

hasfield(T::Type, name::Symbol)

إرجاع قيمة منطقية تشير إلى ما إذا كان T يحتوي على name كأحد حقوله الخاصة.

انظر أيضًا fieldnames، fieldcount، hasproperty.

أمثلة

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false

nfields(x) -> Int

احصل على عدد الحقول في الكائن المعطى.

أمثلة

julia> a = 1//2;

julia> nfields(a)
2

julia> b = 1
1

julia> nfields(b)
0

julia> ex = ErrorException("لقد قمت بشيء سيء");

julia> nfields(ex)
1

في هذه الأمثلة، a هو Rational، الذي يحتوي على حقلين. b هو Int، وهو نوع بدائي من البتات بدون أي حقول على الإطلاق. ex هو ErrorException، الذي يحتوي على حقل واحد.

isconst(m::Module, s::Symbol) -> Bool

حدد ما إذا كان المتغير العالمي مُعلنًا كـ const في الوحدة المعطاة m.

isconst(t::DataType, s::Union{Int,Symbol}) -> Bool

حدد ما إذا كان الحقل s مُعلنًا عنه كـ const في نوع معين t.

isfieldatomic(t::DataType, s::Union{Int,Symbol}) -> Bool

حدد ما إذا كان الحقل s مُعلنًا عنه كـ @atomic في نوع معين t.

sizeof(T::DataType)
sizeof(obj)

الحجم، بالبايت، من التمثيل الثنائي القياسي لنوع البيانات المعطى DataType T، إذا كان موجودًا. أو الحجم، بالبايت، من الكائن obj إذا لم يكن نوع بيانات.

انظر أيضًا Base.summarysize.

أمثلة

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

julia> sizeof(collect(1.0:10.0))
80

julia> struct StructWithPadding
           x::Int64
           flag::Bool
       end

julia> sizeof(StructWithPadding) # ليس مجموع `sizeof` للحقول بسبب الحشو
16

julia> sizeof(Int64) + sizeof(Bool) # مختلف عن السابق
9

إذا لم يكن لنوع البيانات T حجم محدد، يتم إلقاء خطأ.

julia> sizeof(AbstractArray)
ERROR: النوع المجرد AbstractArray ليس له حجم محدد.
Stacktrace:
[...]

isconcretetype(T)

حدد ما إذا كان النوع T نوعًا ملموسًا، مما يعني أنه يمكن أن يكون له حالات مباشرة (قيم x بحيث typeof(x) === T). لاحظ أن هذا ليس نفيًا لـ isabstracttype(T). إذا لم يكن T نوعًا، فارجع false.

انظر أيضًا: isbits, isabstracttype, issingletontype.

أمثلة

julia> isconcretetype(Complex)
false

julia> isconcretetype(Complex{Float32})
true

julia> isconcretetype(Vector{Complex})
true

julia> isconcretetype(Vector{Complex{Float32}})
true

julia> isconcretetype(Union{})
false

julia> isconcretetype(Union{Int,String})
false

isbits(x)

ارجع true إذا كان x هو مثيل من نوع isbitstype.

isbitstype(T)

ارجع true إذا كان النوع T نوع "بيانات عادية"، مما يعني أنه غير قابل للتغيير ولا يحتوي على مراجع لقيم أخرى، فقط أنواع primitive وأنواع أخرى من isbitstype. الأمثلة النموذجية هي الأنواع العددية مثل UInt8، Float64، و Complex{Float64}. هذه الفئة من الأنواع مهمة لأنها صالحة كمعلمات نوع، وقد لا تتعقب حالة isdefined / isassigned، ولها تخطيط محدد يتوافق مع C. إذا لم يكن T نوعًا، فارجع false.

انظر أيضًا isbits، isprimitivetype، ismutable.

أمثلة

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

fieldoffset(type, i)

الإزاحة البايتية للحقل i من نوع ما بالنسبة لبداية البيانات. على سبيل المثال، يمكننا استخدامه بالطريقة التالية لتلخيص المعلومات حول بنية:

julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:fieldcount(T)];

julia> structinfo(Base.Filesystem.StatStruct)
13-element Vector{Tuple{UInt64, Symbol, Type}}:
 (0x0000000000000000, :desc, Union{RawFD, String})
 (0x0000000000000008, :device, UInt64)
 (0x0000000000000010, :inode, UInt64)
 (0x0000000000000018, :mode, UInt64)
 (0x0000000000000020, :nlink, Int64)
 (0x0000000000000028, :uid, UInt64)
 (0x0000000000000030, :gid, UInt64)
 (0x0000000000000038, :rdev, UInt64)
 (0x0000000000000040, :size, Int64)
 (0x0000000000000048, :blksize, Int64)
 (0x0000000000000050, :blocks, Int64)
 (0x0000000000000058, :mtime, Float64)
 (0x0000000000000060, :ctime, Float64)

Base.datatype_alignment(dt::DataType) -> Int

الحد الأدنى لمحاذاة تخصيص الذاكرة لعينات من هذا النوع. يمكن استدعاؤه على أي isconcretetype، على الرغم من أنه بالنسبة للذاكرة، سيعطي محاذاة العناصر، وليس الكائن بالكامل.

Base.datatype_haspadding(dt::DataType) -> Bool

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

Base.datatype_pointerfree(dt::DataType) -> Bool

إرجاع ما إذا كانت مثيلات هذا النوع يمكن أن تحتوي على مراجع إلى الذاكرة المدارة بواسطة gc. يمكن استدعاؤه على أي isconcretetype.

typemin(T)

أدنى قيمة يمكن تمثيلها بواسطة نوع البيانات الرقمي (الحقيقي) المعطى T.

انظر أيضًا: floatmin, typemax, eps.

أمثلة

julia> typemin(Int8)
-128

julia> typemin(UInt32)
0x00000000

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

julia> nextfloat(-Inf32)  # أصغر عدد نقطة عائمة من نوع Float32
-3.4028235f38

typemax(T)

أعلى قيمة يمكن تمثيلها بواسطة DataType (رقم حقيقي) المعطى.

انظر أيضًا: floatmax, typemin, eps.

أمثلة

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> typemax(Float32)
Inf32

julia> floatmax(Float32)  # أكبر عدد نقطة عائمة Finite من نوع Float32
3.4028235f38

floatmin(T = Float64)

إرجاع أصغر عدد عادي موجب يمكن تمثيله بواسطة نوع النقطة العائمة T.

أمثلة

julia> floatmin(Float16)
Float16(6.104e-5)

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308

floatmax(T = Float64)

إرجاع أكبر عدد نهائي يمكن تمثيله بواسطة نوع النقطة العائمة T.

انظر أيضًا: typemax، floatmin، eps.

أمثلة

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

julia> typemax(Float64)
Inf

maxintfloat(T=Float64)

أكبر عدد عشري متسلسل ذو قيمة صحيحة يتم تمثيله بدقة في نوع النقطة العائمة المعطى T (الذي يكون افتراضيًا Float64).

أي أن maxintfloat يُرجع أصغر عدد عشري ذو قيمة صحيحة موجب n بحيث أن n+1 ليس قابلًا للتمثيل بدقة في النوع T.

عند الحاجة إلى قيمة من نوع Integer، استخدم Integer(maxintfloat(T)).

maxintfloat(T, S)

أكبر عدد صحيح متتالي يمكن تمثيله في نوع النقطة العائمة المعطى T والذي لا يتجاوز أيضًا أكبر عدد صحيح يمكن تمثيله بواسطة نوع العدد الصحيح S. بمعنى آخر، هو الحد الأدنى من maxintfloat(T) و typemax(S).

eps(::Type{T}) where T<:AbstractFloat
eps()

ارجع آلة إبسيلون لنوع النقطة العائمة T (T = Float64 بشكل افتراضي). يتم تعريفه على أنه الفجوة بين 1 وأكبر قيمة قابلة للتمثيل التالية بواسطة typeof(one(T))، وهو ما يعادل eps(one(T)). (نظرًا لأن eps(T) هو حد على الخطأ النسبي لـ T، فهو كمية "بلا أبعاد" مثل one.)

أمثلة

julia> eps()
2.220446049250313e-16

julia> eps(Float32)
1.1920929f-7

julia> 1.0 + eps()
1.0000000000000002

julia> 1.0 + eps()/2
1.0

eps(x::AbstractFloat)

ارجع الوحدة في آخر مكان (ulp) لـ x. هذه هي المسافة بين قيم النقطة العائمة القابلة للتمثيل المتتالية عند x. في معظم الحالات، إذا كانت المسافة على أي جانب من x مختلفة، يتم أخذ الأكبر من الاثنين، أي

eps(x) == max(x-prevfloat(x), nextfloat(x)-x)

الاستثناءات من هذه القاعدة هي أصغر وأكبر القيم النهائية (مثل nextfloat(-Inf) و prevfloat(Inf) لـ Float64)، والتي تقرب إلى الأصغر من القيم.

السبب وراء هذا السلوك هو أن eps يحدد خطأ التقريب في النقطة العائمة. تحت وضع التقريب الافتراضي RoundNearest، إذا كان $y$ عددًا حقيقيًا و $x$ هو أقرب عدد نقطة عائمة إلى $y$، فإن

\[|y-x| \leq \operatorname{eps}(x)/2.\]

انظر أيضًا: nextfloat، issubnormal، floatmax.

أمثلة

julia> eps(1.0)
2.220446049250313e-16

julia> eps(prevfloat(2.0))
2.220446049250313e-16

julia> eps(2.0)
4.440892098500626e-16

julia> x = prevfloat(Inf)      # أكبر Float64 نهائي
1.7976931348623157e308

julia> x + eps(x)/2            # يقرب للأعلى
Inf

julia> x + prevfloat(eps(x)/2) # يقرب للأسفل
1.7976931348623157e308

instances(T::Type)

إرجاع مجموعة من جميع الحالات لنوع معين، إذا كان ذلك ممكنًا. يُستخدم بشكل أساسي لأنواع التعداد (انظر @enum).

أمثلة

julia> @enum Color red blue green

julia> instances(Color)
(red, blue, green)

Any::DataType

Any هو اتحاد جميع الأنواع. لديه الخاصية المحددة isa(x, Any) == true لأي x. وبالتالي، يصف Any الكون بأسره من القيم الممكنة. على سبيل المثال، Integer هو مجموعة فرعية من Any تشمل Int و Int8 وأنواع الأعداد الصحيحة الأخرى.

Union{Types...}

نوع Union هو نوع تجريدي يتضمن جميع حالات أي من أنواع وسائطه. هذا يعني أن T <: Union{T,S} و S <: Union{T,S}.

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

أمثلة

julia> IntOrString = Union{Int,AbstractString}
Union{Int64, AbstractString}

julia> 1 isa IntOrString # مثيل من Int مدرج في الاتحاد
true

julia> "Hello!" isa IntOrString # String مدرج أيضًا
true

julia> 1.0 isa IntOrString # Float64 غير مدرج لأنه ليس Int ولا AbstractString
false

مساعدة موسعة

على عكس معظم الأنواع المعاملية الأخرى، فإن الاتحادات متوافقة في معلماتها. على سبيل المثال، Union{Real, String} هو نوع فرعي من Union{Number, AbstractString}.

الاتحاد الفارغ Union{} هو النوع الأدنى في جوليا.

Union{}

Union{}، وهو Union الفارغ من الأنواع، هو النوع الذي ليس له قيم. أي أنه يمتلك الخاصية التعريفية isa(x, Union{}) == false لأي x. يتم تعريف Base.Bottom كاسم مستعار له ونوع Union{} هو Core.TypeofBottom.

أمثلة

julia> isa(nothing, Union{})
false

UnionAll

اتحاد الأنواع على جميع قيم معلمة النوع. يتم استخدام UnionAll لوصف الأنواع المعاملية حيث لا تُعرف قيم بعض المعلمات. انظر قسم الدليل حول أنواع UnionAll.

أمثلة

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Tuple{Types...}

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

julia> (1, 1+1)
(1, 2)

julia> (1,)
(1,)

julia> x = (0.0, "hello", 6*7)
(0.0, "hello", 42)

julia> x[2]
"hello"

julia> typeof(x)
Tuple{Float64, String, Int64}

يجب كتابة التوابل ذات الطول 1 مع فاصلة، (1,)، لأن (1) سيكون مجرد قيمة محاطة بأقواس. () تمثل التوابل الفارغة (طول 0).

يمكن بناء التوابل من مكرر باستخدام نوع Tuple كمنشئ:

julia> Tuple(["a", 1])
("a", 1)

julia> Tuple{String, Float64}(["a", 1])
("a", 1.0)

أنواع التوابل متغايرة في معلماتها: Tuple{Int} هو نوع فرعي من Tuple{Any}. لذلك يعتبر Tuple{Any} نوعًا مجردًا، وأنواع التوابل تكون ملموسة فقط إذا كانت معلماتها ملموسة. لا تحتوي التوابل على أسماء حقول؛ يتم الوصول إلى الحقول فقط بواسطة الفهرس. قد تحتوي أنواع التوابل على أي عدد من المعلمات.

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

انظر أيضًا Vararg، NTuple، ntuple، tuple، NamedTuple.

NTuple{N, T}

طريقة مدمجة لتمثيل النوع لصف من الطول N حيث جميع العناصر من النوع T.

أمثلة

julia> isa((1, 2, 3, 4, 5, 6), NTuple{6, Int})
true

انظر أيضًا ntuple.

NamedTuple

NamedTuples هي، كما يوحي اسمها، Tuples مسماة. أي أنها مجموعة تشبه التوابل من القيم، حيث يحتوي كل إدخال على اسم فريد، يتم تمثيله كـ Symbol. مثل Tuples، NamedTuples غير قابلة للتغيير؛ لا يمكن تعديل الأسماء أو القيم في مكانها بعد الإنشاء.

يمكن إنشاء tuple مسمى كـ literal tuple مع مفاتيح، على سبيل المثال (a=1, b=2)، أو كـ literal tuple مع فاصلة منقوطة بعد القوس المفتوح، على سبيل المثال (; a=1, b=2) (هذا الشكل يقبل أيضًا الأسماء التي تم إنشاؤها برمجيًا كما هو موضح أدناه)، أو باستخدام نوع NamedTuple كمنشئ، على سبيل المثال NamedTuple{(:a, :b)}((1,2)).

يمكن الوصول إلى القيمة المرتبطة باسم في tuple مسمى باستخدام بناء جملة الوصول إلى الحقول، على سبيل المثال x.a، أو باستخدام getindex، على سبيل المثال x[:a] أو x[(:a, :b)]. يمكن الحصول على tuple من الأسماء باستخدام keys، ويمكن الحصول على tuple من القيم باستخدام values.

يمكن استخدام الماكرو @NamedTuple للإعلان بشكل مريح عن أنواع NamedTuple.

أمثلة

julia> x = (a=1, b=2)
(a = 1, b = 2)

julia> x.a
1

julia> x[:a]
1

julia> x[(:a,)]
(a = 1,)

julia> keys(x)
(:a, :b)

julia> values(x)
(1, 2)

julia> collect(x)
2-element Vector{Int64}:
 1
 2

julia> collect(pairs(x))
2-element Vector{Pair{Symbol, Int64}}:
 :a => 1
 :b => 2

بطريقة مشابهة لكيفية تعريف الوسائط الرئيسية برمجيًا، يمكن إنشاء tuple مسمى عن طريق إعطاء أزواج name::Symbol => value بعد فاصلة منقوطة داخل literal tuple. يمكن خلط هذا مع بناء جملة name=value:

julia> (; :a => 1, :b => 2, c=3)
(a = 1, b = 2, c = 3)

يمكن أيضًا تقديم أزواج الاسم-القيمة عن طريق تفكيك tuple مسمى أو أي مكرر ينتج مجموعات ذات قيمتين تحمل كل منها رمزًا كقيمة أولى:

julia> keys = (:a, :b, :c); values = (1, 2, 3);

julia> NamedTuple{keys}(values)
(a = 1, b = 2, c = 3)

julia> (; (keys .=> values)...)
(a = 1, b = 2, c = 3)

julia> nt1 = (a=1, b=2);

julia> nt2 = (c=3, d=4);

julia> (; nt1..., nt2..., b=20) # القيمة النهائية لـ b تتجاوز القيمة من nt1
(a = 1, b = 20, c = 3, d = 4)

julia> (; zip(keys, values)...) # zip ينتج tuples مثل (:a, 1)
(a = 1, b = 2, c = 3)

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

julia> x = 0
0

julia> t = (; x)
(x = 0,)

julia> (; t.x)
(x = 0,)

@NamedTuple{key1::Type1, key2::Type2, ...}
@NamedTuple begin key1::Type1; key2::Type2; ...; end

تقدم هذه الماكرو صياغة أكثر ملاءمة لإعلان أنواع NamedTuple. إنها تعيد نوع NamedTuple مع المفاتيح والأنواع المعطاة، وهو ما يعادل NamedTuple{(:key1, :key2, ...), Tuple{Type1,Type2,...}}. إذا تم حذف إعلان ::Type، يتم اعتباره Any. يسمح شكل begin ... end بتقسيم الإعلانات عبر عدة أسطر (مشابه لإعلان struct)، ولكنه متساوي بخلاف ذلك. يتم استخدام ماكرو NamedTuple عند طباعة أنواع NamedTuple إلى مثلاً REPL.

على سبيل المثال، تحتوي المجموعة (a=3.1, b="hello") على نوع NamedTuple{(:a, :b), Tuple{Float64, String}}، والتي يمكن أيضًا إعلانها عبر @NamedTuple كالتالي:

julia> @NamedTuple{a::Float64, b::String}
@NamedTuple{a::Float64, b::String}

julia> @NamedTuple begin
           a::Float64
           b::String
       end
@NamedTuple{a::Float64, b::String}

@Kwargs{key1::Type1, key2::Type2, ...}

تقدم هذه الماكرو طريقة ملائمة لبناء تمثيل النوع لوسائط الكلمات الرئيسية من نفس بناء الجملة مثل @NamedTuple. على سبيل المثال، عندما يكون لدينا استدعاء دالة مثل func([positional arguments]; kw1=1.0, kw2="2")، يمكننا استخدام هذه الماكرو لبناء التمثيل الداخلي لنوع وسائط الكلمات الرئيسية كـ @Kwargs{kw1::Float64, kw2::String}. تم تصميم بناء جملة الماكرو بشكل خاص لتبسيط نوع توقيع طريقة الكلمات الرئيسية عندما يتم طباعته في عرض تتبع المكدس.

julia> @Kwargs{init::Int} # التمثيل الداخلي لوسائط الكلمات الرئيسية
Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}

julia> sum("julia"; init=1)
ERROR: MethodError: no method matching +(::Char, ::Char)
The function `+` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:585
  +(::Integer, ::AbstractChar)
   @ Base char.jl:247
  +(::T, ::Integer) where T<:AbstractChar
   @ Base char.jl:237

Stacktrace:
  [1] add_sum(x::Char, y::Char)
    @ Base ./reduce.jl:24
  [2] BottomRF
    @ Base ./reduce.jl:86 [inlined]
  [3] _foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, init::Int64, itr::String)
    @ Base ./reduce.jl:62
  [4] foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, nt::Int64, itr::String)
    @ Base ./reduce.jl:48 [inlined]
  [5] mapfoldl_impl(f::typeof(identity), op::typeof(Base.add_sum), nt::Int64, itr::String)
    @ Base ./reduce.jl:44 [inlined]
  [6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64)
    @ Base ./reduce.jl:175 [inlined]
  [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:307 [inlined]
  [8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:535 [inlined]
  [9] sum(a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:564 [inlined]
 [10] top-level scope
    @ REPL[12]:1

Val(c)

ارجع Val{c}(), الذي لا يحتوي على بيانات وقت التشغيل. يمكن استخدام أنواع مثل هذه لنقل المعلومات بين الدوال من خلال القيمة c، التي يجب أن تكون قيمة isbits أو Symbol. الغرض من هذا البناء هو القدرة على التوجيه على الثوابت مباشرة (في وقت الترجمة) دون الحاجة إلى اختبار قيمة الثابت في وقت التشغيل.

أمثلة

julia> f(::Val{true}) = "Good"
f (generic function with 1 method)

julia> f(::Val{false}) = "Bad"
f (generic function with 2 methods)

julia> f(Val(true))
"Good"

Vararg{T,N}

يمكن أن تكون المعلمة الأخيرة من نوع التوبل Tuple هي القيمة الخاصة Vararg، التي تدل على أي عدد من العناصر اللاحقة. Vararg{T,N} يتوافق مع بالضبط N عنصر من النوع T. وأخيرًا، Vararg{T} يتوافق مع صفر أو أكثر من العناصر من النوع T. تُستخدم أنواع توبل Vararg لتمثيل المعاملات المقبولة من قبل طرق varargs (انظر القسم حول وظائف Varargs في الدليل).

انظر أيضًا NTuple.

أمثلة

julia> mytupletype = Tuple{AbstractString, Vararg{Int}}
Tuple{AbstractString, Vararg{Int64}}

julia> isa(("1",), mytupletype)
true

julia> isa(("1",1), mytupletype)
true

julia> isa(("1",1,2), mytupletype)
true

julia> isa(("1",1,2,3.0), mytupletype)
false

لا شيء

نوع بلا حقول وهو نوع nothing.

انظر أيضًا: isnothing، Some، Missing.

isnothing(x)

ارجع true إذا كان x === nothing، وارجع false إذا لم يكن كذلك.

انظر أيضًا something، Base.notnothing، ismissing.

notnothing(x)

ارمِ خطأ إذا كان x === nothing، وأعد x إذا لم يكن كذلك.

Some{T}

نوع غلاف يُستخدم في Union{Some{T}, Nothing} للتمييز بين غياب قيمة (nothing) ووجود قيمة nothing (أي Some(nothing)).

استخدم something للوصول إلى القيمة المغلفة بواسطة كائن Some.

شيء(x...)

ارجع أول قيمة في المعطيات التي لا تساوي nothing، إن وجدت. وإلا، ارمِ خطأ. يتم فك تغليف المعطيات من نوع Some.

انظر أيضًا coalesce، skipmissing، @something.

أمثلة

julia> شيء(nothing, 1)
1

julia> شيء(Some(1), nothing)
1

julia> شيء(Some(nothing), 2) === nothing
true

julia> شيء(missing, nothing)
missing

julia> شيء(nothing, nothing)
ERROR: ArgumentError: لا توجد معطيات قيمة

@something(x...)

نسخة قصيرة من something.

أمثلة

julia> f(x) = (println("f($x)"); nothing);

julia> a = 1;

julia> a = @something a f(2) f(3) error("غير قادر على العثور على افتراضي لـ `a`")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("غير قادر على العثور على افتراضي لـ `b`")
f(2)
f(3)
ERROR: غير قادر على العثور على افتراضي لـ `b`
[...]

julia> b = @something b f(2) f(3) Some(nothing)
f(2)
f(3)

julia> b === nothing
true

Enum{T<:Integer}

النوع الفائق المجرد لجميع الأنواع المعدودة المعرفة باستخدام @enum.

@enum EnumName[::BaseType] value1[=x] value2[=y]

أنشئ نوع فرعي من Enum{BaseType} باسم EnumName وقيم أعضاء التعداد value1 و value2 مع قيم اختيارية معينة لـ x و y، على التوالي. يمكن استخدام EnumName مثل الأنواع الأخرى وقيم أعضاء التعداد كقيم عادية، مثل

أمثلة

julia> @enum Fruit apple=1 orange=2 kiwi=3

julia> f(x::Fruit) = "أنا فاكهة بقيمة: $(Int(x))"
f (دالة عامة مع 1 طريقة)

julia> f(apple)
"أنا فاكهة بقيمة: 1"

julia> Fruit(1)
apple::Fruit = 1

يمكن أيضًا تحديد القيم داخل كتلة begin، على سبيل المثال

@enum EnumName begin
    value1
    value2
end

يجب أن يكون BaseType، الذي يكون افتراضيًا Int32، نوعًا بدائيًا فرعيًا من Integer. يمكن تحويل قيم الأعضاء بين نوع التعداد و BaseType. تقوم read و write بإجراء هذه التحويلات تلقائيًا. في حالة إنشاء التعداد بنوع BaseType غير افتراضي، ستعيد Integer(value1) القيمة الصحيحة value1 مع نوع BaseType.

لإدراج جميع حالات التعداد، استخدم instances، على سبيل المثال

julia> instances(Fruit)
(apple, orange, kiwi)

من الممكن إنشاء رمز من حالة التعداد:

julia> Symbol(apple)
:apple

Expr(head::Symbol, args...)

نوع يمثل التعبيرات المركبة في كود جوليا المحلل (ASTs). تتكون كل تعبير من head Symbol يحدد نوع التعبير (مثل: استدعاء، حلقة for، عبارة شرطية، إلخ)، وتعبيرات فرعية (مثل: الوسائط في استدعاء). يتم تخزين التعبيرات الفرعية في حقل Vector{Any} يسمى args.

راجع الفصل في الدليل حول Metaprogramming و الوثائق الخاصة بالمطورين Julia ASTs.

أمثلة

julia> Expr(:call, :+, 1, 2)
:(1 + 2)

julia> dump(:(a ? b : c))
Expr
  head: Symbol if
  args: Array{Any}((3,))
    1: Symbol a
    2: Symbol b
    3: Symbol c

رمز

نوع الكائن المستخدم لتمثيل المعرفات في كود جوليا المحلل (ASTs). يُستخدم أيضًا غالبًا كاسم أو علامة لتحديد كيان (على سبيل المثال، كمفتاح في القاموس). يمكن إدخال Symbols باستخدام عامل الاقتباس ::

julia> :name
:name

julia> typeof(:name)
رمز

julia> x = 42
42

julia> eval(:x)
42

يمكن أيضًا إنشاء Symbols من السلاسل النصية أو القيم الأخرى عن طريق استدعاء المُنشئ Symbol(x...).

Symbols غير قابلة للتغيير وتنفيذها يعيد استخدام نفس الكائن لجميع Symbols بنفس الاسم.

على عكس السلاسل النصية، فإن Symbols هي كيانات "ذرية" أو "عددية" لا تدعم التكرار عبر الأحرف.

Symbol(x...) -> Symbol

قم بإنشاء Symbol عن طريق دمج تمثيلات السلاسل الخاصة بالوسائط معًا.

أمثلة

julia> Symbol("my", "name")
:myname

julia> Symbol("day", 4)
:day4

الوحدة

الوحدة هي مساحة عمل متغيرات عالمية منفصلة. انظر module و قسم الدليل حول الوحدات للحصول على التفاصيل.

Module(name::Symbol=:anonymous, std_imports=true, default_names=true)

إرجاع وحدة بالاسم المحدد. baremodule يتوافق مع Module(:ModuleName, false)

يمكن إنشاء وحدة فارغة لا تحتوي على أي أسماء على الإطلاق باستخدام Module(:ModuleName, false, false). هذه الوحدة لن تستورد Base أو Core ولا تحتوي على مرجع لنفسها.

وظيفة

نوع مجرد لجميع الوظائف.

أمثلة

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin) (نوع فردي للدالة sin، نوع فرعي من Function)

julia> ans <: Function
true

hasmethod(f, t::Type{<:Tuple}[, kwnames]; world=get_world_counter()) -> Bool

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

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

انظر أيضًا applicable.

أمثلة

julia> hasmethod(length, Tuple{Array})
true

julia> f(; oranges=0) = oranges;

julia> hasmethod(f, Tuple{}, (:oranges,))
true

julia> hasmethod(f, Tuple{}, (:apples, :bananas))
false

julia> g(; xs...) = 4;

julia> hasmethod(g, Tuple{}, (:a, :b, :c, :d))  # g accepts arbitrary kwargs
true

applicable(f, args...) -> Bool

حدد ما إذا كانت الدالة العامة المعطاة تحتوي على طريقة قابلة للتطبيق على المعطيات المعطاة.

انظر أيضًا hasmethod.

أمثلة

julia> function f(x, y)
           x + y
       end;

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true

Base.isambiguous(m1, m2; ambiguous_bottom=false) -> Bool

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

بالنسبة للأنواع البرامترية، يتحكم وسيط الكلمة الرئيسية ambiguous_bottom في ما إذا كان Union{} يُعتبر تقاطعًا غامضًا لمتغيرات النوع - عندما يكون true، يُعتبر غامضًا، وعندما يكون false لا يُعتبر كذلك.

أمثلة

julia> foo(x::Complex{<:Integer}) = 1
foo (generic function with 1 method)

julia> foo(x::Complex{<:Rational}) = 2
foo (generic function with 2 methods)

julia> m1, m2 = collect(methods(foo));

julia> typeintersect(m1.sig, m2.sig)
Tuple{typeof(foo), Complex{Union{}}}

julia> Base.isambiguous(m1, m2, ambiguous_bottom=true)
true

julia> Base.isambiguous(m1, m2, ambiguous_bottom=false)
false

invoke(f, argtypes::Type, args...; kwargs...)

استدعاء طريقة للدالة العامة المعطاة f التي تطابق الأنواع المحددة argtypes على الوسائط المحددة args وتمرير الوسائط الرئيسية kwargs. يجب أن تتوافق الوسائط args مع الأنواع المحددة في argtypes، أي أن التحويل لا يتم تلقائيًا. تتيح هذه الطريقة استدعاء طريقة غير الأكثر تحديدًا المطابقة، وهو أمر مفيد عندما تكون سلوك تعريف أكثر عمومية مطلوبًا بشكل صريح (غالبًا كجزء من تنفيذ طريقة أكثر تحديدًا لنفس الدالة).

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

أمثلة

julia> f(x::Real) = x^2;

julia> f(x::Integer) = 1 + invoke(f, Tuple{Real}, x);

julia> f(2)
5

julia> f1(::Integer) = Integer
       f1(::Real) = Real;

julia> f2(x::Real) = _f2(x)
       _f2(::Integer) = Integer
       _f2(_) = Real;

julia> f1(1)
Integer

julia> f2(1)
Integer

julia> invoke(f1, Tuple{Real}, 1)
Real

julia> invoke(f2, Tuple{Real}, 1)
Integer

@invoke f(arg::T, ...; kwargs...)

يوفر وسيلة مريحة لاستدعاء invoke عن طريق توسيع @invoke f(arg1::T1, arg2::T2; kwargs...) إلى invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...). عندما يتم حذف نوع المعامل، يتم استبداله بـ Core.Typeof لذلك المعامل. لاستدعاء طريقة حيث يكون المعامل غير محدد النوع أو محدد صراحة كـ Any، قم بتعليق المعامل بـ ::Any.

كما أنه يدعم الصياغة التالية:

• @invoke (x::X).f يتوسع إلى invoke(getproperty, Tuple{X,Symbol}, x, :f)
• @invoke (x::X).f = v::V يتوسع إلى invoke(setproperty!, Tuple{X,Symbol,V}, x, :f, v)
• @invoke (xs::Xs)[i::I] يتوسع إلى invoke(getindex, Tuple{Xs,I}, xs, i)
• @invoke (xs::Xs)[i::I] = v::V يتوسع إلى invoke(setindex!, Tuple{Xs,V,I}, xs, v, i)

أمثلة

julia> @macroexpand @invoke f(x::T, y)
:(Core.invoke(f, Tuple{T, Core.Typeof(y)}, x, y))

julia> @invoke 420::Integer % Unsigned
0x00000000000001a4

julia> @macroexpand @invoke (x::X).f
:(Core.invoke(Base.getproperty, Tuple{X, Core.Typeof(:f)}, x, :f))

julia> @macroexpand @invoke (x::X).f = v::V
:(Core.invoke(Base.setproperty!, Tuple{X, Core.Typeof(:f), V}, x, :f, v))

julia> @macroexpand @invoke (xs::Xs)[i::I]
:(Core.invoke(Base.getindex, Tuple{Xs, I}, xs, i))

julia> @macroexpand @invoke (xs::Xs)[i::I] = v::V
:(Core.invoke(Base.setindex!, Tuple{Xs, V, I}, xs, v, i))

invokelatest(f, args...; kwargs...)

يستدعي f(args...; kwargs...)، ولكنه يضمن أن يتم تنفيذ أحدث طريقة لـ f. هذا مفيد في ظروف متخصصة، مثل حلقات الأحداث الطويلة أو دوال الاسترجاع التي قد تستدعي إصدارات قديمة من دالة f. (العيب هو أن invokelatest أبطأ قليلاً من استدعاء f مباشرة، ولا يمكن للمجمع استنتاج نوع النتيجة.)

@invokelatest f(args...; kwargs...)

يوفر وسيلة مريحة لاستدعاء invokelatest. سيتم توسيع @invokelatest f(args...; kwargs...) ببساطة إلى Base.invokelatest(f, args...; kwargs...).

كما أنه يدعم الصيغة التالية:

• @invokelatest x.f يتوسع إلى Base.invokelatest(getproperty, x, :f)
• @invokelatest x.f = v يتوسع إلى Base.invokelatest(setproperty!, x, :f, v)
• @invokelatest xs[i] يتوسع إلى Base.invokelatest(getindex, xs, i)
• @invokelatest xs[i] = v يتوسع إلى Base.invokelatest(setindex!, xs, v, i)

julia> @macroexpand @invokelatest f(x; kw=kwv)
:(Base.invokelatest(f, x; kw = kwv))

julia> @macroexpand @invokelatest x.f
:(Base.invokelatest(Base.getproperty, x, :f))

julia> @macroexpand @invokelatest x.f = v
:(Base.invokelatest(Base.setproperty!, x, :f, v))

julia> @macroexpand @invokelatest xs[i]
:(Base.invokelatest(Base.getindex, xs, i))

julia> @macroexpand @invokelatest xs[i] = v
:(Base.invokelatest(Base.setindex!, xs, v, i))

new، أو new{A,B,...}

دالة خاصة متاحة للبانيين الداخليين التي تنشئ كائنًا جديدًا من النوع. الشكل new{A,B,...} يحدد صراحةً قيم المعلمات لأنواع المعلمات. راجع قسم الدليل حول طرق الباني الداخلي لمزيد من المعلومات.

|>(x, f)

عامل infix الذي يطبق الدالة f على الوسيطة x. هذا يسمح بكتابة f(g(x)) كـ x |> g |> f. عند استخدامه مع الدوال المجهولة، عادة ما تكون الأقواس مطلوبة حول التعريف للحصول على السلسلة المقصودة.

أمثلة

julia> 4 |> inv
0.25

julia> [2, 3, 5] |> sum |> inv
0.1

julia> [0 1; 2 3] .|> (x -> x^2) |> sum
14

f ∘ g

تأليف الدوال: أي أن (f ∘ g)(args...; kwargs...) تعني f(g(args...; kwargs...)). يمكن إدخال الرمز ∘ في REPL الخاص بـ Julia (ومعظم المحررات، إذا تم تكوينها بشكل مناسب) عن طريق كتابة \circ<tab>.

تعمل تأليف الدوال أيضًا في الشكل البادئ: ∘(f, g) هو نفسه f ∘ g. يدعم الشكل البادئ تأليف دوال متعددة: ∘(f, g, h) = f ∘ g ∘ h وفتح ∘(fs...) لتأليف مجموعة قابلة للتكرار من الدوال. يتم تنفيذ آخر معطى لـ ∘ أولاً.

أمثلة

julia> map(uppercase∘first, ["apple", "banana", "carrot"])
3-element Vector{Char}:
 'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
 'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)
 'C': ASCII/Unicode U+0043 (category Lu: Letter, uppercase)

julia> (==(6)∘length).(["apple", "banana", "carrot"])
3-element BitVector:
 0
 1
 1

julia> fs = [
           x -> 2x
           x -> x-1
           x -> x/2
           x -> x+1
       ];

julia> ∘(fs...)(3)
2.0

انظر أيضًا ComposedFunction، !f::Function.

ComposedFunction{Outer,Inner} <: Function

يمثل تركيب كائنين قابلين للاستدعاء outer::Outer و inner::Inner. أي

ComposedFunction(outer, inner)(args...; kw...) === outer(inner(args...; kw...))

الطريقة المفضلة لإنشاء مثيل من ComposedFunction هي استخدام عامل التركيب ∘:

julia> sin ∘ cos === ComposedFunction(sin, cos)
true

julia> typeof(sin∘cos)
ComposedFunction{typeof(sin), typeof(cos)}

تُخزن الأجزاء المركبة في حقول ComposedFunction ويمكن استرجاعها كما يلي:

julia> composition = sin ∘ cos
sin ∘ cos

julia> composition.outer === sin
true

julia> composition.inner === cos
true

انظر أيضًا ∘.

splat(f)

يعادل

    my_splat(f) = args->f(args...)

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

أمثلة

julia> map(splat(+), zip(1:3,4:6))
3-element Vector{Int64}:
 5
 7
 9

julia> my_add = splat(+)
splat(+)

julia> my_add((1,2,3))
6

Fix1(f, x)

نوع يمثل نسخة جزئية التطبيق من الدالة ذات المعاملين f، مع تثبيت المعامل الأول على القيمة "x". بعبارة أخرى، فإن Fix1(f, x) يتصرف بشكل مشابه لـ y->f(x, y).

انظر أيضًا Fix2.

Fix2(f, x)

نوع يمثل نسخة جزئية التطبيق من الدالة ذات المعاملين f، مع تثبيت المعامل الثاني على القيمة "x". بعبارة أخرى، فإن Fix2(f, x) يتصرف بشكل مشابه لـ y->f(y, x).

Core.eval(m::Module, expr)

قم بتقييم تعبير في الوحدة المعطاة وأعد النتيجة.

eval(expr)

قم بتقييم تعبير في النطاق العالمي للوحدة المحتوية. كل Module (باستثناء تلك المعرفة باستخدام baremodule) لديها تعريف خاص بها من 1-حجة لـ eval، والذي يقوم بتقييم التعبيرات في تلك الوحدة.

@eval [mod,] ex

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

evalfile(path::AbstractString, args::Vector{String}=String[])

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

أمثلة

julia> write("testfile.jl", """
           @show ARGS
           1 + 1
       """);

julia> x = evalfile("testfile.jl", ["ARG1", "ARG2"]);
ARGS = ["ARG1", "ARG2"]

julia> x
2

julia> rm("testfile.jl")

esc(e)

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

@inbounds(blk)

يُلغي التحقق من حدود المصفوفة داخل التعبيرات.

في المثال أدناه، يتم تخطي التحقق من النطاق عند الإشارة إلى العنصر i من المصفوفة A لتحسين الأداء.

function sum(A::AbstractArray)
    r = zero(eltype(A))
    for i in eachindex(A)
        @inbounds r += A[i]
    end
    return r
end

!!! تحذير استخدام @inbounds قد يؤدي إلى نتائج غير صحيحة/تعطل/فساد للموشرات خارج الحدود. المستخدم مسؤول عن التحقق من ذلك يدويًا. استخدم @inbounds فقط عندما يكون من المؤكد من المعلومات المتاحة محليًا أن جميع الوصولات ضمن الحدود. على وجه الخصوص، استخدام 1:length(A) بدلاً من eachindex(A) في دالة مثل تلك أعلاه ليس ضمن الحدود بأمان لأن الفهرس الأول لـ A قد لا يكون 1 لجميع الأنواع المعرفة من قبل المستخدم التي تشتق من AbstractArray.

@boundscheck(blk)

يُعلّم التعبير blk ككتلة فحص حدود، مما يسمح بإلغائها بواسطة @inbounds.

!!! ملاحظة يجب أن تكون الدالة التي كُتبت فيها @boundscheck مضمنة في المتصل بها لكي يكون لـ @inbounds تأثير.

أمثلة

julia> @inline function g(A, i)
           @boundscheck checkbounds(A, i)
           return "accessing ($A)[$i]"
       end;

julia> f1() = return g(1:2, -1);

julia> f2() = @inbounds return g(1:2, -1);

julia> f1()
ERROR: BoundsError: attempt to access 2-element UnitRange{Int64} at index [-1]
Stacktrace:
 [1] throw_boundserror(::UnitRange{Int64}, ::Tuple{Int64}) at ./abstractarray.jl:455
 [2] checkbounds at ./abstractarray.jl:420 [inlined]
 [3] g at ./none:2 [inlined]
 [4] f1() at ./none:1
 [5] top-level scope

julia> f2()
"accessing (1:2)[-1]"

!!! تحذير يسمح لك توضيح @boundscheck، ككاتب مكتبة، بالاختيار للسماح لشفرة أخرى بإزالة فحوصات الحدود الخاصة بك باستخدام @inbounds. كما هو مذكور هناك، يجب على المتصل التحقق - باستخدام المعلومات التي يمكنهم الوصول إليها - من أن وصولاتهم صحيحة قبل استخدام @inbounds. على سبيل المثال، بالنسبة للفهرسة في فئات AbstractArray الفرعية الخاصة بك، يتضمن ذلك التحقق من الفهارس مقابل axes الخاصة بها. لذلك، يجب إضافة توضيحات @boundscheck فقط إلى تنفيذ getindex أو setindex! بعد أن تكون متأكدًا من أن سلوكها صحيح.

@propagate_inbounds

يخبر المترجم بإدراج دالة مع الاحتفاظ بسياق حدود المتصل.

@inline

أعطِ تلميحًا للمترجم بأن هذه الدالة تستحق أن تُدرج.

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

يمكن تطبيق @inline مباشرةً قبل تعريف دالة أو داخل جسم دالة.

# توضيح تعريف طويل
@inline function longdef(x)
    ...
end

# توضيح تعريف قصير
@inline shortdef(x) = ...

# توضيح دالة مجهولة ينشئها كتلة `do`
f() do
    @inline
    ...
end

@inline block

أعطِ تلميحًا للمترجم بأن الاستدعاءات داخل block تستحق أن تُدرج.

# سيحاول المترجم إدراج `f`
@inline f(...)

# سيحاول المترجم إدراج `f` و `g` و `+`
@inline f(...) + g(...)

@noinline function explicit_noinline(args...)
    # الجسم
end

let
    @inline explicit_noinline(args...) # سيتم إدراجه
end

@noinline let a0, b0 = ...
    a = @inline f(a0)  # سيحاول المترجم إدراج هذا الاستدعاء
    b = f(b0)          # لن يحاول المترجم إدراج هذا الاستدعاء
    return a, b
end

@noinline

أعطِ تلميحًا للمترجم بأنه يجب ألا يقوم بإدماج دالة.

عادةً ما يتم إدماج الدوال الصغيرة تلقائيًا. من خلال استخدام @noinline على الدوال الصغيرة، يمكن منع الإدماج التلقائي.

يمكن تطبيق @noinline مباشرةً قبل تعريف دالة أو داخل جسم دالة.

# توضيح تعريف طويل
@noinline function longdef(x)
    ...
end

# توضيح تعريف قصير
@noinline shortdef(x) = ...

# توضيح دالة مجهولة ينشئها كتلة `do`
f() do
    @noinline
    ...
end

@noinline block

أعطِ تلميحًا للمترجم بأنه يجب ألا يقوم بإدماج الاستدعاءات داخل block.

# سيحاول المترجم عدم إدماج `f`
@noinline f(...)

# سيحاول المترجم عدم إدماج `f` و `g` و `+`
@noinline f(...) + g(...)

@inline function explicit_inline(args...)
    # الجسم
end

let
    @noinline explicit_inline(args...) # لن يتم إدماجها
end

@inline let a0, b0 = ...
    a = @noinline f(a0)  # لن يحاول المترجم إدماج هذا الاستدعاء
    b = f(b0)            # سيحاول المترجم إدماج هذا الاستدعاء
    return a, b
end

@nospecialize

عند تطبيقها على اسم وسيط دالة، تشير إلى المترجم بأن تنفيذ الطريقة يجب ألا يكون متخصصًا لأنواع مختلفة من ذلك الوسيط، بل يجب استخدام النوع المعلن لذلك الوسيط. يمكن تطبيقها على وسيط ضمن قائمة الوسائط الرسمية، أو في جسم الدالة. عند تطبيقها على وسيط، يجب أن يحيط الماكرو بالتعبير الكامل للوسيط، مثل @nospecialize(x::Real) أو @nospecialize(i::Integer...) بدلاً من إحاطة اسم الوسيط فقط. عند استخدامها في جسم الدالة، يجب أن يحدث الماكرو في موضع البيان وقبل أي كود.

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

يمكن إعادة التخصص إلى الوضع الافتراضي باستخدام @specialize.

function example_function(@nospecialize x)
    ...
end

function example_function(x, @nospecialize(y = 1))
    ...
end

function example_function(x, y, z)
    @nospecialize x y
    ...
end

@nospecialize
f(y) = [x for x in y]
@specialize

!!! ملاحظة @nospecialize تؤثر على توليد الكود ولكن ليس على الاستدلال: إنها تحد من تنوع الكود الأصلي الناتج، لكنها لا تفرض أي قيود (بخلاف القيود القياسية) على استدلال النوع. استخدم Base.@nospecializeinfer مع @nospecialize لقمع الاستدلال بشكل إضافي.

أمثلة

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Float64
└──      return %1
) => Float64

هنا، تؤدي تعليمة @nospecialize إلى ما يعادل

f(A::AbstractArray) = invoke(g, Tuple{AbstractArray}, A)

م ensuring that only one version of native code will be generated for g, one that is generic for any AbstractArray. ومع ذلك، لا يزال يتم استنتاج نوع الإرجاع المحدد لكل من g و f، ولا يزال يتم استخدام هذا في تحسين المتصلين بـ f و g.

@specialize

إعادة تعيين تلميح التخصص لوسيط إلى القيمة الافتراضية. لمزيد من التفاصيل، انظر @nospecialize.

Base.@nospecializeinfer function f(args...)
    @nospecialize ...
    ...
end
Base.@nospecializeinfer f(@nospecialize args...) = ...

يخبر المترجم باستنتاج f باستخدام الأنواع المعلنة للوسائط @nospecialize. يمكن استخدام ذلك للحد من عدد التخصصات التي ينشئها المترجم أثناء الاستنتاج.

أمثلة

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline Base.@nospecializeinfer g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Any
└──      return %1
) => Any

في هذا المثال، سيتم استنتاج f لكل نوع محدد من A، ولكن سيتم استنتاج g مرة واحدة فقط مع نوع الوسيط المعلن A::AbstractArray، مما يعني أن المترجم لن يرى على الأرجح الوقت الزائد للاستنتاج عليه بينما لا يمكنه استنتاج نوع الإرجاع المحدد له. بدون @nospecializeinfer، كان من الممكن أن يستنتج f([1.0]) نوع الإرجاع لـ g كـ Float64، مما يشير إلى أن الاستنتاج تم على g(::Vector{Float64}) على الرغم من الحظر على إنشاء كود متخصص.

Base.@constprop إعداد [ex]

تحكم في وضع انتشار الثوابت بين الإجراءات للدالة المعلنة.

يدعم اثنان من الإعدادات:

• Base.@constprop :aggressive [ex]: تطبيق انتشار الثوابت بشكل عدواني. بالنسبة لطريقة تعتمد نوع الإرجاع على قيمة المعاملات، يمكن أن يؤدي ذلك إلى تحسين نتائج الاستدلال على حساب وقت التجميع الإضافي.
• Base.@constprop :none [ex]: تعطيل انتشار الثوابت. يمكن أن يقلل ذلك من أوقات التجميع للدوال التي قد تعتبرها جوليا جديرة بانتشار الثوابت. الحالات الشائعة هي للدوال التي تحتوي على معاملات ذات قيم Bool أو Symbol أو معاملات مفتاحية.

يمكن تطبيق Base.@constprop مباشرة قبل تعريف دالة أو داخل جسم دالة.

# توضيح تعريف طويل
Base.@constprop :aggressive function longdef(x)
    ...
end

# توضيح تعريف قصير
Base.@constprop :aggressive shortdef(x) = ...

# توضيح دالة مجهولة ينشئها كتلة `do`
f() do
    Base.@constprop :aggressive
    ...
end

gensym([tag])

يولد رمزًا لن يتعارض مع أسماء المتغيرات الأخرى (في نفس الوحدة).

@gensym

يولد رمز gensym لمتغير. على سبيل المثال، يتم تحويل @gensym x y إلى x = gensym("x"); y = gensym("y").

var

تشير الصيغة var"#example#" إلى متغير يسمى Symbol("#example#")، على الرغم من أن #example# ليس اسم معرف صالح في جوليا.

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

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

لاحظ أن هذه الصيغة تتطلب دعم المحلل، لذا يتم توسيعها مباشرة بواسطة المحلل بدلاً من تنفيذها كـ ماكرو سلسلة عادية @var_str.

@goto name

@goto name يقفز بلا شروط إلى العبارة في الموقع @label name.

لا يمكن لـ @label و @goto إنشاء قفزات إلى عبارات من المستوى الأعلى المختلفة. محاولات القيام بذلك تسبب خطأ. لاستخدام @goto، قم بتضمين @label و @goto في كتلة.

@label name

يضع علامة على بيان بالعلامة الرمزية name. تشير العلامة إلى نقطة النهاية لانتقال غير مشروط باستخدام @goto name.

@simd

قم بتعليق حلقة for للسماح للمترجم بأخذ حريات إضافية للسماح بإعادة ترتيب الحلقات

!!! تحذير هذه الميزة تجريبية وقد تتغير أو تختفي في الإصدارات المستقبلية من جوليا. قد يتسبب الاستخدام غير الصحيح لماكرو @simd في نتائج غير متوقعة.

يجب أن يكون الكائن الذي يتم التكرار عليه في حلقة @simd for نطاقًا أحادي البعد. من خلال استخدام @simd، أنت تؤكد عدة خصائص للحلقة:

• من الآمن تنفيذ التكرارات بترتيب عشوائي أو متداخل، مع اعتبار خاص لمتغيرات الاختزال.
• يمكن إعادة ترتيب أو تقليص العمليات العائمة على متغيرات الاختزال، مما قد يتسبب في نتائج مختلفة مقارنةً بدون @simd.

في العديد من الحالات، تتمكن جوليا من تحويل الحلقات الداخلية تلقائيًا إلى شكل متجه دون استخدام @simd. يمنح استخدام @simd المترجم مزيدًا من الحرية لجعل ذلك ممكنًا في المزيد من الحالات. في كلتا الحالتين، يجب أن تحتوي حلقتك الداخلية على الخصائص التالية للسماح بالتوجيه المتجه:

• يجب أن تكون الحلقة حلقة داخلية.
• يجب أن يكون جسم الحلقة كودًا خطيًا. لذلك، @inbounds مطلوب حاليًا لجميع الوصولات إلى المصفوفات. يمكن أن يقوم المترجم أحيانًا بتحويل تعبيرات && و || و ?: القصيرة إلى كود خطي إذا كان من الآمن تقييم جميع المعاملات بشكل غير مشروط. ضع في اعتبارك استخدام دالة ifelse بدلاً من ?: في الحلقة إذا كان من الآمن القيام بذلك.
• يجب أن تحتوي الوصولات على نمط خطوة ولا يمكن أن تكون "تجمعات" (قراءات عشوائية) أو "تشتتات" (كتابات عشوائية).
• يجب أن تكون الخطوة خطوة وحدة.

!!! ملاحظة لا يؤكد @simd بشكل افتراضي أن الحلقة خالية تمامًا من الاعتماديات على الذاكرة التي تحملها الحلقة، وهو افتراض يمكن انتهاكه بسهولة في الكود العام. إذا كنت تكتب كودًا غير عام، يمكنك استخدام @simd ivdep for ... end لتأكيد أيضًا أن:

• لا توجد اعتمادات على الذاكرة تحملها الحلقة
• لا تنتظر أي تكرار على تكرار سابق لتحقيق تقدم للأمام.

@polly

يخبر المترجم بتطبيق المحسّن متعدد الأبعاد بولي على دالة.

@generated f

@generated يُستخدم لوصف دالة سيتم إنشاؤها. في جسم الدالة المُنشأة، يمكن قراءة أنواع المعاملات فقط (وليس القيم). الدالة تُرجع تعبيرًا مُقتبسًا يتم تقييمه عند استدعاء الدالة. يجب عدم استخدام ماكرو @generated على الدوال التي تُغير النطاق العالمي أو تعتمد على عناصر قابلة للتغيير.

انظر Metaprogramming لمزيد من التفاصيل.

أمثلة

julia> @generated function bar(x)
           if x <: Integer
               return :(x ^ 2)
           else
               return :(x)
           end
       end
bar (generic function with 1 method)

julia> bar(4)
16

julia> bar("baz")
"baz"

Base.@assume_effects إعداد... [ex]

تجاوز نمذجة تأثير المترجم. يمكن استخدام هذه الماكرو في عدة سياقات:

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

أمثلة

julia> Base.@assume_effects :terminates_locally function fact(x)
           # الاستخدام 1:
           # هذا :terminates_locally يسمح لـ `fact` بأن يتم طيّه بشكل ثابت
           res = 1
           0 ≤ x < 20 || error("خطأ في العامل")
           while x > 1
               res *= x
               x -= 1
           end
           return res
       end
fact (generic function with 1 method)

julia> code_typed() do
           fact(12)
       end |> only
CodeInfo(
1 ─     return 479001600
) => Int64

julia> code_typed() do
           map((2,3,4)) do x
               # الاستخدام 2:
               # هذا :terminates_locally يسمح لهذه الدالة المجهولة بأن يتم طيّها بشكل ثابت
               Base.@assume_effects :terminates_locally
               res = 1
               0 ≤ x < 20 || error("خطأ في العامل")
               while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

julia> code_typed() do
           map((2,3,4)) do x
               res = 1
               0 ≤ x < 20 || error("خطأ في العامل")
               # الاستخدام 3:
               # مع هذه التعليمة :terminates_locally يتجاوز المترجم تلوين
               # تأثير `:terminates` داخل هذه الكتلة `while`، مما يسمح للدالة
               # المجهولة الأم بأن يتم طيّها بشكل ثابت
               Base.@assume_effects :terminates_locally while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

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

القيم setting التالية مدعومة.

• :consistent
• :effect_free
• :nothrow
• :terminates_globally
• :terminates_locally
• :notaskstate
• :inaccessiblememonly
• :noub
• :noub_if_noinbounds
• :nortcall
• :foldable
• :removable
• :total

مساعدة موسعة

:consistent

تؤكد إعداد :consistent أنه بالنسبة للمدخلات المتساوية (===):

• طريقة إنهاء التنفيذ (قيمة الإرجاع، استثناء، عدم إنهاء) ستكون دائمًا هي نفسها.
• إذا كانت الطريقة تعيد قيمة، فستكون النتائج دائمًا متساوية.

:effect_free

تؤكد إعداد :effect_free أن الطريقة خالية من الآثار الجانبية المرئية بشكل خارجي. القائمة التالية غير مكتملة من الآثار الجانبية المرئية بشكل خارجي:

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

ومع ذلك، فإن ما يلي ليس مرئيًا بشكل صريح، حتى لو كان يمكن ملاحظته:

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

قاعدة الإبهام هنا هي أن أي تأثير جانبي مرئي خارجي هو أي شيء قد يؤثر على تنفيذ بقية البرنامج إذا لم يتم تنفيذ الدالة.

:nothrow

تؤكد إعداد :nothrow أن هذه الطريقة لا تلقي استثناء (أي ستعيد دائمًا قيمة أو لن تعيد أبدًا).

:terminates_globally

تؤكد إعداد :terminates_globally أن هذه الطريقة ستنتهي في النهاية (إما بشكل طبيعي أو غير طبيعي)، أي أنها لا تتكرر إلى ما لا نهاية.

:terminates_locally

تعتبر إعداد :terminates_locally مثل :terminates_globally، باستثناء أنها تنطبق فقط على تدفق التحكم النحوي داخل الطريقة المعلّمة. وبالتالي، فهي تأكيد أضعف بكثير (وبالتالي أكثر أمانًا) يسمح بإمكانية عدم الإنهاء إذا استدعت الطريقة بعض الطرق الأخرى التي لا تنتهي.

:notaskstate

تؤكد إعداد :notaskstate أن الطريقة لا تستخدم أو تعدل حالة المهمة المحلية (تخزين محلي للمهمة، حالة RNG، إلخ) وبالتالي يمكن نقلها بأمان بين المهام دون نتائج مرئية.

:inaccessiblememonly

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

:noub

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

:nortcall

تؤكد إعداد :nortcall أن الطريقة لا تستدعي Core.Compiler.return_type، وأن أي طرق أخرى قد تستدعيها هذه الطريقة لا تستدعي أيضًا Core.Compiler.return_type.

:foldable

تعتبر هذه الإعدادات اختصارًا مريحًا لمجموعة التأثيرات التي يتطلبها المترجم لضمان طي ثابت لاستدعاء في وقت الترجمة. وهي حاليًا تعادل الإعدادات التالية:

• :consistent
• :effect_free
• :terminates_globally
• :noub
• :nortcall

:removable

تعتبر هذه الإعدادات اختصارًا مريحًا لمجموعة التأثيرات التي يتطلبها المترجم لضمان حذف استدعاء لم يتم استخدام نتيجته في وقت الترجمة. وهي حاليًا تعادل الإعدادات التالية:

• :effect_free
• :nothrow
• :terminates_globally

:total

تعتبر هذه الإعدادات أقصى مجموعة ممكنة من التأثيرات. وهي حاليًا تعني الإعدادات الأخرى التالية:

• :consistent
• :effect_free
• :nothrow
• :terminates_globally
• :notaskstate
• :inaccessiblememonly
• :noub
• :nortcall

التأثيرات المنفية

يمكن أن يتم تمييز أسماء التأثيرات بواسطة ! للإشارة إلى أن التأثير يجب أن يتم إزالته من تأثير ميتا سابق. على سبيل المثال، :total !:nothrow تشير إلى أنه بينما يكون الاستدعاء بشكل عام كليًا، إلا أنه قد يلقي استثناء.

@deprecate old new [export_old=true]

قم بإلغاء استخدام الطريقة old وحدد استدعاء الاستبدال new، مع تعريف طريقة جديدة old بالتوقيع المحدد في هذه العملية.

لمنع تصدير old، قم بتعيين export_old إلى false.

انظر أيضًا Base.depwarn().

أمثلة

julia> @deprecate old(x) new(x)
old (generic function with 1 method)

julia> @deprecate old(x) new(x) false
old (generic function with 1 method)

ستحدد الاستدعاءات إلى @deprecate بدون توضيحات نوع صريحة طرقًا ملغاة تقبل أي عدد من الوسائط الموضعية ووسائط الكلمات الرئيسية من النوع Any.

لتقييد إلغاء الاستخدام لتوقيع محدد، قم بتعليق الوسائط الخاصة بـ old. على سبيل المثال،

julia> new(x::Int) = x;

julia> new(x::Float64) = 2x;

julia> @deprecate old(x::Int) new(x);

julia> methods(old)
# 1 method for generic function "old" from Main:
 [1] old(x::Int64)
     @ deprecated.jl:94

سيحدد ويُلغي استخدام طريقة old(x::Int) التي تعكس new(x::Int) ولكن لن يُعرّف أو يُلغي استخدام الطريقة old(x::Float64).

Base.depwarn(msg::String, funcsym::Symbol; force=false)

اطبع msg كتحذير من الإهمال. يجب أن يكون الرمز funcsym هو اسم الدالة المستدعاة، والتي تُستخدم لضمان أن تحذير الإهمال يتم طباعته فقط في المرة الأولى لكل مكان استدعاء. قم بتعيين force=true لفرض عرض التحذير دائمًا، حتى لو تم بدء جوليا مع --depwarn=no (الإعداد الافتراضي).

انظر أيضًا @deprecate.

أمثلة

function deprecated_func()
    Base.depwarn("لا تستخدم `deprecated_func()`!", :deprecated_func)

    1 + 1
end

مفقود

نوع بلا حقول يتم استخدام مثيله الفردي missing لتمثيل القيم المفقودة.

انظر أيضًا: skipmissing، nonmissingtype، Nothing.

مفقود

مثيل فردي من النوع Missing يمثل قيمة مفقودة.

انظر أيضًا: NaN، skipmissing، nonmissingtype.

coalesce(x...)

ارجع أول قيمة في المعطيات التي لا تساوي missing، إذا وُجدت. وإلا ارجع missing.

انظر أيضًا skipmissing، something، @coalesce.

أمثلة

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # يرجع `nothing`

julia> coalesce(missing, missing)
missing

@coalesce(x...)

نسخة قصيرة من coalesce.

أمثلة

julia> f(x) = (println("f($x)"); missing);

julia> a = 1;

julia> a = @coalesce a f(2) f(3) error("`a` is still missing")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b` is still missing")
f(2)
f(3)
ERROR: `b` is still missing
[...]

ismissing(x)

حدد ما إذا كان x هو missing.

انظر أيضًا: skipmissing، isnothing، isnan.

skipmissing(itr)

إرجاع مُكرّر على العناصر في itr متجاوزًا قيم missing. يمكن فهرسة الكائن المُرجع باستخدام مؤشرات itr إذا كان الأخير قابلًا للفهرسة. المؤشرات التي تتوافق مع القيم المفقودة غير صالحة: يتم تخطيها بواسطة keys وeachindex، ويتم إلقاء استثناء MissingException عند محاولة استخدامها.

استخدم collect للحصول على Array تحتوي على القيم غير المفقودة في itr. لاحظ أنه حتى إذا كانت itr مصفوفة متعددة الأبعاد، فإن النتيجة ستكون دائمًا Vector لأنه لا يمكن إزالة القيم المفقودة مع الحفاظ على أبعاد الإدخال.

انظر أيضًا coalesce، ismissing، something.

أمثلة

julia> x = skipmissing([1, missing, 2])
skipmissing(Union{Missing, Int64}[1, missing, 2])

julia> sum(x)
3

julia> x[1]
1

julia> x[2]
ERROR: MissingException: the value at index (2,) is missing
[...]

julia> argmax(x)
3

julia> collect(keys(x))
2-element Vector{Int64}:
 1
 3

julia> collect(skipmissing([1, missing, 2]))
2-element Vector{Int64}:
 1
 2

julia> collect(skipmissing([1 missing; 2 missing]))
2-element Vector{Int64}:
 1
 2

nonmissingtype(T::Type)

إذا كان T هو اتحاد من الأنواع يحتوي على Missing، قم بإرجاع نوع جديد مع إزالة Missing.

أمثلة

julia> nonmissingtype(Union{Int64,Missing})
Int64

julia> nonmissingtype(Any)
Any

run(command, args...; wait::Bool = true)

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

تسمح لك args... بتمرير موصّلات الملفات إلى الأمر، وهي مرتبة مثل موصّلات الملفات العادية في يونكس (مثل stdin, stdout, stderr, FD(3), FD(4)...).

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

عندما يكون wait خاطئًا، يتم توجيه تدفقات الإدخال/الإخراج للعملية إلى devnull. عندما يكون wait صحيحًا، يتم مشاركة تدفقات الإدخال/الإخراج مع العملية الأصلية. استخدم pipeline للتحكم في إعادة توجيه الإدخال/الإخراج.

devnull

يستخدم في إعادة توجيه التدفق للتخلص من جميع البيانات المكتوبة إليه. يعادل بشكل أساسي /dev/null على أنظمة Unix أو NUL على Windows. الاستخدام:

run(pipeline(`cat test.txt`, devnull))

success(command)

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

process_running(p::Process)

تحديد ما إذا كانت العملية تعمل حاليًا.

process_exited(p::Process)

تحديد ما إذا كانت العملية قد انتهت.

kill(p::Process, signum=Base.SIGTERM)

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

Sys.set_process_title(title::AbstractString)

قم بتعيين عنوان العملية. لا تفعل شيئًا على بعض أنظمة التشغيل.

Sys.get_process_title()

احصل على عنوان العملية. في بعض الأنظمة، سيعيد دائمًا سلسلة فارغة.

ignorestatus(command)

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

detach(command)

قم بتمييز كائن الأمر بحيث يتم تشغيله في مجموعة عمليات جديدة، مما يسمح له بالاستمرار بعد عملية جوليا، وعدم تمرير مقاطعات Ctrl-C إليه.

Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir)
Cmd(exec::Vector{String})

قم بإنشاء كائن Cmd جديد، يمثل برنامجًا خارجيًا وحججه، من cmd، مع تغيير إعدادات الوسائط الاختيارية:

• ignorestatus::Bool: إذا كانت true (افتراضيًا false)، فلن يقوم Cmd بإلقاء خطأ إذا كانت قيمة الإرجاع غير صفر.
• detach::Bool: إذا كانت true (افتراضيًا false)، فسيتم تشغيل Cmd في مجموعة عمليات جديدة، مما يسمح له بالاستمرار في الحياة بعد عملية julia وعدم تمرير Ctrl-C إليه.
• windows_verbatim::Bool: إذا كانت true (افتراضيًا false)، فإن Cmd على نظام Windows سيرسل سلسلة سطر الأوامر إلى العملية دون اقتباس أو هروب للحجج، حتى الحجج التي تحتوي على مسافات. (على نظام Windows، يتم إرسال الحجج إلى البرنامج كسلسلة "سطر أوامر" واحدة، والبرامج مسؤولة عن تحليلها إلى حجج. بشكل افتراضي، يتم اقتباس الحجج الفارغة والحجج التي تحتوي على مسافات أو علامات تبويب بعلامات اقتباس مزدوجة " في سطر الأوامر، و \ أو " يتم تقديمها بواسطة شرائح خلفية. windows_verbatim=true مفيد لتشغيل البرامج التي تحلل سطر الأوامر الخاص بها بطرق غير قياسية.) ليس له تأثير على الأنظمة غير العاملة بنظام Windows.
• windows_hide::Bool: إذا كانت true (افتراضيًا false)، فلن يتم عرض نافذة وحدة تحكم جديدة عند تنفيذ Cmd على نظام Windows. ليس له تأثير إذا كانت وحدة تحكم مفتوحة بالفعل أو على الأنظمة غير العاملة بنظام Windows.
• env: تعيين متغيرات البيئة لاستخدامها عند تشغيل Cmd. env هو إما قاموس يربط السلاسل بالسلاسل، أو مصفوفة من السلاسل على شكل "var=val"، أو مصفوفة أو مجموعة من أزواج "var"=>val. لتعديل (بدلاً من استبدال) البيئة الحالية، قم بتهيئة env باستخدام copy(ENV) ثم قم بتعيين env["var"]=val حسب الرغبة. لإضافة إلى كتلة البيئة داخل كائن Cmd دون استبدال جميع العناصر، استخدم addenv() الذي سيعيد كائن Cmd مع البيئة المحدثة.
• dir::AbstractString: تحديد دليل عمل للأمر (بدلاً من الدليل الحالي).

بالنسبة لأي كلمات رئيسية لم يتم تحديدها، يتم استخدام الإعدادات الحالية من cmd.

لاحظ أن مُنشئ Cmd(exec) لا ينشئ نسخة من exec. ستنعكس أي تغييرات لاحقة على exec في كائن Cmd.

أكثر الطرق شيوعًا لإنشاء كائن Cmd هي باستخدام الحروف الأمرية (علامات الاقتباس العكسية)، على سبيل المثال:

`ls -l`

يمكن بعد ذلك تمرير هذا إلى مُنشئ Cmd لتعديل إعداداته، على سبيل المثال:

Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)

setenv(command::Cmd, env; dir)

قم بتعيين متغيرات البيئة لاستخدامها عند تشغيل الأمر المعطى command. env إما أن يكون قاموسًا يربط السلاسل بسلاسل، أو مصفوفة من السلاسل بالشكل "var=val"، أو صفر أو أكثر من أزواج المعاملات "var"=>val. من أجل تعديل (بدلاً من استبدال) البيئة الحالية، قم بإنشاء env من خلال copy(ENV) ثم تعيين env["var"]=val كما هو مطلوب، أو استخدم addenv.

يمكن استخدام معامل الكلمة الرئيسية dir لتحديد دليل العمل للأمر. dir افتراضيًا هو dir المحدد حاليًا لـ command (وهو دليل العمل الحالي إذا لم يتم تحديده بالفعل).

انظر أيضًا Cmd، addenv، ENV، pwd.

addenv(command::Cmd, env...; inherit::Bool = true)

ادمج خرائط البيئة الجديدة في كائن Cmd المعطى، مع إرجاع كائن Cmd جديد. يتم استبدال المفاتيح المكررة. إذا لم يحتوي command على أي قيم بيئية تم تعيينها مسبقًا، فإنه يرث البيئة الحالية في وقت استدعاء addenv() إذا كان inherit هو true. يتم حذف المفاتيح التي تحتوي على قيمة nothing من البيئة.

انظر أيضًا Cmd، setenv، ENV.

withenv(f, kv::Pair...)

نفذ f في بيئة تم تعديلها مؤقتًا (وليس استبدالها كما في setenv) بواسطة صفر أو أكثر من الوسائط "var"=>val kv. يتم استخدام withenv عمومًا عبر بناء الجملة withenv(kv...) do ... end. يمكن استخدام قيمة nothing لإلغاء تعيين متغير بيئي مؤقتًا (إذا كان مضبوطًا). عند عودة withenv، تم استعادة البيئة الأصلية.

!!! تحذير تغيير البيئة ليس آمنًا في الخيوط. لتشغيل الأوامر الخارجية ببيئة مختلفة عن عملية الوالد، يُفضل استخدام addenv بدلاً من withenv.

setcpuaffinity(original_command::Cmd, cpus) -> command::Cmd

قم بتعيين تفضيل وحدة المعالجة المركزية لـ command بواسطة قائمة من معرفات وحدة المعالجة المركزية (1-based) cpus. يعني تمرير cpus = nothing إلغاء تعيين تفضيل وحدة المعالجة المركزية إذا كان لدى original_command أي منها.

تدعم هذه الوظيفة فقط في Linux و Windows. لا يتم دعمها في macOS لأن libuv لا يدعم تعيين التفضيل.

أمثلة

في Linux، يمكن استخدام برنامج سطر الأوامر taskset لرؤية كيفية عمل setcpuaffinity.

julia> run(setcpuaffinity(`sh -c 'taskset -p $$'`, [1, 2, 5]));
pid 2273's current affinity mask: 13

لاحظ أن قيمة القناع 13 تعكس أن البتات الأولى والثانية والخامسة (بالعد من الموضع الأقل أهمية) مضاءة:

julia> 0b010011
0x13

pipeline(from, to, ...)

أنشئ خط أنابيب من مصدر بيانات إلى وجهة. يمكن أن تكون المصدر والوجهة أوامر، تدفقات إدخال/إخراج، سلاسل نصية، أو نتائج استدعاءات أخرى لـ pipeline. يجب أن يكون هناك على الأقل وسيط واحد هو أمر. تشير السلاسل النصية إلى أسماء الملفات. عند استدعائها بأكثر من وسيطين، يتم ربطها معًا من اليسار إلى اليمين. على سبيل المثال، pipeline(a,b,c) يعادل pipeline(pipeline(a,b),c). يوفر هذا طريقة أكثر اختصارًا لتحديد خطوط أنابيب متعددة المراحل.

أمثلة:

run(pipeline(`ls`, `grep xyz`))
run(pipeline(`ls`, "out.txt"))
run(pipeline("out.txt", `grep xyz`))

pipeline(command; stdin, stdout, stderr, append=false)

إعادة توجيه الإدخال/الإخراج إلى أو من command المعطى. تحدد الوسائط الرئيسية أي من تدفقات الأمر يجب إعادة توجيهها. يتحكم append في ما إذا كان إخراج الملف يضاف إلى الملف. هذه نسخة أكثر عمومية من دالة pipeline ذات الوسيطين. pipeline(from, to) تعادل pipeline(from, stdout=to) عندما يكون from أمرًا، و pipeline(to, stdin=from) عندما يكون from نوعًا آخر من مصادر البيانات.

أمثلة:

run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
run(pipeline(`update`, stdout="log.txt", append=true))

gethostname() -> String

احصل على اسم المضيف لجهاز الكمبيوتر المحلي.

getpid() -> Int32

احصل على معرف عملية جوليا.

getpid(process) -> Int32

احصل على معرف عملية الطفل، إذا كانت لا تزال موجودة.

time() -> Float64

احصل على وقت النظام بالثواني منذ العصر، بدقة عالية (عادةً، ميكروثانية).

time_ns() -> UInt64

احصل على الوقت بالنانوثانية. الوقت المقابل لـ 0 غير محدد، ويتكرر كل 5.8 سنوات.

@time expr
@time "description" expr

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

يمكنك اختيارياً تقديم سلسلة وصفية للطباعة قبل تقرير الوقت.

في بعض الحالات، ستنظر النظام داخل تعبير @time وتجمع بعض الكود المستدعى قبل بدء تنفيذ التعبير على المستوى الأعلى. عندما يحدث ذلك، لن يتم احتساب بعض وقت التجميع. لتضمين هذا الوقت يمكنك تشغيل @time @eval ....

انظر أيضًا @showtime، @timev، @timed، @elapsed، @allocated، و @allocations.

!!! ملاحظة من أجل قياس الأداء بشكل أكثر جدية، ضع في اعتبارك ماكرو @btime من حزمة BenchmarkTools.jl التي تقيم الوظيفة عدة مرات من أجل تقليل الضوضاء.

!!! توافق "جوليا 1.8" تم تقديم خيار إضافة وصف في جوليا 1.8.

تم تقديم وقت إعادة التجميع الذي يظهر بشكل منفصل عن وقت التجميع في جوليا 1.8.

!!! توافق "جوليا 1.11" تم إضافة تقرير أي تعارضات في القفل في جوليا 1.11.

julia> x = rand(10,10);

julia> @time x * x;
  0.606588 seconds (2.19 M allocations: 116.555 MiB, 3.75% gc time, 99.94% compilation time)

julia> @time x * x;
  0.000009 seconds (1 allocation: 896 bytes)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 seconds (8 allocations: 336 bytes)
2

julia> @time "A one second sleep" sleep(1)
A one second sleep: 1.005750 seconds (5 allocations: 144 bytes)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 seconds (5 allocations: 144 bytes)
2: 1.001263 seconds (5 allocations: 144 bytes)
3: 1.003676 seconds (5 allocations: 144 bytes)

@showtime expr

مثل @time ولكنه يطبع أيضًا التعبير الذي يتم تقييمه للرجوع إليه.

انظر أيضًا @time.

julia> @showtime sleep(1)
sleep(1): 1.002164 seconds (4 allocations: 128 bytes)

@timev expr
@timev "description" expr

هذه نسخة مفصلة من ماكرو @time. أولاً، تطبع نفس المعلومات مثل @time، ثم أي عدادات تخص تخصيص الذاكرة غير الصفرية، ثم تعيد قيمة التعبير.

يمكنك اختيارياً تقديم سلسلة وصف لطباعة قبل تقرير الوقت.

انظر أيضًا @time، @timed، @elapsed، @allocated، و@allocations.

julia> x = rand(10,10);

julia> @timev x * x;
  0.546770 seconds (2.20 M allocations: 116.632 MiB, 4.23% gc time, 99.94% compilation time)
elapsed time (ns): 546769547
gc time (ns):      23115606
bytes allocated:   122297811
pool allocs:       2197930
non-pool GC allocs:1327
malloc() calls:    36
realloc() calls:   5
GC pauses:         3

julia> @timev x * x;
  0.000010 seconds (1 allocation: 896 bytes)
elapsed time (ns): 9848
bytes allocated:   896
pool allocs:       1

@timed

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

في بعض الحالات، ستنظر النظام داخل تعبير @timed وتجمع بعض الشيفرات المستدعاة قبل بدء تنفيذ التعبير على المستوى الأعلى. عندما يحدث ذلك، لن يتم احتساب بعض وقت التجميع. لتضمين هذا الوقت يمكنك تشغيل @timed @eval ....

انظر أيضًا @time، @timev، @elapsed، @allocated، @allocations، و@lock_conflicts.

julia> stats = @timed rand(10^6);

julia> stats.time
0.006634834

julia> stats.bytes
8000256

julia> stats.gctime
0.0055765

julia> propertynames(stats.gcstats)
(:allocd, :malloc, :realloc, :poolalloc, :bigalloc, :freecall, :total_time, :pause, :full_sweep)

julia> stats.gcstats.total_time
5576500

julia> stats.compile_time
0.0

julia> stats.recompile_time
0.0

@elapsed

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

في بعض الحالات، سينظر النظام داخل تعبير @elapsed ويقوم بتجميع بعض الشيفرات المستدعاة قبل بدء تنفيذ التعبير على المستوى الأعلى. عندما يحدث ذلك، لن يتم احتساب بعض وقت التجميع. لتضمين هذا الوقت يمكنك تشغيل @elapsed @eval ....

انظر أيضًا @time، @timev، @timed، @allocated، و @allocations.

julia> @elapsed sleep(0.3)
0.301391426

@allocated

ماكرو لتقييم تعبير، متجاهلاً القيمة الناتجة، بدلاً من ذلك إرجاع العدد الإجمالي للبايتات المخصصة أثناء تقييم التعبير.

انظر أيضًا @allocations، @time، @timev، @timed، و@elapsed.

julia> @allocated rand(10^6)
8000080

@allocations

ماكرو لتقييم تعبير، والتخلص من القيمة الناتجة، وبدلاً من ذلك إرجاع العدد الإجمالي للتخصيصات أثناء تقييم التعبير.

انظر أيضًا @allocated، @time، @timev، @timed، و@elapsed.

julia> @allocations rand(10^6)
2

@lock_conflicts

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

انظر أيضًا @time، @timev و @timed.

julia> @lock_conflicts begin
    l = ReentrantLock()
    Threads.@threads for i in 1:Threads.nthreads()
        lock(l) do
        sleep(1)
        end
    end
end
5

EnvDict() -> EnvDict

يوفر كائن مفرد من هذا النوع واجهة جدول تجزئة لمتغيرات البيئة.

ENV

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

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

!!! تحذير تعديل البيئة غير آمن في سياق متعدد الخيوط.

أمثلة

julia> ENV
Base.EnvDict with "50" entries:
  "SECURITYSESSIONID"            => "123"
  "USER"                         => "username"
  "MallocNanoZone"               => "0"
  ⋮                              => ⋮

julia> ENV["JULIA_EDITOR"] = "vim"
"vim"

julia> ENV["JULIA_EDITOR"]
"vim"

انظر أيضًا: withenv، addenv.

Sys.STDLIB::String

سلسلة تحتوي على المسار الكامل إلى الدليل الذي يحتوي على حزم stdlib.

Sys.isunix([os])

عبارة لاختبار ما إذا كان نظام التشغيل يوفر واجهة شبيهة بـ Unix. راجع الوثائق في Handling Operating System Variation.

Sys.isapple([os])

عبارة لاختبار ما إذا كان نظام التشغيل هو مشتق من نظام تشغيل أبل ماكنتوش OS X أو داروين. راجع الوثائق في Handling Operating System Variation.

Sys.islinux([os])

عبارة لاختبار ما إذا كان نظام التشغيل مشتقًا من لينكس. راجع الوثائق في التعامل مع اختلافات نظام التشغيل.

Sys.isbsd([os])

عبارة لاختبار ما إذا كان نظام التشغيل مشتقًا من BSD. راجع الوثائق في التعامل مع اختلافات نظام التشغيل.

!!! ملاحظة نواة داروين تنحدر من BSD، مما يعني أن Sys.isbsd() تكون true على أنظمة macOS. لاستبعاد macOS من العبارة، استخدم Sys.isbsd() && !Sys.isapple().

Sys.isfreebsd([os])

عبارة لاختبار ما إذا كان نظام التشغيل مشتقًا من FreeBSD. راجع الوثائق في Handling Operating System Variation.

!!! ملاحظة لا ينبغي الخلط بينه وبين Sys.isbsd()، الذي يكون true على FreeBSD ولكن أيضًا على أنظمة BSD الأخرى. تشير Sys.isfreebsd() فقط إلى FreeBSD.

!!! توافق "جوليا 1.1" تتطلب هذه الوظيفة على الأقل جوليا 1.1.

Sys.isopenbsd([os])

دالة لاختبار ما إذا كان نظام التشغيل مشتقًا من OpenBSD. راجع الوثائق في Handling Operating System Variation.

!!! ملاحظة لا تخلط بين Sys.isbsd()، التي تكون true على OpenBSD ولكن أيضًا على أنظمة BSD الأخرى. تشير Sys.isopenbsd() فقط إلى OpenBSD.

!!! توافق "جوليا 1.1" تتطلب هذه الدالة على الأقل جوليا 1.1.

Sys.isnetbsd([os])

دالة لاختبار ما إذا كان نظام التشغيل مشتقًا من NetBSD. راجع الوثائق في Handling Operating System Variation.

!!! ملاحظة لا تخلط بين Sys.isbsd()، التي تكون true على NetBSD ولكن أيضًا على أنظمة BSD الأخرى. تشير Sys.isnetbsd() فقط إلى NetBSD.

!!! توافق "جوليا 1.1" تتطلب هذه الدالة على الأقل جوليا 1.1.

Sys.isdragonfly([os])

عبارة لاختبار ما إذا كان نظام التشغيل هو مشتق من DragonFly BSD. راجع الوثائق في Handling Operating System Variation.

!!! ملاحظة لا تخلط بينه وبين Sys.isbsd()، الذي يكون true على DragonFly ولكن أيضًا على أنظمة أخرى قائمة على BSD. تشير Sys.isdragonfly() فقط إلى DragonFly.

!!! توافق "جوليا 1.1" تتطلب هذه الوظيفة على الأقل جوليا 1.1.

Sys.iswindows([os])

عبارة لاختبار ما إذا كان نظام التشغيل مشتقًا من Microsoft Windows NT. راجع الوثائق في Handling Operating System Variation.

Sys.windows_version()

إرجاع رقم الإصدار لنواة Windows NT كـ VersionNumber، أي v"major.minor.build"، أو v"0.0.0" إذا لم يكن هذا يعمل على Windows.

Sys.free_memory()

احصل على إجمالي الذاكرة الحرة في RAM بالبايت.

Sys.total_memory()

احصل على إجمالي الذاكرة في RAM (بما في ذلك ما هو مستخدم حاليًا) بالبايت. قد يكون هذا المبلغ مقيدًا، على سبيل المثال، بواسطة مجموعات التحكم في Linux. للحصول على المبلغ غير المقيد، انظر Sys.total_physical_memory().

Sys.free_physical_memory()

احصل على الذاكرة الحرة للنظام بالبايت. قد لا تكون الكمية الكاملة متاحة للعملية الحالية؛ استخدم Sys.free_memory() للكمية المتاحة فعليًا.

Sys.total_physical_memory()

احصل على إجمالي الذاكرة في RAM (بما في ذلك ما هو مستخدم حاليًا) بالبايت. قد لا تكون الكمية الكاملة متاحة للعملية الحالية؛ انظر Sys.total_memory().

Sys.uptime()

يحصل على وقت تشغيل النظام الحالي بالثواني.

Sys.isjsvm([os])

عبارة لاختبار ما إذا كانت جوليا تعمل في بيئة JavaScript VM (JSVM)، بما في ذلك على سبيل المثال، تضمين JavaScript WebAssembly في متصفح الويب.

Sys.loadavg()

احصل على متوسط الحمل. انظر: https://en.wikipedia.org/wiki/Load_(computing).

isexecutable(path::String)

ارجع true إذا كان path المعطى لديه أذونات تنفيذ.

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

!!! ملاحظة قبل Julia 1.6، لم يكن هذا يستجوب ACLs نظام الملفات بشكل صحيح على Windows، لذلك كان سيعيد true لأي ملف. بدءًا من Julia 1.6، يحدد بشكل صحيح ما إذا كان الملف مُعَلَّمًا كتنفيذي أم لا.

انظر أيضًا ispath، isreadable، iswritable.

isreadable(path::String)

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

انظر أيضًا ispath، isexecutable، iswritable.

isreadable(io) -> Bool

ارجع false إذا كان كائن IO المحدد غير قابل للقراءة.

أمثلة

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           isreadable(io)
       end
false

julia> open("myfile.txt", "r") do io
           isreadable(io)
       end
true

julia> rm("myfile.txt")

iswritable(path::String)

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

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

!!! ملاحظة حالياً، لا تستجوب هذه الدالة ACLs نظام الملفات بشكل صحيح على Windows، لذلك قد تعيد نتائج خاطئة.

!!! توافق "جوليا 1.11" تتطلب هذه الدالة على الأقل جوليا 1.11.

انظر أيضًا ispath، isexecutable، isreadable.

iswritable(io) -> Bool

ارجع false إذا كان كائن IO المحدد غير قابل للكتابة.

أمثلة

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           iswritable(io)
       end
true

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")

Sys.username() -> String

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

لاسترجاع اسم مستخدم يمكن تجاوزه عبر متغير بيئة، مثل USER، يُفضل استخدام

user = get(Sys.username, ENV, "USER")

انظر أيضًا homedir.

@static

قم بتقييم تعبير جزئيًا في وقت التحليل.

على سبيل المثال، @static Sys.iswindows() ? foo : bar سيقوم بتقييم Sys.iswindows() وإدراج إما foo أو bar في التعبير. هذا مفيد في الحالات التي سيكون فيها البناء غير صالح على منصات أخرى، مثل ccall إلى دالة غير موجودة. @static if Sys.isapple() foo end و @static foo <&&,||> bar هما أيضًا بناء صحيح.

رقم الإصدار

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

يمكن مقارنة كائنات VersionNumber مع جميع عوامل المقارنة القياسية (==، <، <=، إلخ)، مع اتباع النتيجة لقواعد semver.

يمتلك VersionNumber الحقول العامة التالية:

• v.major::Integer
• v.minor::Integer
• v.patch::Integer
• v.prerelease::Tuple{Vararg{Union{Integer, AbstractString}}}
• v.build::Tuple{Vararg{Union{Integer, AbstractString}}}

انظر أيضًا @v_str لبناء كائنات VersionNumber بكفاءة من سلاسل نصية بتنسيق semver، وVERSION لرقم الإصدار الخاص بـ Julia، والأدلة الخاصة برقم الإصدار في الدليل.

أمثلة

julia> a = VersionNumber(1, 2, 3)
v"1.2.3"

julia> a >= v"1.2"
true

julia> b = VersionNumber("2.0.1-rc1")
v"2.0.1-rc1"

julia> b >= v"2.0.1"
false

@v_str

ماكرو السلسلة المستخدم لتحليل سلسلة إلى VersionNumber.

أمثلة

julia> v"1.2.3"
v"1.2.3"

julia> v"2.0.1-rc1"
v"2.0.1-rc1"

error(message::AbstractString)

رفع ErrorException مع الرسالة المعطاة.

error(msg...)

رفع ErrorException برسالة تم إنشاؤها بواسطة string(msg...).

throw(e)

إلقاء كائن كاستثناء.

انظر أيضًا: rethrow، error.

rethrow()

إعادة رمي الاستثناء الحالي من داخل كتلة catch. سيستمر الاستثناء المعاد رميه في الانتشار كما لو لم يتم التقاطه.

!!! ملاحظة الشكل البديل rethrow(e) يتيح لك ربط كائن استثناء بديل e مع تتبع الأخطاء الحالي. ومع ذلك، فإن هذا يسيء تمثيل حالة البرنامج في وقت الخطأ، لذا يُشجع على بدلاً من ذلك رمي استثناء جديد باستخدام throw(e). في جوليا 1.1 وما فوق، سيحافظ استخدام throw(e) على استثناء السبب الجذري في المكدس، كما هو موضح في current_exceptions.

backtrace()

احصل على كائن تتبع للخلف لنقطة البرنامج الحالية.

catch_backtrace()

احصل على تتبع الأخطاء للاستثناء الحالي، للاستخدام داخل كتل catch.

current_exceptions(task::Task=current_task(); [backtrace::Bool=true])

احصل على مكدس الاستثناءات التي يتم التعامل معها حاليًا. بالنسبة لكتل catch المتداخلة، قد يكون هناك أكثر من استثناء حالي واحد، وفي هذه الحالة يكون الاستثناء الذي تم طرحه مؤخرًا هو الأخير في المكدس. يتم إرجاع المكدس كـ ExceptionStack، وهو عبارة عن AbstractVector من التوائم المسماة (exception,backtrace). إذا كان backtrace غير صحيح، فسيتم تعيين تتبع الاستثناء في كل زوج إلى nothing.

سوف يؤدي تمرير task بشكل صريح إلى إرجاع مكدس الاستثناءات الحالي على مهمة عشوائية. هذا مفيد لفحص المهام التي فشلت بسبب استثناءات غير معالجة.

@assert cond [text]

ارمِ AssertionError إذا كانت cond false. هذه هي الصيغة المفضلة لكتابة التأكيدات، وهي شروط يُفترض أن تكون صحيحة، ولكن قد يقرر المستخدم التحقق منها على أي حال، كوسيلة للمساعدة في تصحيح الأخطاء إذا فشلت. يتم عرض الرسالة الاختيارية text عند فشل التأكيد.

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

أمثلة

julia> @assert iseven(3) "3 is an odd number!"
ERROR: AssertionError: 3 is an odd number!

julia> @assert isodd(3) "What even are numbers?"

Experimental.register_error_hint(handler, exceptiontype)

سجل دالة "تلميح" handler(io, exception) التي يمكن أن تقترح طرقًا محتملة للمستخدمين لتجاوز الأخطاء. يجب على handler فحص exception لمعرفة ما إذا كانت الشروط المناسبة للحصول على تلميح متوفرة، وإذا كان الأمر كذلك، توليد مخرجات إلى io. يجب على الحزم استدعاء register_error_hint من داخل دالة __init__.

بالنسبة لأنواع الاستثناءات المحددة، يُطلب من handler قبول معلمات إضافية:

• MethodError: قدم handler(io, exc::MethodError, argtypes, kwargs)، الذي يقسم المعلمات المجمعة إلى معلمات موضعية ومعلمات مفتاحية.

عند إصدار تلميح، يجب أن تبدأ المخرجات عادةً بـ \n.

إذا قمت بتعريف أنواع استثناءات مخصصة، يمكن لطريقة showerror الخاصة بك دعم التلميحات عن طريق استدعاء Experimental.show_error_hints.

أمثلة

julia> module Hinter

       only_int(x::Int)      = 1
       any_number(x::Number) = 2

       function __init__()
           Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
               if exc.f == only_int
                    # اللون ليس ضروريًا، هذا فقط لإظهار أنه ممكن.
                    print(io, "\nهل كنت تقصد استدعاء ")
                    printstyled(io, "`any_number`؟", color=:cyan)
               end
           end
       end

       end

ثم إذا قمت باستدعاء Hinter.only_int على شيء ليس Int (مما يؤدي إلى تحفيز MethodError)، فإنه يصدر التلميح:

julia> Hinter.only_int(1.0)
ERROR: MethodError: no method matching only_int(::Float64)
The function `only_int` exists, but no method is defined for this combination of argument types.
هل كنت تقصد استدعاء `any_number`؟
أقرب المرشحين هم:
    ...

Experimental.show_error_hints(io, ex, args...)

استدعاء جميع المعالجات من Experimental.register_error_hint لنوع الاستثناء المحدد typeof(ex). يجب أن تحتوي args على أي معلمات أخرى متوقعة من قبل المعالج لذلك النوع.

ArgumentError(msg)

الوسائط المرسلة إلى الدالة غير صالحة. msg هو رسالة خطأ وصفية.

AssertionError([msg])

الشرط الذي تم التحقق منه لم يقيم إلى true. الوسيطة الاختيارية msg هي سلسلة خطأ وصفية.

أمثلة

julia> @assert false "this is not true"
ERROR: AssertionError: this is not true

عادةً ما يتم رمي AssertionError من @assert. ```

BoundsError([a],[i])

عملية فهرسة في مصفوفة، a، حاولت الوصول إلى عنصر خارج الحدود عند الفهرس i.

أمثلة

julia> A = fill(1.0, 7);

julia> A[8]
ERROR: BoundsError: attempt to access 7-element Vector{Float64} at index [8]


julia> B = fill(1.0, (2,3));

julia> B[2, 4]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [2, 4]


julia> B[9]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [9]

CompositeException

قم بتغليف Vector من الاستثناءات التي تم طرحها بواسطة Task (على سبيل المثال، التي تم إنشاؤها من عامل بعيد عبر قناة أو كتابة إدخال/إخراج محلية تنفذ بشكل غير متزامن أو عامل بعيد تحت pmap) مع معلومات حول سلسلة الاستثناءات. على سبيل المثال، إذا كانت مجموعة من العمال تنفذ عدة مهام، وفشل عدة عمال، فإن CompositeException الناتجة ستحتوي على "حزمة" من المعلومات من كل عامل تشير إلى مكان وسبب حدوث الاستثناءات.

DimensionMismatch([msg])

الأشياء التي تم استدعاؤها لا تتطابق في الأبعاد. الوسيطة الاختيارية msg هي سلسلة خطأ وصفية.

DivideError()

تمت محاولة القسمة الصحيحة مع قيمة المقام 0.

أمثلة

julia> 2/0
Inf

julia> div(2, 0)
ERROR: DivideError: integer division error
Stacktrace:
[...]

DomainError(val)
DomainError(val, msg)

الحجة val إلى دالة أو مُنشئ خارج النطاق الصالح.

أمثلة

julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrt تم استدعاؤه بحجة حقيقية سالبة ولكنه سيعيد نتيجة معقدة فقط إذا تم استدعاؤه بحجة معقدة. حاول sqrt(Complex(x)).
Stacktrace:
[...]

EOFError()

لم يكن هناك المزيد من البيانات المتاحة للقراءة من ملف أو تدفق.

ErrorException(msg)

نوع خطأ عام. قد توفر رسالة الخطأ، في حقل .msg، تفاصيل أكثر تحديدًا.

أمثلة

julia> ex = ErrorException("لقد قمت بشيء سيء");

julia> ex.msg
"لقد قمت بشيء سيء"

InexactError(name::Symbol, T, val)

لا يمكن تحويل val بدقة إلى النوع T في طريقة من دالة name.

أمثلة

julia> convert(Float64, 1+2im)
ERROR: InexactError: Float64(1 + 2im)
Stacktrace:
[...]

InterruptException()

تم إيقاف العملية بواسطة مقاطعة من الطرفية (CTRL+C).

لاحظ أنه في نص جولي الذي بدأ بدون خيار -i (تفاعلي)، لا يتم رمي InterruptException بشكل افتراضي. يمكن استدعاء Base.exit_on_sigint(false) في النص لاستعادة سلوك REPL. بدلاً من ذلك، يمكن بدء نص جولي مع

julia -e "include(popfirst!(ARGS))" script.jl

لجعل InterruptException يتم رميه بواسطة CTRL+C أثناء التنفيذ.

KeyError(key)

عملية الفهرسة في AbstractDict (Dict) أو كائن مشابه لـ Set حاولت الوصول إلى عنصر غير موجود أو حذفه.

LoadError(file::AbstractString, line::Int, error)

حدث خطأ أثناء include أو require أو using ملف. يجب أن تكون تفاصيل الخطأ متاحة في حقل .error.

MethodError(f, args)

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

MissingException(msg)

استثناء يُرمى عندما يتم مواجهة قيمة missing في حالة لا تدعمها. قد يوفر رسالة الخطأ، في حقل msg، تفاصيل أكثر تحديدًا.

OutOfMemoryError()

تم تخصيص عملية ما لذاكرة زائدة عن الحد بحيث لا يمكن للنظام أو لجمع القمامة التعامل معها بشكل صحيح.

ReadOnlyMemoryError()

حاولت عملية الكتابة إلى ذاكرة للقراءة فقط.

OverflowError(msg)

نتيجة تعبير ما كبيرة جدًا بالنسبة لنوع البيانات المحدد وستسبب التفافًا.

ProcessFailedException

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

TaskFailedException

يتم طرح هذا الاستثناء بواسطة مكالمة wait(t) عندما يفشل المهمة t. يقوم TaskFailedException بتغليف المهمة الفاشلة t.

StackOverflowError()

تجاوز استدعاء الدالة حجم مكدس الاستدعاءات. يحدث هذا عادةً عندما يتكرر الاستدعاء بلا حدود.

SystemError(prefix::AbstractString, [errno::Int32])

فشلت مكالمة النظام مع رمز خطأ (في المتغير العالمي errno).

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

فشل في تأكيد النوع، أو استدعاء دالة داخلية مع نوع وسيط غير صحيح.

UndefKeywordError(var::Symbol)

لم يتم تعيين وسيط الكلمة الرئيسية المطلوب var في استدعاء الدالة.

أمثلة

julia> function my_func(;my_arg)
           return my_arg + 1
       end
my_func (generic function with 1 method)

julia> my_func()
ERROR: UndefKeywordError: keyword argument `my_arg` not assigned
Stacktrace:
 [1] my_func() at ./REPL[1]:2
 [2] top-level scope at REPL[2]:1

UndefRefError()

العنصر أو الحقل غير معرف للكائن المعطى.

أمثلة

julia> struct MyType
           a::Vector{Int}
           MyType() = new()
       end

julia> A = MyType()
MyType(#undef)

julia> A.a
ERROR: UndefRefError: access to undefined reference
Stacktrace:
[...]

UndefVarError(var::Symbol, [scope])

رمز في النطاق الحالي غير معرف.

أمثلة

julia> a
ERROR: UndefVarError: `a` not defined in `Main`

julia> a = 1;

julia> a
1

StringIndexError(str, i)

حدث خطأ عند محاولة الوصول إلى str عند الفهرس i الذي ليس صالحًا.

InitError(mod::Symbol, error)

حدث خطأ عند تشغيل دالة __init__ لوحدة. الخطأ الفعلي الذي تم طرحه متاح في حقل .error.

retry(f;  delays=ExponentialBackOff(), check=nothing) -> Function

إرجاع دالة غير مسماة تستدعي الدالة f. إذا حدث استثناء، يتم استدعاء f مرة أخرى، في كل مرة تعيد فيها check القيمة true، بعد الانتظار لعدد الثواني المحددة في delays. يجب أن تأخذ check الحالة الحالية لـ delays و Exception كمدخلات.

أمثلة

retry(f, delays=fill(5.0, 3))
retry(f, delays=rand(5:10, 2))
retry(f, delays=Base.ExponentialBackOff(n=3, first_delay=5, max_delay=1000))
retry(http_get, check=(s,e)->e.status == "503")(url)
retry(read, check=(s,e)->isa(e, IOError))(io, 128; all=false)

ExponentialBackOff(; n=1, first_delay=0.05, max_delay=10.0, factor=5.0, jitter=0.1)

مكرر Float64 بطول n حيث تزداد عناصره بشكل أسي بمعدل في الفترة factor * (1 ± jitter). العنصر الأول هو first_delay وجميع العناصر مقيدة بـ max_delay.

Timer(callback::Function, delay; interval = 0)

أنشئ مؤقتًا يقوم بتشغيل الدالة callback عند انتهاء كل مؤقت.

تستيقظ المهام المنتظرة وتُستدعى الدالة callback بعد تأخير أولي قدره delay ثوانٍ، ثم تتكرر مع الفاصل الزمني المحدد بالثواني. إذا كان interval يساوي 0، فإن الدالة callback تُشغل مرة واحدة فقط. تُستدعى الدالة callback مع وسيط واحد، وهو المؤقت نفسه. أوقف المؤقت عن طريق استدعاء close. قد لا تزال الدالة callback تُشغل مرة أخيرة، إذا كان المؤقت قد انتهى بالفعل.

أمثلة

هنا يتم طباعة الرقم الأول بعد تأخير قدره ثانيتين، ثم يتم طباعة الأرقام التالية بسرعة.

julia> begin
           i = 0
           cb(timer) = (global i += 1; println(i))
           t = Timer(cb, 2, interval=0.2)
           wait(t)
           sleep(0.5)
           close(t)
       end
1
2
3

Timer(delay; interval = 0)

أنشئ مؤقتًا يوقظ المهام التي تنتظرها (عن طريق استدعاء wait على كائن المؤقت).

تستيقظ المهام المنتظرة بعد تأخير أولي لا يقل عن delay ثوانٍ، ثم تتكرر بعد مرور لا يقل عن interval ثوانٍ مرة أخرى. إذا كان interval يساوي 0، يتم تفعيل المؤقت مرة واحدة فقط. عند إغلاق المؤقت (عن طريق close)، يتم إيقاظ المهام المنتظرة بخطأ. استخدم isopen للتحقق مما إذا كان المؤقت لا يزال نشطًا.