I/O and Network

stdout::IO

متغير عالمي يشير إلى تدفق الإخراج القياسي.

stderr::IO

متغير عالمي يشير إلى تدفق الخطأ القياسي.

stdin::IO

متغير عالمي يشير إلى تدفق الإدخال القياسي.

read(filename::AbstractString)

اقرأ المحتويات الكاملة لملف كـ Vector{UInt8}.

read(filename::AbstractString, String)

اقرأ المحتويات الكاملة لملف كسلسلة نصية.

read(filename::AbstractString, args...)

افتح ملفًا واقرأ محتوياته. يتم تمرير args إلى read: هذا يعادل open(io->read(io, args...), filename).

write(filename::AbstractString, content)

اكتب التمثيل الثنائي القياسي لـ content إلى ملف، والذي سيتم إنشاؤه إذا لم يكن موجودًا بعد أو سيتم الكتابة فوقه إذا كان موجودًا.

أعد عدد البايتات المكتوبة في الملف.

open(f::Function, args...; kwargs...)

قم بتطبيق الدالة f على نتيجة open(args...; kwargs...) وأغلق موصل الملف الناتج عند الانتهاء.

أمثلة

julia> write("myfile.txt", "Hello world!");

julia> open(io->read(io, String), "myfile.txt")
"Hello world!"

julia> rm("myfile.txt")

open(filename::AbstractString; lock = true, keywords...) -> IOStream

افتح ملفًا في وضع محدد بواسطة خمسة معلمات مفتاحية من نوع بولي:

الافتراضي عند عدم تمرير أي كلمات مفتاحية هو فتح الملفات للقراءة فقط. يُرجع دفقًا للوصول إلى الملف المفتوح.

تتحكم معلمة الكلمة المفتاحية lock فيما إذا كانت العمليات ستُقفل للوصول الآمن متعدد الخيوط.

open(filename::AbstractString, [mode::AbstractString]; lock = true) -> IOStream

صيغة بديلة لـ open، حيث يتم استخدام محدد وضع قائم على السلسلة بدلاً من الخمسة قيم البوليانية. تتوافق قيم mode مع تلك الموجودة في fopen(3) أو Perl open، وهي تعادل تعيين مجموعات البوليان التالية:

تتحكم حجة الكلمة الرئيسية lock في ما إذا كانت العمليات ستُقفل للوصول الآمن متعدد الخيوط.

أمثلة

julia> io = open("myfile.txt", "w");

julia> write(io, "Hello world!");

julia> close(io);

julia> io = open("myfile.txt", "r");

julia> read(io, String)
"Hello world!"

julia> write(io, "This file is read only")
ERROR: ArgumentError: write failed, IOStream is not writeable
[...]

julia> close(io)

julia> io = open("myfile.txt", "a");

julia> write(io, "This stream is not read only")
28

julia> close(io)

julia> rm("myfile.txt")

open(fd::OS_HANDLE) -> IO

خذ مقبض ملف خام ولفه في نوع IO مدرك لجوليا، وتولى ملكية مقبض fd. استدعِ open(Libc.dup(fd)) لتجنب التقاط الملكية من المقبض الأصلي.

!!! تحذير لا تستدعي هذا على مقبض مملوك بالفعل من قبل جزء آخر من النظام.

open(command, mode::AbstractString, stdio=devnull)

قم بتشغيل command بشكل غير متزامن. مثل open(command, stdio; read, write) باستثناء تحديد علامات القراءة والكتابة عبر سلسلة وضع بدلاً من الوسائط الرئيسية. سلاسل الوضع الممكنة هي:

open(command, stdio=devnull; write::Bool = false, read::Bool = !write)

ابدأ تشغيل command بشكل غير متزامن، وأعد كائن process::IO. إذا كانت read صحيحة، فإن القراءة من العملية تأتي من المخرجات القياسية للعملية وstdio يحدد اختياريًا دفق الإدخال القياسي للعملية. إذا كانت write صحيحة، فإن الكتابات تذهب إلى الإدخال القياسي للعملية وstdio يحدد اختياريًا دفق المخرجات القياسية للعملية. دفق الأخطاء القياسية للعملية متصل بـ stderr العالمي الحالي.

open(f::Function, command, args...; kwargs...)

مشابه لـ open(command, args...; kwargs...)، ولكن يستدعي f(stream) على تدفق العملية الناتج، ثم يغلق تدفق الإدخال وينتظر حتى تكتمل العملية. يُرجع القيمة التي تُرجعها f عند النجاح. يُلقي خطأ إذا فشلت العملية، أو إذا حاولت العملية طباعة أي شيء إلى stdout.

IOStream

تدفق IO مؤقت يلتف حول موصِّل ملف نظام التشغيل. يُستخدم بشكل أساسي لتمثيل الملفات التي يتم إرجاعها بواسطة open.

IOBuffer([data::AbstractVector{UInt8}]; keywords...) -> IOBuffer

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

يمكن أن تأخذ معلمات اختيارية:

• read, write, append: تقيد العمليات على المخزن المؤقت؛ انظر open للتفاصيل.
• truncate: يقطع حجم المخزن المؤقت إلى طول صفر.
• maxsize: يحدد حجمًا لا يمكن أن يتجاوز المخزن المؤقت.
• sizehint: يقترح سعة المخزن المؤقت (data يجب أن تنفذ sizehint!(data, size)).

عندما لا يتم إعطاء data، سيكون المخزن المؤقت قابلًا للقراءة والكتابة بشكل افتراضي.

أمثلة

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

julia> io = IOBuffer(b"JuliaLang is a GitHub organization.")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=35, maxsize=Inf, ptr=1, mark=-1)

julia> read(io, String)
"JuliaLang is a GitHub organization."

julia> write(io, "This isn't writable.")
ERROR: ArgumentError: ensureroom failed, IOBuffer is not writeable

julia> io = IOBuffer(UInt8[], read=true, write=true, maxsize=34)
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=34, ptr=1, mark=-1)

julia> write(io, "JuliaLang is a GitHub organization.")
34

julia> String(take!(io))
"JuliaLang is a GitHub organization"

julia> length(read(IOBuffer(b"data", read=true, truncate=false)))
4

julia> length(read(IOBuffer(b"data", read=true, truncate=true)))
0

IOBuffer(string::String)

إنشاء IOBuffer للقراءة فقط على البيانات الأساسية للسلسلة المعطاة.

أمثلة

julia> io = IOBuffer("Haho");

julia> String(take!(io))
"Haho"

julia> String(take!(io))
"Haho"

take!(b::IOBuffer)

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

أمثلة

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.", " It has many members.")
56

julia> String(take!(io))
"JuliaLang is a GitHub organization. It has many members."

Pipe()

قم بإنشاء كائن Pipe غير مُهيأ، خاصةً للتواصل IO بين عمليات متعددة.

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

julia> err = Pipe()

# بعد ذلك، سيتم تهيئة `err` ويمكنك قراءة `foo`'s
# stderr من أنبوب `err`، أو تمرير `err` إلى خطوط أنابيب أخرى.
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# الآن دمر النصف الكتابي من الأنبوب، بحيث يحصل النصف القارئ على EOF
julia> closewrite(err)

julia> read(err, String)
"stderr messages"

انظر أيضًا Base.link_pipe!.

link_pipe!(pipe; reader_supports_async=false, writer_supports_async=false)

قم بتهيئة pipe وربط نقطة النهاية in بنقطة النهاية out. تتوافق الوسائط الرئيسية reader_supports_async/writer_supports_async مع OVERLAPPED على نظام Windows و O_NONBLOCK على أنظمة POSIX. يجب أن تكون true ما لم يتم استخدامها بواسطة برنامج خارجي (على سبيل المثال، ناتج أمر تم تنفيذه باستخدام run).

fdio([name::AbstractString, ]fd::Integer[, own::Bool=false]) -> IOStream

قم بإنشاء كائن IOStream من موصِّل ملف صحيح. إذا كان own هو true، فإن إغلاق هذا الكائن سيغلق الموصل الأساسي. بشكل افتراضي، يتم إغلاق IOStream عندما يتم جمعه بواسطة جامع القمامة. يسمح لك name بربط الموصل بملف مسمى.

flush(stream)

قم بتأكيد جميع الكتابات المخزنة مؤقتًا حاليًا إلى الدفق المعطى.

close(stream)

إغلاق تدفق الإدخال/الإخراج. يتم تنفيذ flush أولاً.

closewrite(stream)

إغلاق نصف الكتابة من دفق الإدخال/الإخراج ثنائي الاتجاه. يتم تنفيذ flush أولاً. إخطار الطرف الآخر بأنه لن يتم كتابة المزيد من البيانات إلى الملف الأساسي. هذا غير مدعوم من قبل جميع أنواع الإدخال/الإخراج.

إذا تم تنفيذها، فإن closewrite يتسبب في أن تستدعي المكالمات اللاحقة لـ read أو eof التي كانت ستعلق بدلاً من ذلك برمي EOF أو إرجاع true، على التوالي. إذا كان الدفق مغلقًا بالفعل، فإن هذا يكون غير مؤثر.

أمثلة

julia> io = Base.BufferStream(); # هذا لا يعلق أبدًا، لذا يمكننا القراءة والكتابة على نفس المهمة

julia> write(io, "request");

julia> # استدعاء `read(io)` هنا سيعلق إلى الأبد

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

اكتب التمثيل الثنائي القياسي لقيمة إلى دفق الإدخال/الإخراج أو الملف المعطى. ارجع بعدد البايتات المكتوبة في الدفق. انظر أيضًا print لكتابة تمثيل نصي (مع ترميز قد يعتمد على io).

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

يمكنك كتابة قيم متعددة بنفس استدعاء write. أي أن ما يلي متساوي:

write(io, x, y...)
write(io, x) + write(io, y...)

أمثلة

تسلسل متسق:

julia> fname = tempname(); # اسم ملف مؤقت عشوائي

julia> open(fname,"w") do f
           # تأكد من أننا نكتب عدد صحيح 64 بت بترتيب بايت صغير
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # تحويل مرة أخرى إلى ترتيب بايت المضيف ونوع عدد صحيح المضيف
           Int(ltoh(read(f,Int64)))
       end
42

دمج استدعاءات الكتابة:

julia> io = IOBuffer();

julia> write(io, "JuliaLang هي منظمة على GitHub.", " لديها العديد من الأعضاء.")
56

julia> String(take!(io))
"JuliaLang هي منظمة على GitHub. لديها العديد من الأعضاء."

julia> write(io, "أحيانًا هؤلاء الأعضاء") + write(io, " يكتبون الوثائق.")
44

julia> String(take!(io))
"أحيانًا هؤلاء الأعضاء يكتبون الوثائق."

يمكن كتابة أنواع البيانات البسيطة المعرفة من قبل المستخدم بدون طرق write عندما تكون مغلفة في Ref:

julia> struct MyStruct; x::Float64; end

julia> io = IOBuffer()
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=0, maxsize=Inf, ptr=1, mark=-1)

julia> write(io, Ref(MyStruct(42.0)))
8

julia> seekstart(io); read!(io, Ref(MyStruct(NaN)))
Base.RefValue{MyStruct}(MyStruct(42.0))

read(io::IO, T)

اقرأ قيمة واحدة من النوع T من io، في التمثيل الثنائي القياسي.

لاحظ أن جوليا لا تقوم بتحويل ترتيب البايتات من أجلك. استخدم ntoh أو ltoh لهذا الغرض.

read(io::IO, String)

اقرأ كل محتويات io، كـ String (انظر أيضًا readchomp).

أمثلة

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> read(io, Char)
'J': ASCII/Unicode U+004A (الفئة Lu: حرف، كبير)

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> read(io, String)
"JuliaLang is a GitHub organization"

read(filename::AbstractString)

اقرأ المحتويات الكاملة لملف كـ Vector{UInt8}.

read(filename::AbstractString, String)

اقرأ المحتويات الكاملة لملف كسلسلة نصية.

read(filename::AbstractString, args...)

افتح ملفًا واقرأ محتوياته. يتم تمرير args إلى read: هذا يعادل open(io->read(io, args...), filename).

read(s::IO, nb=typemax(Int))

اقرأ في أقصى حد nb بايت من s، مع إرجاع Vector{UInt8} من البايتات المقروءة.

read(s::IOStream, nb::Integer; all=true)

اقرأ في أقصى حد nb بايت من s، معيدًا Vector{UInt8} من البايتات المقروءة.

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

read(command::Cmd)

قم بتشغيل command وأعد الناتج الناتج كمصفوفة من البايتات.

read(command::Cmd, String)

قم بتشغيل command وأعد الناتج الناتج كـ String.

read!(stream::IO, array::AbstractArray)
read!(filename::AbstractString, array::AbstractArray)

اقرأ البيانات الثنائية من دفق الإدخال/الإخراج أو الملف، مع ملء array.

readbytes!(stream::IO, b::AbstractVector{UInt8}, nb=length(b))

اقرأ في أقصى حد nb بايت من stream إلى b، مع إرجاع عدد البايتات التي تم قراءتها. سيتم زيادة حجم b إذا لزم الأمر (أي إذا كان nb أكبر من length(b) وتمكن من قراءة عدد كافٍ من البايتات)، لكنه لن يتم تقليله أبدًا.

readbytes!(stream::IOStream, b::AbstractVector{UInt8}, nb=length(b); all::Bool=true)

اقرأ في أقصى حد nb بايت من stream إلى b، مع إرجاع عدد البايتات المقروءة. سيتم زيادة حجم b إذا لزم الأمر (أي إذا كان nb أكبر من length(b) وتمكن من قراءة عدد كافٍ من البايتات)، لكنه لن يتم تقليله أبدًا.

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

unsafe_read(io::IO, ref, nbytes::UInt)

انسخ nbytes من كائن تدفق IO إلى ref (المحول إلى مؤشر).

يوصى بأن تقوم الأنواع الفرعية T<:IO بتجاوز توقيع الطريقة التالية لتوفير تنفيذات أكثر كفاءة: unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

unsafe_write(io::IO, ref, nbytes::UInt)

انسخ nbytes من ref (المحول إلى مؤشر) إلى كائن IO.

يوصى بأن تقوم الأنواع الفرعية T<:IO بتجاوز توقيع الطريقة التالية لتوفير تنفيذات أكثر كفاءة: unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

readeach(io::IO, T)

يُرجع كائنًا قابلًا للتكرار يُنتج read(io, T).

انظر أيضًا skipchars، eachline، readuntil.

أمثلة

julia> io = IOBuffer("JuliaLang is a GitHub organization.\n It has many members.\n");

julia> for c in readeach(io, Char)
           c == '\n' && break
           print(c)
       end
JuliaLang is a GitHub organization.

peek(stream[, T=UInt8])

اقرأ وأعد قيمة من النوع T من دفق دون التقدم في الموضع الحالي في الدفق. انظر أيضًا startswith(stream, char_or_string).

أمثلة

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (الفئة Ll: حرف، صغير)

position(l::Lexer)

يعيد الموضع الحالي.

الموقع(ات)

احصل على الموقع الحالي لتدفق.

أمثلة

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> position(io)
5

julia> skip(io, 10);

julia> position(io)
15

julia> seekend(io);

julia> position(io)
35

seek(s, pos)

ابحث عن دفق إلى الموضع المعطى.

أمثلة

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (الفئة Lu: حرف، كبير)

seekstart(s)

ابحث عن دفق إلى بدايته.

أمثلة

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (category Lu: Letter, uppercase)

julia> seekstart(io);

julia> read(io, Char)
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)

seekend(s)

ابحث عن دفق إلى نهايته.

skip(s, offset)

ابحث عن دفق بالنسبة للموقع الحالي.

أمثلة

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> seek(io, 5);

julia> skip(io, 10);

julia> read(io, Char)
'G': ASCII/Unicode U+0047 (الفئة Lu: حرف، كبير)

mark(s::IO)

أضف علامة في الموضع الحالي من الدفق s. أعد الموضع الم marked.

انظر أيضًا unmark، reset، ismarked.

unmark(s::IO)

إزالة علامة من الدفق s. إرجاع true إذا كانت الدفق مؤشراً عليه، و false خلاف ذلك.

انظر أيضًا mark، reset، ismarked.

reset(s::IO)

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

انظر أيضًا mark، unmark، ismarked.

ismarked(s::IO)

ارجع true إذا كانت الدفق s محددة.

انظر أيضًا mark، unmark، reset.

eof(stream) -> Bool

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

أمثلة

julia> b = IOBuffer("my buffer");

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

isreadonly(io) -> Bool

حدد ما إذا كانت الدفق للقراءة فقط.

أمثلة

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

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")

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")

isexecutable(path::String)

ارجع true إذا كان path المعطى لديه أذونات تنفيذ.

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

!!! ملاحظة قبل Julia 1.6، لم يكن هذا يستجوب ACLs نظام الملفات بشكل صحيح على Windows، لذلك كان سيعيد true لأي ملف. بدءًا من Julia 1.6، يحدد بشكل صحيح ما إذا كان الملف مُعَلَّمًا كتنفيذي أم لا.

انظر أيضًا ispath، isreadable، iswritable.

isopen(object) -> Bool

حدد ما إذا كان الكائن - مثل دفق أو مؤقت - لم يُغلق بعد. بمجرد إغلاق كائن، فلن ينتج حدثًا جديدًا أبدًا. ومع ذلك، نظرًا لأن الدفق المغلق قد لا يزال يحتوي على بيانات للقراءة في ذاكرته المؤقتة، استخدم eof للتحقق من إمكانية قراءة البيانات. استخدم حزمة FileWatching لتكون على علم عندما قد يكون الدفق قابلًا للكتابة أو القراءة.

أمثلة

julia> io = open("my_file.txt", "w+");

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(stream)

إرجاع موصِف الملف الذي يدعم الدفق أو الملف. لاحظ أن هذه الدالة تنطبق فقط على File و IOStream المتزامنة وليس على أي من التدفقات غير المتزامنة.

redirect_stdio(;stdin=stdin, stderr=stderr, stdout=stdout)

إعادة توجيه مجموعة فرعية من التدفقات stdin، stderr، stdout. يجب أن يكون كل وسيط عبارة عن IOStream، TTY، Pipe، مقبس، أو devnull.

redirect_stdio(f; stdin=nothing, stderr=nothing, stdout=nothing)

إعادة توجيه مجموعة فرعية من التدفقات stdin، stderr، stdout، استدعاء f() واستعادة كل تدفق.

القيم الممكنة لكل تدفق هي:

• nothing مما يدل على أن التدفق لا ينبغي إعادة توجيهه.
• path::AbstractString لإعادة توجيه التدفق إلى الملف الموجود في path.
• io تدفق IOStream، TTY، Pipe، مقبس، أو devnull.

أمثلة

julia> redirect_stdio(stdout="stdout.txt", stderr="stderr.txt") do
           print("hello stdout")
           print(stderr, "hello stderr")
       end

julia> read("stdout.txt", String)
"hello stdout"

julia> read("stderr.txt", String)
"hello stderr"

حالات حافة

من الممكن تمرير نفس الوسيطة إلى stdout و stderr:

julia> redirect_stdio(stdout="log.txt", stderr="log.txt", stdin=devnull) do
    ...
end

ومع ذلك، لا يُسمح بتمرير موصِفين متميزين لنفس الملف.

julia> io1 = open("same/path", "w")

julia> io2 = open("same/path", "w")

julia> redirect_stdio(f, stdout=io1, stderr=io2) # غير مدعوم

أيضًا، قد لا تكون الوسيطة stdin هي نفس الموصِف مثل stdout أو stderr.

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # غير مدعوم

redirect_stdout([stream]) -> stream

قم بإنشاء أنبوب يتم توجيه جميع مخرجات stdout على مستوى C وJulia إليه. ارجع تدفقًا يمثل نهايات الأنبوب. يمكن الآن قراءة البيانات المكتوبة إلى stdout من الطرف rd للأنبوب.

!!! ملاحظة يجب أن يكون stream كائنات متوافقة، مثل IOStream، TTY، Pipe، مقبس، أو devnull.

انظر أيضًا redirect_stdio.

redirect_stdout(f::Function, stream)

قم بتشغيل الدالة f مع إعادة توجيه stdout إلى stream. عند الانتهاء، يتم استعادة stdout إلى إعداداته السابقة.

redirect_stderr([stream]) -> stream

مثل redirect_stdout، ولكن لـ stderr.

!!! ملاحظة يجب أن يكون stream كائنات متوافقة، مثل IOStream، TTY، Pipe، مقبس، أو devnull.

انظر أيضًا redirect_stdio.

redirect_stderr(f::Function, stream)

قم بتشغيل الدالة f مع إعادة توجيه stderr إلى stream. عند الانتهاء، يتم استعادة stderr إلى إعداداته السابقة.

redirect_stdin([stream]) -> stream

مثل redirect_stdout، ولكن لـ stdin. لاحظ أن اتجاه الدفق معكوس.

!!! ملاحظة يجب أن يكون stream كائنات متوافقة، مثل IOStream، TTY، Pipe، مقبس، أو devnull.

انظر أيضًا redirect_stdio.

redirect_stdin(f::Function, stream)

قم بتشغيل الدالة f مع إعادة توجيه stdin إلى stream. عند الانتهاء، يتم استعادة stdin إلى إعداداته السابقة.

readchomp(x)

اقرأ محتوى x بالكامل كسلسلة وأزل سطرًا جديدًا نهائيًا واحدًا إذا كان موجودًا. يعادل chomp(read(x, String)).

أمثلة

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readchomp("my_file.txt")
"JuliaLang is a GitHub organization.\nIt has many members."

julia> rm("my_file.txt");

truncate(file, n)

قم بتغيير حجم الملف أو المخزن المؤقت المعطى بواسطة الوسيطة الأولى إلى بالضبط n بايت، مع ملء المساحة غير المخصصة سابقًا بـ '\0' إذا تم زيادة حجم الملف أو المخزن المؤقت.

أمثلة

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.")
35

julia> truncate(io, 15)
IOBuffer(data=UInt8[...], readable=true, writable=true, seekable=true, append=false, size=15, maxsize=Inf, ptr=16, mark=-1)

julia> String(take!(io))
"JuliaLang is a "

julia> io = IOBuffer();

julia> write(io, "JuliaLang is a GitHub organization.");

julia> truncate(io, 40);

julia> String(take!(io))
"JuliaLang is a GitHub organization.\0\0\0\0\0"

skipchars(predicate, io::IO; linecomment=nothing)

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

أمثلة

julia> buf = IOBuffer("    text")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=1, mark=-1)

julia> skipchars(isspace, buf)
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=8, maxsize=Inf, ptr=5, mark=-1)

julia> String(readavailable(buf))
"text"

countlines(io::IO; eol::AbstractChar = '\n')
countlines(filename::AbstractString; eol::AbstractChar = '\n')

اقرأ io حتى نهاية الدفق/الملف واحسب عدد الأسطر. لتحديد ملف، مرر اسم الملف كأول وسيط. يتم دعم علامات نهاية السطر (EOL) الأخرى غير '\n' عن طريق تمريرها كوسيط ثانٍ. يتم احتساب آخر سطر غير فارغ من io حتى لو لم ينتهِ بعلامة نهاية السطر، مما يتطابق مع الطول الذي يتم إرجاعه بواسطة eachline و readlines.

لعد الأسطر في String، يمكن استخدام countlines(IOBuffer(str)).

أمثلة

julia> io = IOBuffer("JuliaLang is a GitHub organization.\n");

julia> countlines(io)
1

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> countlines(io)
1

julia> eof(io) # counting lines moves the file pointer
true

julia> io = IOBuffer("JuliaLang is a GitHub organization.");

julia> countlines(io, eol = '.')
1

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\n")
36

julia> countlines("my_file.txt")
1

julia> countlines("my_file.txt", eol = 'n')
4

julia> rm("my_file.txt")

PipeBuffer(data::AbstractVector{UInt8}=UInt8[]; maxsize::Integer = typemax(Int))

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

readavailable(stream)

اقرأ البيانات المتاحة المخزنة في الذاكرة من دفق. يتم تنفيذ الإدخال/الإخراج الفعلي فقط إذا لم يتم تخزين أي بيانات بالفعل. النتيجة هي Vector{UInt8}.

!!! تحذير كمية البيانات المعادة تعتمد على التنفيذ؛ على سبيل المثال، يمكن أن تعتمد على الاختيار الداخلي لحجم المخزن. يجب عمومًا استخدام دوال أخرى مثل read بدلاً من ذلك.

IOContext

IOContext يوفر آلية لتمرير إعدادات تكوين الإخراج بين طرق show.

باختصار، هو قاموس غير قابل للتغيير وهو فئة فرعية من IO. يدعم عمليات القاموس القياسية مثل getindex، ويمكن أيضًا استخدامه كتيار إدخال/إخراج.

IOContext(io::IO, KV::Pair...)

أنشئ IOContext الذي يلتف حول تدفق معين، مضيفًا أزواج key=>value المحددة إلى خصائص ذلك التدفق (لاحظ أن io يمكن أن يكون أيضًا IOContext).

• استخدم (key => value) in io للتحقق مما إذا كانت هذه المجموعة المحددة موجودة في مجموعة الخصائص
• استخدم get(io, key, default) لاسترجاع أحدث قيمة لمفتاح معين

الخصائص التالية هي في الاستخدام الشائع:

• :compact: Boolean يحدد أنه يجب طباعة القيم بشكل أكثر إحكامًا، على سبيل المثال، يجب طباعة الأرقام بعدد أقل من الأرقام. يتم تعيين هذا عند طباعة عناصر المصفوفة. يجب ألا تحتوي مخرجات :compact على فواصل أسطر.
• :limit: Boolean يحدد أنه يجب تقليم الحاويات، على سبيل المثال، عرض … بدلاً من معظم العناصر.
• :displaysize: Tuple{Int,Int} يعطي الحجم بالصفوف والأعمدة لاستخدامه في إخراج النص. يمكن استخدام ذلك لتجاوز حجم العرض للدوال المستدعاة، ولكن للحصول على حجم الشاشة استخدم دالة displaysize.
• :typeinfo: نوع يميز المعلومات التي تم طباعتها بالفعل بشأن نوع الكائن الذي سيتم عرضه. هذا مفيد بشكل أساسي عند عرض مجموعة من الكائنات من نفس النوع، بحيث يمكن تجنب المعلومات الزائدة عن النوع (على سبيل المثال، يمكن عرض [Float16(0)] كـ "Float16[0.0]" بدلاً من "Float16[Float16(0.0)]": أثناء عرض عناصر المصفوفة، سيتم تعيين خاصية :typeinfo إلى Float16).
• :color: Boolean يحدد ما إذا كانت رموز اللون/الهروب ANSI مدعومة/متوقعة. بشكل افتراضي، يتم تحديد ذلك بناءً على ما إذا كان io هو محطة متوافقة وأي علامة سطر أوامر --color عند تشغيل julia.

أمثلة

julia> io = IOBuffer();

julia> printstyled(IOContext(io, :color => true), "string", color=:red)

julia> String(take!(io))
"\e[31mstring\e[39m"

julia> printstyled(io, "string", color=:red)

julia> String(take!(io))
"string"

julia> print(IOContext(stdout, :compact => false), 1.12341234)
1.12341234
julia> print(IOContext(stdout, :compact => true), 1.12341234)
1.12341

julia> function f(io::IO)
           if get(io, :short, false)
               print(io, "short")
           else
               print(io, "loooooong")
           end
       end
f (generic function with 1 method)

julia> f(stdout)
loooooong
julia> f(IOContext(stdout, :short => true))
short

IOContext(io::IO, context::IOContext)

قم بإنشاء IOContext يلتف حول IO بديل ولكنه يرث خصائص context.

show([io::IO = stdout], x)

اكتب تمثيل نصي لقيمة x إلى تدفق الإخراج io. يجب على الأنواع الجديدة T أن تعيد تحميل show(io::IO, x::T). التمثيل المستخدم بواسطة show يتضمن عمومًا تنسيقًا خاصًا بـ Julia ومعلومات عن النوع، ويجب أن يكون قابلًا للتحليل ككود Julia عند الإمكان.

repr يعيد ناتج show كسلسلة نصية.

للحصول على مخرجات نصية أكثر تفصيلاً وقابلة للقراءة البشرية لكائنات من النوع T، قم بتعريف show(io::IO, ::MIME"text/plain", ::T) أيضًا. يُوصى بالتحقق من مفتاح IOContext :compact (الذي يتم التحقق منه غالبًا كـ get(io, :compact, false)::Bool) في مثل هذه الطرق، حيث أن بعض الحاويات تعرض عناصرها عن طريق استدعاء هذه الطريقة مع :compact => true.

انظر أيضًا إلى print، الذي يكتب تمثيلات غير مزينة.

أمثلة

julia> show("Hello World!")
"Hello World!"
julia> print("Hello World!")
Hello World!

summary(io::IO, x)
str = summary(x)

اطبع إلى دفق io، أو ارجع سلسلة str، تعطي وصفًا موجزًا لقيمة. بشكل افتراضي، ترجع string(typeof(x))، على سبيل المثال، Int64.

بالنسبة للمصفوفات، ترجع سلسلة تحتوي على معلومات الحجم والنوع، على سبيل المثال 10-element Array{Int64,1}.

أمثلة

julia> summary(1)
"Int64"

julia> summary(zeros(2))
"2-element Vector{Float64}"

print([io::IO], xs...)

اكتب إلى io (أو إلى تدفق الإخراج الافتراضي stdout إذا لم يتم إعطاء io) تمثيل نصي قياسي (غير مزخرف). التمثيل المستخدم بواسطة print يتضمن تنسيقًا بسيطًا ويحاول تجنب التفاصيل الخاصة بـ Julia.

تتراجع print إلى استدعاء show، لذا يجب على معظم الأنواع فقط تعريف show. قم بتعريف print إذا كانت لديك تمثيل "عادي" منفصل لنوعك. على سبيل المثال، تعرض show السلاسل النصية مع علامات الاقتباس، بينما تعرض print السلاسل النصية بدون علامات اقتباس.

انظر أيضًا println، string، printstyled.

أمثلة

julia> print("Hello World!")
Hello World!
julia> io = IOBuffer();

julia> print(io, "Hello", ' ', :World!)

julia> String(take!(io))
"Hello World!"

println([io::IO], xs...)

اطبع (باستخدام print) xs إلى io متبوعًا بسطر جديد. إذا لم يتم توفير io، يتم الطباعة إلى تدفق الإخراج الافتراضي stdout.

انظر أيضًا printstyled لإضافة الألوان وما إلى ذلك.

أمثلة

julia> println("Hello, world")
Hello, world

julia> io = IOBuffer();

julia> println(io, "Hello", ',', " world.")

julia> String(take!(io))
"Hello, world.\n"

printstyled([io], xs...; bold::Bool=false, italic::Bool=false, underline::Bool=false, blink::Bool=false, reverse::Bool=false, hidden::Bool=false, color::Union{Symbol,Int}=:normal)

اطبع xs بلون محدد كرمز أو عدد صحيح، اختياريًا بخط عريض.

يمكن أن تأخذ الكلمة الرئيسية color أي من القيم :normal, :italic, :default, :bold, :black, :blink, :blue, :cyan, :green, :hidden, :light_black, :light_blue, :light_cyan, :light_green, :light_magenta, :light_red, :light_white, :light_yellow, :magenta, :nothing, :red, :reverse, :underline, :white, أو :yellow أو عدد صحيح بين 0 و 255 شاملًا. لاحظ أن ليس كل المحطات تدعم 256 لونًا.

الكلمات الرئيسية bold=true, italic=true, underline=true, blink=true واضحة بذاتها. الكلمة الرئيسية reverse=true تطبع مع تبادل ألوان المقدمة والخلفية، و hidden=true يجب أن تكون غير مرئية في المحطة ولكن يمكن نسخها. يمكن استخدام هذه الخصائص بأي تركيبة.

انظر أيضًا print, println, show.

!!! ملاحظة ليس كل المحطات تدعم الإخراج المائل. بعض المحطات تفسر المائل كعكسي أو وميض.

!!! توافق "جوليا 1.7" تمت إضافة الكلمات الرئيسية باستثناء color و bold في جوليا 1.7.

!!! توافق "جوليا 1.10" تمت إضافة دعم الإخراج المائل في جوليا 1.10.

sprint(f::Function, args...; context=nothing, sizehint=0)

استدعاء الدالة المعطاة مع دفق الإدخال/الإخراج والوسائط الإضافية المقدمة. كل ما يُكتب في دفق الإدخال/الإخراج هذا يُعاد كسلسلة نصية. يمكن أن يكون context عبارة عن IOContext يتم استخدام خصائصه، أو Pair يحدد خاصية وقيمتها، أو مجموعة من Pair تحدد خصائص متعددة وقيمها. يشير sizehint إلى سعة المؤشر (بالبايت).

يمكن تعيين الوسيطة الاختيارية context إلى زوج :key=>value، أو مجموعة من أزواج :key=>value، أو كائن IO أو IOContext تُستخدم سماته لدفق الإدخال/الإخراج الممرر إلى f. sizehint الاختياري هو حجم مقترح (بالبايت) لتخصيصه للمؤشر المستخدم لكتابة السلسلة النصية.

أمثلة

julia> sprint(show, 66.66666; context=:compact => true)
"66.6667"

julia> sprint(showerror, BoundsError([1], 100))
"BoundsError: attempt to access 1-element Vector{Int64} at index [100]"

showerror(io, e)

عرض تمثيل وصفي لكائن الاستثناء e. تُستخدم هذه الطريقة لعرض الاستثناء بعد استدعاء throw.

أمثلة

julia> struct MyException <: Exception
           msg::String
       end

julia> function Base.showerror(io::IO, err::MyException)
           print(io, "MyException: ")
           print(io, err.msg)
       end

julia> err = MyException("test exception")
MyException("test exception")

julia> sprint(showerror, err)
"MyException: test exception"

julia> throw(MyException("test exception"))
ERROR: MyException: test exception

dump(x; maxdepth=8)

عرض كل جزء من تمثيل قيمة. يتم تقليم عمق الإخراج عند maxdepth.

أمثلة

julia> struct MyStruct
           x
           y
       end

julia> x = MyStruct(1, (2,3));

julia> dump(x)
MyStruct
  x: Int64 1
  y: Tuple{Int64, Int64}
    1: Int64 2
    2: Int64 3

julia> dump(x; maxdepth = 1)
MyStruct
  x: Int64 1
  y: Tuple{Int64, Int64}

@dump expr

عرض كل جزء من تمثيل التعبير المعطى. يعادل dump(:(expr)).

readline(io::IO=stdin; keep::Bool=false)
readline(filename::AbstractString; keep::Bool=false)

اقرأ سطرًا واحدًا من النص من دفق الإدخال/الإخراج أو الملف المعطى (الافتراضي هو stdin). عند القراءة من ملف، يُفترض أن يكون النص مشفرًا بتشفير UTF-8. تنتهي الأسطر في الإدخال بـ '\n' أو "\r\n" أو نهاية دفق الإدخال. عندما يكون keep خاطئًا (كما هو الحال بشكل افتراضي)، تتم إزالة هذه الأحرف الجديدة الزائدة من السطر قبل إرجاعه. عندما يكون keep صحيحًا، يتم إرجاعها كجزء من السطر.

إرجاع String. انظر أيضًا copyline للكتابة بدلاً من ذلك في مكان آخر إلى دفق آخر (يمكن أن يكون IOBuffer مُخصص مسبقًا).

انظر أيضًا readuntil للقراءة حتى فواصل أكثر عمومية.

أمثلة

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readline("my_file.txt")
"JuliaLang is a GitHub organization."

julia> readline("my_file.txt", keep=true)
"JuliaLang is a GitHub organization.\n"

julia> rm("my_file.txt")

julia> print("Enter your name: ")
Enter your name:

julia> your_name = readline()
Logan
"Logan"

readuntil(stream::IO, delim; keep::Bool = false)
readuntil(filename::AbstractString, delim; keep::Bool = false)

اقرأ سلسلة من stream الإدخال/الإخراج أو ملف، حتى المحدد المعطى. يمكن أن يكون المحدد UInt8، AbstractChar، سلسلة، أو متجه. يتحكم وسيط الكلمة keep في ما إذا كان سيتم تضمين المحدد في النتيجة. يُفترض أن النص مشفر بتنسيق UTF-8.

إرجاع String إذا كان delim هو AbstractChar أو سلسلة، أو خلاف ذلك إرجاع Vector{typeof(delim)}. انظر أيضًا copyuntil للكتابة بدلاً من ذلك في مكان آخر إلى دفق آخر (يمكن أن يكون IOBuffer مُخصص مسبقًا).

أمثلة

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readuntil("my_file.txt", 'L')
"Julia"

julia> readuntil("my_file.txt", '.', keep = true)
"JuliaLang is a GitHub organization."

julia> rm("my_file.txt")

readlines(io::IO=stdin; keep::Bool=false)
readlines(filename::AbstractString; keep::Bool=false)

اقرأ جميع الأسطر من تدفق الإدخال/الإخراج أو ملف كمتجه من السلاسل النصية. السلوك يعادل حفظ نتيجة القراءة من readline بشكل متكرر بنفس الوسائط وحفظ الأسطر الناتجة كمتجه من السلاسل النصية. انظر أيضًا eachline للتكرار على الأسطر دون قراءتها جميعًا دفعة واحدة.

أمثلة

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> readlines("my_file.txt")
2-element Vector{String}:
 "JuliaLang is a GitHub organization."
 "It has many members."

julia> readlines("my_file.txt", keep=true)
2-element Vector{String}:
 "JuliaLang is a GitHub organization.\n"
 "It has many members.\n"

julia> rm("my_file.txt")

eachline(io::IO=stdin; keep::Bool=false)
eachline(filename::AbstractString; keep::Bool=false)

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

للتكرار على كل سطر من String، يمكن استخدام eachline(IOBuffer(str)).

يمكن استخدام Iterators.reverse على كائن EachLine لقراءة الأسطر بترتيب عكسي (لملفات، والمخازن المؤقتة، وغيرها من تدفقات الإدخال/الإخراج التي تدعم seek)، ويمكن استخدام first أو last لاستخراج الأسطر الأولية أو النهائية، على التوالي.

أمثلة

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\n It has many members.\n");

julia> for line in eachline("my_file.txt")
           print(line)
       end
JuliaLang is a GitHub organization. It has many members.

julia> rm("my_file.txt");

copyline(out::IO, io::IO=stdin; keep::Bool=false)
copyline(out::IO, filename::AbstractString; keep::Bool=false)

انسخ سطرًا واحدًا من نص من stream إدخال/إخراج أو ملف إلى تدفق out، مع إرجاع out.

عند القراءة من ملف، يُفترض أن النص مشفر بتنسيق UTF-8. تنتهي الأسطر في الإدخال بـ '\n' أو "\r\n" أو نهاية تدفق الإدخال. عندما يكون keep خاطئًا (كما هو افتراضيًا)، تتم إزالة هذه الأحرف الجديدة اللاحقة من السطر قبل إرجاعه. عندما يكون keep صحيحًا، يتم إرجاعها كجزء من السطر.

مماثل لـ readline، الذي يُرجع String؛ على النقيض من ذلك، يقوم copyline بالكتابة مباشرة إلى out، دون تخصيص سلسلة. (يمكن استخدام ذلك، على سبيل المثال، لقراءة البيانات في IOBuffer مُخصص مسبقًا.)

انظر أيضًا copyuntil للقراءة حتى فواصل أكثر عمومية.

أمثلة

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> String(take!(copyline(IOBuffer(), "my_file.txt")))
"JuliaLang is a GitHub organization."

julia> String(take!(copyline(IOBuffer(), "my_file.txt", keep=true)))
"JuliaLang is a GitHub organization.\n"

julia> rm("my_file.txt")

copyuntil(out::IO, stream::IO, delim; keep::Bool = false)
copyuntil(out::IO, filename::AbstractString, delim; keep::Bool = false)

انسخ سلسلة من stream الإدخال/الإخراج أو ملف، حتى المحدد المعطى، إلى تدفق out، مع إرجاع out. يمكن أن يكون المحدد UInt8 أو AbstractChar أو سلسلة أو متجه. يتحكم وسيط keep في ما إذا كان سيتم تضمين المحدد في النتيجة. يُفترض أن النص مشفر بتنسيق UTF-8.

مماثل لـ readuntil، الذي يُرجع String؛ على العكس من ذلك، يقوم copyuntil بالكتابة مباشرة إلى out، دون تخصيص سلسلة. (يمكن استخدام ذلك، على سبيل المثال، لقراءة البيانات في IOBuffer مُخصص مسبقًا.)

أمثلة

julia> write("my_file.txt", "JuliaLang is a GitHub organization.\nIt has many members.\n");

julia> String(take!(copyuntil(IOBuffer(), "my_file.txt", 'L')))
"Julia"

julia> String(take!(copyuntil(IOBuffer(), "my_file.txt", '.', keep = true)))
"JuliaLang is a GitHub organization."

julia> rm("my_file.txt")

displaysize([io::IO]) -> (lines, columns)

ارجع الحجم الاسمي للشاشة التي يمكن استخدامها لعرض المخرجات إلى هذا الكائن IO. إذا لم يتم توفير أي إدخال، يتم قراءة متغيرات البيئة LINES و COLUMNS. إذا لم يتم تعيين تلك المتغيرات، يتم إرجاع حجم افتراضي قدره (24, 80).

أمثلة

julia> withenv("LINES" => 30, "COLUMNS" => 100) do
           displaysize()
       end
(30, 100)

للحصول على حجم TTY الخاص بك،

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

نوع سوبر مجرد لأجهزة الإخراج الغنية. TextDisplay هو نوع فرعي من هذا.

display(x)
display(d::AbstractDisplay, x)
display(mime, x)
display(d::AbstractDisplay, mime, x)

عرض x باستخدام العرض الأكثر ملاءمة في مكدس العرض، عادةً باستخدام أغنى إخراج وسائط متعددة مدعوم لـ x، مع إخراج نص عادي stdout كخيار احتياطي. يحاول متغير display(d, x) عرض x على العرض المعطى d فقط، مما يؤدي إلى إلقاء MethodError إذا لم يتمكن d من عرض كائنات من هذا النوع.

بشكل عام، لا يمكنك افتراض أن إخراج display يذهب إلى stdout (على عكس print(x) أو show(x)). على سبيل المثال، قد يفتح display(x) نافذة منفصلة تحتوي على صورة. يعني display(x) "عرض x بأفضل طريقة يمكنك لجهاز الإخراج الحالي (أجهزة الإخراج)." إذا كنت تريد إخراج نصي مشابه لـ REPL مضمون أن يذهب إلى stdout، استخدم show(stdout, "text/plain", x) بدلاً من ذلك.

هناك أيضًا متغيران مع وسيط mime (سلسلة نوع MIME، مثل "image/png")، يحاولان عرض x باستخدام نوع MIME المطلوب فقط، مما يؤدي إلى إلقاء MethodError إذا لم يكن هذا النوع مدعومًا من قبل العرض (العروض) أو من قبل x. مع هذه المتغيرات، يمكن للمرء أيضًا تزويد البيانات "الخام" بالنوع MIME المطلوب عن طريق تمرير x::AbstractString (لأنواع MIME ذات التخزين النصي، مثل text/html أو application/postscript) أو x::Vector{UInt8} (لأنواع MIME الثنائية).

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

redisplay(x)
redisplay(d::AbstractDisplay, x)
redisplay(mime, x)
redisplay(d::AbstractDisplay, mime, x)

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

displayable(mime) -> Bool
displayable(d::AbstractDisplay, mime) -> Bool

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

show(io::IO, mime, x)

تقوم دوال display في النهاية باستدعاء show لكتابة كائن x كنوع mime معين إلى دفق الإدخال/الإخراج io (عادةً ما يكون مخزن ذاكرة)، إذا كان ذلك ممكنًا. من أجل توفير تمثيل وسائط متعددة غني لنوع معرفه المستخدم T، يكفي فقط تعريف طريقة show جديدة لـ T، عبر: show(io, ::MIME"mime", x::T) = ...، حيث mime هو سلسلة نوع MIME وجسم الدالة يستدعي write (أو ما شابه) لكتابة ذلك التمثيل لـ x إلى io. (لاحظ أن تدوين MIME"" يدعم فقط السلاسل الحرفية؛ لإنشاء أنواع MIME بطريقة أكثر مرونة استخدم MIME{Symbol("")}.)

على سبيل المثال، إذا قمت بتعريف نوع MyImage وتعرفت على كيفية كتابته إلى ملف PNG، يمكنك تعريف دالة show(io, ::MIME"image/png", x::MyImage) = ... للسماح بعرض صورك على أي AbstractDisplay يدعم PNG (مثل IJulia). كما هو معتاد، تأكد من import Base.show لإضافة طرق جديدة إلى دالة Julia المدمجة show.

تقنيًا، يقوم ماكرو MIME"mime" بتعريف نوع مفرد لسلسلة mime المعطاة، مما يسمح لنا بالاستفادة من آليات التوزيع في Julia لتحديد كيفية عرض كائنات من أي نوع معين.

نوع MIME الافتراضي هو MIME"text/plain". هناك تعريف احتياطي لإخراج text/plain يستدعي show مع 2 من المعاملات، لذا ليس من الضروري دائمًا إضافة طريقة لذلك الحالة. إذا كان النوع يستفيد من إخراج مخصص قابل للقراءة البشرية، يجب تعريف show(::IO, ::MIME"text/plain", ::T). على سبيل المثال، يستخدم نوع Day 1 day كإخراج لنوع MIME text/plain، و Day(1) كإخراج لدالة show ذات المعاملات الـ 2.

أمثلة

julia> struct Day
           n::Int
       end

julia> Base.show(io::IO, ::MIME"text/plain", d::Day) = print(io, d.n, " day")

julia> Day(1)
1 day

تقوم أنواع الحاويات عمومًا بتنفيذ show ذات 3 معاملات عن طريق استدعاء show(io, MIME"text/plain"(), x) للعناصر x، مع تعيين :compact => true في IOContext الممررة كأول معامل.

showable(mime, x)

إرجاع قيمة منطقية تشير إلى ما إذا كان يمكن كتابة الكائن x كنوع mime المعطى.

(بشكل افتراضي، يتم تحديد ذلك تلقائيًا من خلال وجود طريقة show المقابلة لـ typeof(x). بعض الأنواع توفر طرق showable مخصصة؛ على سبيل المثال، إذا كانت تنسيقات MIME المتاحة تعتمد على قيمة x.)

أمثلة

julia> showable(MIME("text/plain"), rand(5))
true

julia> showable("image/png", rand(5))
false

repr(mime, x; context=nothing)

إرجاع AbstractString أو Vector{UInt8} يحتوي على تمثيل x في نوع mime المطلوب، كما هو مكتوب بواسطة show(io, mime, x) (مما يؤدي إلى رمي MethodError إذا لم يكن هناك show مناسب متاح). يتم إرجاع AbstractString لأنواع MIME ذات التمثيلات النصية (مثل "text/html" أو "application/postscript")، بينما يتم إرجاع البيانات الثنائية كـ Vector{UInt8}. (تقوم الدالة istextmime(mime) بإرجاع ما إذا كانت جوليا تعالج نوع mime معين كنص.)

يمكن تعيين الوسيطة الاختيارية context إلى زوج :key=>value أو كائن IO أو IOContext يتم استخدام سماته لتدفق الإدخال/الإخراج الممرر إلى show.

كحالة خاصة، إذا كان x هو AbstractString (لأنواع MIME النصية) أو Vector{UInt8} (لأنواع MIME الثنائية)، فإن دالة repr تفترض أن x موجود بالفعل في تنسيق mime المطلوب وتعيد ببساطة x. لا تنطبق هذه الحالة الخاصة على نوع MIME "text/plain". هذا مفيد حتى يمكن تمرير البيانات الخام إلى display(m::MIME, x).

على وجه الخصوص، repr("text/plain", x) هو عادةً نسخة "مُنسقة" من x مصممة للاستهلاك البشري. انظر أيضًا repr(x) لإرجاع سلسلة تتوافق مع show(x) التي قد تكون أقرب إلى كيفية إدخال قيمة x في جوليا.

أمثلة

julia> A = [1 2; 3 4];

julia> repr("text/plain", A)
"2×2 Matrix{Int64}:\n 1  2\n 3  4"

MIME

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

يمكن تمرير كائن MIME كوسيط ثانٍ إلى show لطلب الإخراج بتلك التنسيق.

أمثلة

julia> show(stdout, MIME("text/plain"), "hi")
"hi"

@MIME_str

ماكرو ملائم لكتابة MIME الأنواع، وعادة ما يستخدم عند إضافة طرق إلى show. على سبيل المثال، يمكن استخدام الصيغة show(io::IO, ::MIME"text/html", x::MyType) = ... لتعريف كيفية كتابة تمثيل HTML لـ MyType.

pushdisplay(d::AbstractDisplay)

يدفع عرضًا جديدًا d إلى أعلى مكدس واجهة العرض العالمية. استدعاء display(x) أو display(mime, x) سيعرض x على أعلى واجهة متوافقة في المكدس (أي، أعلى واجهة لا ترمي MethodError).

popdisplay()
popdisplay(d::AbstractDisplay)

قم بإزالة الواجهة الخلفية العليا من كومة واجهات العرض، أو النسخة العليا من d في النسخة الثانية.

TextDisplay(io::IO)

إرجاع TextDisplay <: AbstractDisplay، والذي يعرض أي كائن كنوع MIME text/plain (بشكل افتراضي)، مع كتابة التمثيل النصي إلى تدفق الإدخال/الإخراج المعطى. (هذه هي الطريقة التي يتم بها طباعة الكائنات في REPL الخاص بـ Julia.)

istextmime(m::MIME)

حدد ما إذا كان نوع MIME هو بيانات نصية. يُفترض أن تكون أنواع MIME بيانات ثنائية باستثناء مجموعة من الأنواع المعروفة بأنها بيانات نصية (ربما Unicode).

أمثلة

julia> istextmime(MIME("text/plain"))
true

julia> istextmime(MIME("image/png"))
false

bytesavailable(io)

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

أمثلة

julia> io = IOBuffer("JuliaLang is a GitHub organization");

julia> bytesavailable(io)
34

ntoh(x)

تحويل ترتيب البايت لقيمة من ترتيب بايت الشبكة (big-endian) إلى ذلك المستخدم من قبل المضيف.

hton(x)

تحويل ترتيب البايت لقيمة من ذلك المستخدم بواسطة المضيف إلى ترتيب بايت الشبكة (big-endian).

ltoh(x)

تحويل ترتيب البايت لقيمة من الترتيب الصغير إلى الترتيب المستخدم من قبل المضيف.

htol(x)

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

ENDIAN_BOM

تشير علامة ترتيب البايت 32 بت إلى ترتيب البايت الأصلي لجهاز المضيف. ستحتوي الآلات ذات الترتيب الصغير على القيمة 0x04030201. ستحتوي الآلات ذات الترتيب الكبير على القيمة 0x01020304.