I/O and Network

stdout::IO

Standart çıkış akışını ifade eden küresel değişken.

stderr::IO

Standart hata akışını ifade eden global değişken.

stdin::IO

Standart giriş akışını ifade eden global değişken.

read(filename::AbstractString)

Bir dosyanın tüm içeriğini Vector{UInt8} olarak oku.

read(filename::AbstractString, String)

Bir dosyanın tüm içeriğini bir dize olarak oku.

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

Bir dosyayı aç ve içeriğini oku. args, read fonksiyonuna iletilir: bu, open(io->read(io, args...), filename) ile eşdeğerdir.

write(filename::AbstractString, content)

content'ın kanonik ikili temsilini bir dosyaya yazın, dosya henüz yoksa oluşturulacak veya mevcutsa üzerine yazılacaktır.

Dosyaya yazılan byte sayısını döndürün.

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

open(args...; kwargs...) sonucunu f fonksiyonuna uygular ve tamamlandığında elde edilen dosya tanımlayıcısını kapatır.

Örnekler

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

Beş boolean anahtar argümanla belirtilen bir modda bir dosya açın:

Anahtar kelimeler geçilmediğinde varsayılan olarak dosyalar yalnızca okuma için açılır. Açılan dosyaya erişim için bir akış döner.

lock anahtar argümanı, işlemlerin güvenli çoklu iş parçacıklı erişim için kilitlenip kilitlenmeyeceğini kontrol eder.

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

Açık, beş boolean yerine bir dize tabanlı mod belirticisi kullanılan alternatif sözdizimi. mode değerleri, fopen(3) veya Perl open'den gelenlerle eşdeğerdir ve aşağıdaki boolean gruplarını ayarlamakla eşdeğerdir:

lock anahtar kelime argümanı, işlemlerin güvenli çoklu iş parçacıklı erişim için kilitlenip kilitlenmeyeceğini kontrol eder.

Örnekler

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

julia> write(io, "Merhaba dünya!");

julia> close(io);

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

julia> read(io, String)
"Merhaba dünya!"

julia> write(io, "Bu dosya yalnızca okunabilir")
HATA: ArgumentError: yazma başarısız oldu, IOStream yazılabilir değil
[...]

julia> close(io)

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

julia> write(io, "Bu akış yalnızca okunabilir değil")
28

julia> close(io)

julia> rm("myfile.txt")

open(fd::OS_HANDLE) -> IO

Bir ham dosya tanımlayıcısını alır, bunu Julia'ya özgü bir IO türü içinde sarar ve fd tutamağının mülkiyetini alır. Orijinal tutamağın mülkiyetini ele geçirmemek için open(Libc.dup(fd)) çağrısını yapın.

!!! uyarı Bunu, sistemin başka bir parçası tarafından zaten sahip olunan bir tutamakta çağırmayın.

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

command'ı asenkron olarak çalıştırın. open(command, stdio; read, write) gibi, ancak okuma ve yazma bayraklarını anahtar argümanlar yerine bir mod dizesi aracılığıyla belirterek. Olası mod dizeleri şunlardır:

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

command'ı asenkron olarak çalıştırmaya başlayın ve bir process::IO nesnesi döndürün. Eğer read doğruysa, o zaman süreçten okunan veriler sürecin standart çıktısından gelir ve stdio isteğe bağlı olarak sürecin standart giriş akışını belirtir. Eğer write doğruysa, o zaman yazmalar sürecin standart girişine gider ve stdio isteğe bağlı olarak sürecin standart çıkış akışını belirtir. Sürecin standart hata akışı mevcut küresel stderr ile bağlantılıdır.

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

open(command, args...; kwargs...) ile benzer, ancak sonuçlanan işlem akışında f(stream) çağrısını yapar, ardından giriş akışını kapatır ve işlemin tamamlanmasını bekler. Başarılı olduğunda f tarafından döndürülen değeri döndürür. İşlem başarısız olursa veya işlem stdout'a herhangi bir şey yazmaya çalışırsa bir hata fırlatır.

IOStream

Bir OS dosya tanımlayıcısını saran bir tamponlu IO akışı. Çoğunlukla open ile döndürülen dosyaları temsil etmek için kullanılır.

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

Önceden var olan bir dizi üzerinde isteğe bağlı olarak çalışabilen, bellek içi bir G/Ç akışı oluşturur.

İsteğe bağlı anahtar kelime argümanlarını alabilir:

• read, write, append: işlemleri tamponla sınırlamak için; ayrıntılar için open'a bakın.
• truncate: tampon boyutunu sıfır uzunluğa kısaltır.
• maxsize: tamponun büyüyemeyeceği bir boyut belirtir.
• sizehint: tamponun kapasitesini önerir (data sizehint!(data, size)'i uygulamalıdır).

data verilmediğinde, tampon varsayılan olarak hem okunabilir hem de yazılabilir olacaktır.

Örnekler

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.")
HATA: 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)

Verilen dizeye dayanan bir yalnızca okunabilir IOBuffer oluşturur.

Örnekler

julia> io = IOBuffer("Haho");

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

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

take!(b::IOBuffer)

Bir IOBuffer'ın içeriğini bir dizi olarak alın. Sonrasında, IOBuffer başlangıç durumuna sıfırlanır.

Örnekler

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

Başka süreçler arasında IO iletişimi için özellikle kullanılmak üzere, başlatılmamış bir Pipe nesnesi oluşturur.

Pipe'ın uygun ucu, nesne süreç oluşturma sırasında kullanıldığında otomatik olarak başlatılacaktır. Bu, süreç boru hatlarında referansları kolayca elde etmek için yararlı olabilir, örneğin:

julia> err = Pipe()

# Bu `err` başlatılacak ve `foo`'nun
# stderr'sini `err` borusundan okuyabilirsiniz veya `err`'yi diğer boru hatlarına geçirebilirsiniz.
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# Şimdi borunun yazma kısmını yok edin, böylece okuma kısmı EOF alacaktır
julia> closewrite(err)

julia> read(err, String)
"stderr mesajları"

Ayrıca Base.link_pipe! bakınız.

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

pipe'i başlatın ve in uç noktasını out uç noktasına bağlayın. Anahtar kelime argümanları reader_supports_async/writer_supports_async, Windows'ta OVERLAPPED ve POSIX sistemlerinde O_NONBLOCK ile ilişkilidir. Harici bir program tarafından kullanılmayacaklarsa (örneğin, run ile yürütülen bir komutun çıktısı gibi) true olmalıdırlar.

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

Bir tamsayı dosya tanımlayıcısından bir IOStream nesnesi oluşturur. Eğer own true ise, bu nesneyi kapatmak, alttaki tanımlayıcıyı kapatacaktır. Varsayılan olarak, bir IOStream çöp toplayıcı tarafından toplandığında kapatılır. name, tanımlayıcıyı adlandırılmış bir dosyayla ilişkilendirmenizi sağlar.

flush(stream)

Verilen akışa tüm şu anda tamponlanmış yazmaları taahhüt eder.

close(stream)

Bir I/O akışını kapatır. Öncelikle bir flush işlemi gerçekleştirir.

closewrite(stream)

Tam çift yönlü bir G/Ç akışının yazma kısmını kapatır. Öncelikle bir flush gerçekleştirir. Diğer uca, altta yatan dosyaya daha fazla veri yazılmayacağını bildirir. Bu, tüm G/Ç türleri tarafından desteklenmez.

Eğer uygulanmışsa, closewrite, engellenmesi gereken sonraki read veya eof çağrılarının yerine EOF fırlatmasına veya sırasıyla true döndürmesine neden olur. Eğer akış zaten kapatılmışsa, bu idempotenttir.

Örnekler

julia> io = Base.BufferStream(); # bu asla engellenmez, bu yüzden aynı Görev üzerinde okuyabilir ve yazabiliriz

julia> write(io, "request");

julia> # burada `read(io)` çağrısı sonsuza kadar engellenecektir

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

Verilen I/O akışına veya dosyasına bir değerin kanonik ikili temsilini yazın. Akışa yazılan byte sayısını döndürün. Metin temsilini yazmak için print fonksiyonuna da bakın (kodlama ioya bağlı olabilir).

Yazılan değerin endianlığı, ana sistemin endianlığına bağlıdır. Yazarken/okurken sabit bir endianlığa dönüştürmek için (örneğin, htol ve ltoh kullanarak) platformlar arasında tutarlı sonuçlar elde edebilirsiniz.

Aynı write çağrısıyla birden fazla değer yazabilirsiniz. Yani, aşağıdakiler eşdeğerdir:

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

Örnekler

Tutarlı serileştirme:

julia> fname = tempname(); # rastgele geçici dosya adı

julia> open(fname,"w") do f
           # 64bit tam sayıyı küçük endian byte sırasına yazdığımızdan emin olun
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # Ana byte sırasına ve ana tam sayı türüne geri dönüştür
           Int(ltoh(read(f,Int64)))
       end
42

Yazma çağrılarını birleştirme:

julia> io = IOBuffer();

julia> write(io, "JuliaLang bir GitHub organizasyonudur.", " Birçok üyesi var.")
56

julia> String(take!(io))
"JuliaLang bir GitHub organizasyonudur. Birçok üyesi var."

julia> write(io, "Bazen o üyeler") + write(io, " belge yazar.")
44

julia> String(take!(io))
"Bazen o üyeler belge yazar."

write yöntemleri olmayan kullanıcı tanımlı düz veri türleri, bir Ref içinde sarıldığında yazılabilir:

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)

io'dan T türünde tek bir değeri, kanonik ikili temsilinde okuyun.

Julia'nın sonlandırma düzenini sizin için dönüştürmediğini unutmayın. Bu amaçla ntoh veya ltoh kullanın.

read(io::IO, String)

io'nun tamamını bir String olarak okuyun (bkz. ayrıca readchomp).

Örnekler

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

julia> read(io, Char)
'J': ASCII/Unicode U+004A (kategori Lu: Harf, büyük)

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

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

read(filename::AbstractString)

Bir dosyanın tüm içeriğini Vector{UInt8} olarak oku.

read(filename::AbstractString, String)

Bir dosyanın tüm içeriğini bir dize olarak oku.

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

Bir dosyayı aç ve içeriğini oku. args, read fonksiyonuna iletilir: bu, open(io->read(io, args...), filename) ile eşdeğerdir.

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

s'den en fazla nb bayt okuyun ve okunan baytların Vector{UInt8}'sini döndürün.

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

s'den en fazla nb bayt okuyun ve okunan baytların Vector{UInt8}'sini döndürün.

all true (varsayılan) ise, bu fonksiyon bir hata veya dosya sonu meydana gelene kadar istenen tüm baytları okumaya çalışarak sürekli olarak engellenir. all false ise, en fazla bir read çağrısı yapılır ve döndürülen veri miktarı cihaza bağlıdır. Tüm akış türlerinin all seçeneğini desteklemediğini unutmayın.

read(command::Cmd)

command'ı çalıştırın ve sonuç olarak çıkan çıktıyı bir bayt dizisi olarak döndürün.

read(command::Cmd, String)

command'ı çalıştırın ve sonuç olarak çıkan çıktıyı String olarak döndürün.

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

Bir I/O akışından veya dosyadan ikili verileri okuyarak array'i doldurur.

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

stream'den en fazla nb bayt okuyarak b'ye yazar, okunan bayt sayısını döner. b'nin boyutu gerektiğinde artırılacaktır (yani, nb length(b)'den büyükse ve yeterli bayt okunabiliyorsa), ancak asla azaltılmayacaktır.

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

stream'den b'ye en fazla nb bayt okuyun ve okunan bayt sayısını döndürün. b'nin boyutu gerektiğinde artırılacaktır (yani nb, length(b)'den büyükse ve yeterince bayt okunabiliyorsa), ancak asla azaltılmayacaktır.

all true (varsayılan) ise, bu fonksiyon bir hata veya dosya sonu meydana gelene kadar tüm istenen baytları okumak için tekrar tekrar engellenecektir. all false ise, en fazla bir read çağrısı gerçekleştirilir ve döndürülen veri miktarı cihaza bağlıdır. Tüm akış türlerinin all seçeneğini desteklemediğini unutmayın.

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

IO akış nesnesinden nbytes'ı ref'e (bir işaretçiye dönüştürülmüş) kopyalar.

T<:IO alt türlerinin daha verimli uygulamalar sağlamak için aşağıdaki yöntem imzasını geçersiz kılmaları önerilir: unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

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

ref'den nbytes'i (bir işaretçiye dönüştürülmüş) IO nesnesine kopyalayın.

T<:IO alt türlerinin daha verimli uygulamalar sağlamak için aşağıdaki yöntem imzasını geçersiz kılmaları önerilir: unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

readeach(io::IO, T)

Bir read(io, T) döndüren bir iterable nesne sağlar.

Ayrıca skipchars, eachline, readuntil ile de bakabilirsiniz.

Örnekler

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

Bir akıştan mevcut konumu ilerletmeden T türünde bir değer okuyun ve döndürün. Ayrıca startswith(stream, char_or_string) bakın.

Örnekler

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (kategori Ll: Küçük harf, harf)

position(l::Lexer)

Mevcut konumu döndürür.

pozisyon(lar)

Akışın mevcut pozisyonunu alır.

Örnekler

julia> io = IOBuffer("JuliaLang bir GitHub organizasyonudur.");

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)

Bir akışı verilen konuma yönlendirin.

Örnekler

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

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (kategori Lu: Harf, büyük)

seekstart(s)

Bir akışı başlangıcına yönlendirin.

Örnekler

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

julia> seek(io, 5);

julia> read(io, Char)
'L': ASCII/Unicode U+004C (kategori Lu: Harf, büyük)

julia> seekstart(io);

julia> read(io, Char)
'J': ASCII/Unicode U+004A (kategori Lu: Harf, büyük)

seekend(s)

Bir akışı sonuna yönlendirin.

skip(s, offset)

Mevcut konuma göre bir akışı arayın.

Örnekler

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 (kategori Lu: Harf, büyük)

mark(s::IO)

Akış s'nin mevcut konumuna bir işaret ekleyin. İşaretlenmiş konumu döndürün.

Ayrıca bkz. unmark, reset, ismarked.

unmark(s::IO)

Akış s'den bir işareti kaldırır. Akış işaretlenmişse true, aksi takdirde false döner.

Ayrıca bkz. mark, reset, ismarked.

reset(s::IO)

Bir akışı s daha önce işaretlenmiş bir konuma sıfırlayın ve işareti kaldırın. Daha önce işaretlenmiş konumu döndürün. Akış işaretlenmemişse bir hata fırlatın.

Ayrıca bkz. mark, unmark, ismarked.

ismarked(s::IO)

Akış s işaretlenmişse true döndürür.

Ayrıca bkz. mark, unmark, reset.

eof(stream) -> Bool

Bir I/O akışının dosya sonuna ulaşıp ulaşmadığını test eder. Eğer akış henüz tükenmemişse, bu fonksiyon gerekli olduğunda daha fazla veri beklemek için bloklanacak ve ardından false döndürecektir. Bu nedenle, eof'un false döndüğünü gördükten sonra bir bayt okumak her zaman güvenlidir. eof, tamponlanmış veriler hala mevcut olduğu sürece false döndürecektir, bağlantının uzak ucu kapalı olsa bile.

Örnekler

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

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

isreadonly(io) -> Bool

Bir akışın yalnızca okunabilir olup olmadığını belirleyin.

Örnekler

julia> io = IOBuffer("JuliaLang bir GitHub organizasyonudur");

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

iswritable(path::String)

Verilen path için erişim izinleri mevcut kullanıcı tarafından yazmaya izin veriyorsa true döner.

Ayrıca bkz. ispath, isexecutable, isreadable.

iswritable(io) -> Bool

Belirtilen IO nesnesi yazılabilir değilse false döner.

Örnekler

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)

Verilen path için erişim izinleri mevcut kullanıcı tarafından okuma izni veriyorsa true döner.

Ayrıca bkz. ispath, isexecutable, iswritable.

isreadable(io) -> Bool

Belirtilen IO nesnesi okunabilir değilse false döndürür.

Örnekler

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)

Verilen path'in çalıştırılabilir izinlere sahip olup olmadığını kontrol eder ve true döner.

Ayrıca bkz. ispath, isreadable, iswritable.

isopen(object) -> Bool

Bir nesnenin - bir akış veya zamanlayıcı gibi - henüz kapatılıp kapatılmadığını belirleyin. Bir nesne kapatıldığında, asla yeni bir olay üretmeyecektir. Ancak, kapatılmış bir akışın hala tamponunda okunacak verileri olabileceğinden, veri okuma yeteneğini kontrol etmek için eof kullanın. Bir akışın yazılabilir veya okunabilir olabileceği konusunda bildirim almak için FileWatching paketini kullanın.

Örnekler

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(stream)

Akış veya dosyanın arkasındaki dosya tanımlayıcısını döndürür. Bu işlev yalnızca senkron File ve IOStream'lere uygulanır, herhangi bir asenkron akışa uygulanmaz.

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

stdin, stderr, stdout akışlarının bir alt kümesini yönlendirin. Her argüman bir IOStream, TTY, Pipe, soket veya devnull olmalıdır.

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

stdin, stderr, stdout akışlarının bir alt kümesini yönlendirin, f() çağırın ve her akışı geri yükleyin.

Her akış için olası değerler:

• nothing akışın yönlendirilmemesi gerektiğini belirtir.
• path::AbstractString akışı path'teki dosyaya yönlendirir.
• io bir IOStream, TTY, Pipe, soket veya devnull.

Örnekler

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"

Kenar durumları

stdout ve stderr için aynı argümanı geçmek mümkündür:

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

Ancak, aynı dosyanın iki farklı tanımlayıcısını geçmek desteklenmez.

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

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

julia> redirect_stdio(f, stdout=io1, stderr=io2) # desteklenmiyor

Ayrıca stdin argümanı stdout veya stderr ile aynı tanımlayıcı olamaz.

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # desteklenmiyor

redirect_stdout([stream]) -> stream

Tüm C ve Julia düzeyindeki stdout çıktısının yönlendirileceği bir boru oluşturur. Boru uçlarını temsil eden bir akış döndürür. stdout üzerine yazılan veriler artık borunun rd ucundan okunabilir.

Ayrıca bkz. redirect_stdio.

redirect_stdout(f::Function, stream)

f fonksiyonunu çalıştırırken stdout akışını stream'e yönlendirin. Tamamlandığında, stdout önceki ayarına geri döner.

redirect_stderr([stream]) -> stream

stderr için redirect_stdout gibi.

Ayrıca bkz. redirect_stdio.

redirect_stderr(f::Function, stream)

Fonksiyonu f'yi çalıştırırken stderr akışına yönlendirir. Tamamlandığında, stderr önceki ayarına geri döner.

redirect_stdin([stream]) -> stream

stdout için redirect_stdout gibi, ancak stdin için. Akışın yönünün tersine döndüğünü unutmayın.

Ayrıca bkz. redirect_stdio.

redirect_stdin(f::Function, stream)

f fonksiyonunu stream'e yönlendirerek çalıştırır. Tamamlandığında, stdin önceki ayarına geri döner.

readchomp(x)

x'i bir dize olarak tamamen okuyun ve varsa tek bir son satır sonunu kaldırın. chomp(read(x, String)) ile eşdeğerdir.

Örnekler

julia> write("my_file.txt", "JuliaLang bir GitHub organizasyonudur.\nBirçok üyesi vardır.\n");

julia> readchomp("my_file.txt")
"JuliaLang bir GitHub organizasyonudur.\nBirçok üyesi vardır."

julia> rm("my_file.txt");

truncate(file, n)

Verilen dosyayı veya tamponu ilk argüman olarak n bayta tam olarak yeniden boyutlandırır, eğer dosya veya tampon büyütülürse daha önce tahsis edilmemiş alanı '\0' ile doldurur.

Örnekler

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)

Akışı io öyle bir şekilde ilerletin ki, bir sonraki okunacak karakter, predicate'in false döndüğü ilk kalan karakter olsun. Eğer linecomment anahtar kelime argümanı belirtilmişse, o karakterden başlayarak bir sonraki satırın başına kadar olan tüm karakterler yok sayılır.

Örnekler

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`'yu akış/dosya sonuna kadar okuyun ve satır sayısını sayın. Bir dosyayı belirtmek için dosya adını ilk argüman olarak geçirin. `'\n'` dışındaki EOL işaretleri, ikinci argüman olarak geçilerek desteklenir. `io`'nun son boş olmayan satırı, EOL ile bitmese bile sayılır; bu, [`eachline`](@ref) ve [`readlines`](@ref) tarafından döndürülen uzunlukla eşleşir.

Bir `String`'in satırlarını saymak için `countlines(IOBuffer(str))` kullanılabilir.

# Örnekler

jldoctest julia> io = IOBuffer("JuliaLang bir GitHub organizasyonudur.\n");

julia> countlines(io) 1

julia> io = IOBuffer("JuliaLang bir GitHub organizasyonudur.");

julia> countlines(io) 1

julia> eof(io) # satır sayma dosya işaretçisini hareket ettirir true

julia> io = IOBuffer("JuliaLang bir GitHub organizasyonudur.");

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

jldoctest julia> write("my_file.txt", "JuliaLang bir GitHub organizasyonudur.\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))

Bir IOBuffer okuma yapmaya ve yazma işlemlerini ekleyerek gerçekleştirmeye olanak tanır. Arama ve kısaltma desteklenmez. Mevcut yapıcılar için IOBuffer belgesine bakın. Eğer data verilirse, bir veri vektörü üzerinde çalışacak bir PipeBuffer oluşturur ve isteğe bağlı olarak, altındaki Array'in büyüyemeyeceği bir boyut belirtebilirsiniz.

readavailable(stream)

Bir akıştan mevcut tamponlanmış verileri okuyun. Gerçek I/O, yalnızca daha önce tamponlanmış veri yoksa gerçekleştirilir. Sonuç bir Vector{UInt8}'dir.

IOContext

IOContext, çıktıyı yapılandırma ayarlarını show yöntemleri arasında geçirme mekanizması sağlar.

Kısacası, IO sınıfının bir alt sınıfı olan değiştirilemez bir sözlüktür. getindex gibi standart sözlük işlemlerini destekler ve ayrıca bir G/Ç akışı olarak da kullanılabilir.

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

Verilen bir akışı saran ve o akışın özelliklerine belirtilen anahtar=>değer çiftlerini ekleyen bir IOContext oluşturun (not: io kendisi bir IOContext olabilir).

• Bu belirli kombinasyonun özellikler setinde olup olmadığını görmek için (anahtar => değer) in io kullanın.
• Belirli bir anahtar için en son değeri almak için get(io, anahtar, varsayılan) kullanın.

Aşağıdaki özellikler yaygın olarak kullanılmaktadır:

• :compact: Değerlerin daha kompakt bir şekilde yazdırılması gerektiğini belirten Boolean, örneğin sayıların daha az basamakla yazdırılması gerektiğini belirtir. Bu, dizi elemanları yazdırılırken ayarlanır. :compact çıktısı satır sonu içermemelidir.
• :limit: Kapların kesilmesi gerektiğini belirten Boolean, örneğin çoğu elemanın yerinde … gösterilmesi.
• :displaysize: Metin çıktısı için kullanılacak satır ve sütun sayısını veren bir Tuple{Int,Int}. Bu, çağrılan fonksiyonlar için görüntüleme boyutunu geçersiz kılmak için kullanılabilir, ancak ekran boyutunu almak için displaysize fonksiyonunu kullanın.
• :typeinfo: Gösterilecek nesnenin türü hakkında daha önce yazdırılan bilgileri karakterize eden bir Type. Bu, aynı türdeki nesnelerin bir koleksiyonu gösterirken gereksiz tür bilgisinin önlenmesi için özellikle yararlıdır (örneğin, [Float16(0)] "Float16[0.0]" olarak gösterilebilir, "Float16[Float16(0.0)]" yerine: dizinin elemanlarını gösterirken, :typeinfo özelliği Float16 olarak ayarlanacaktır).
• :color: ANSI renk/kaçış kodlarının desteklenip beklenmediğini belirten Boolean. Varsayılan olarak, bu, io'nun uyumlu bir terminal olup olmadığına ve julia başlatıldığında herhangi bir --color komut satırı bayrağına bağlı olarak belirlenir.

Örnekler

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)

Bir IOContext oluşturun, alternatif bir IO'yu sarar ancak context'in özelliklerini miras alır.

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

Bir değer x'in metin temsilini çıkış akışı io'ya yazın. Yeni türler T, show(io::IO, x::T) ile aşırı yüklenmelidir. show tarafından kullanılan temsil genellikle Julia'ya özgü biçimlendirme ve tür bilgilerini içerir ve mümkün olduğunda ayrıştırılabilir Julia kodu olmalıdır.

repr show'un çıktısını bir dize olarak döndürür.

T türündeki nesneler için daha ayrıntılı insan tarafından okunabilir metin çıktısı almak için, ayrıca show(io::IO, ::MIME"text/plain", ::T) tanımlayın. Bu tür yöntemlerde io'nun :compact IOContext anahtarını kontrol etmek önerilir (genellikle get(io, :compact, false)::Bool olarak kontrol edilir), çünkü bazı konteynerler elemanlarını :compact => true ile bu yöntemle gösterir.

Ayrıca print ile ilgili, süssüz temsilleri yazar.

Örnekler

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

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

Bir akışa io yazdırır veya bir değer hakkında kısa bir açıklama veren bir dize str döndürür. Varsayılan olarak string(typeof(x)) döner, örneğin Int64.

Diziler için, boyut ve tür bilgilerini içeren bir dize döner, örneğin 10-element Array{Int64,1}.

Örnekler

julia> summary(1)
"Int64"

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

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

io'ya (ve io verilmemişse varsayılan çıktı akışına stdout) kanonik (süslenmemiş) bir metin temsili yazın. print tarafından kullanılan temsil, minimum biçimlendirme içerir ve Julia'ya özgü ayrıntılardan kaçınmaya çalışır.

print, show çağrısına geri döner, bu nedenle çoğu tür sadece show tanımlamalıdır. Eğer türünüzün ayrı bir "düz" temsili varsa print tanımlayın. Örneğin, show dizeleri tırnak içinde gösterirken, print dizeleri tırnaksız gösterir.

Ayrıca bkz. println, string, printstyled.

Örnekler

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

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

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

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

xs'yi io'ya yazdırır ( print kullanarak) ve ardından bir yeni satır ekler. Eğer io sağlanmamışsa, varsayılan çıkış akışına stdout yazdırır.

Renkler eklemek için printstyled ile de bakabilirsiniz.

Örnekler

julia> println("Merhaba, dünya")
Merhaba, dünya

julia> io = IOBuffer();

julia> println(io, "Merhaba", ',', " dünya.")

julia> String(take!(io))
"Merhaba, dünya.\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'yi bir sembol veya tam sayı olarak belirtilen bir renkte, isteğe bağlı olarak kalın olarak yazdırır.

color anahtar kelimesi :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 veya :yellow veya 0 ile 255 arasında bir tam sayı alabilir. Tüm terminallerin 256 rengi desteklemediğini unutmayın.

bold=true, italic=true, underline=true, blink=true anahtar kelimeleri kendiliğinden açıklayıcıdır. reverse=true anahtar kelimesi, ön plan ve arka plan renklerini değiştirilmiş olarak yazdırır ve hidden=true terminalde görünmez olmalıdır ancak yine de kopyalanabilir. Bu özellikler herhangi bir kombinasyonda kullanılabilir.

Ayrıca print, println, show bakınız.

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

Verilen fonksiyonu bir I/O akışı ile ve sağlanan ek argümanlarla çağırır. Bu I/O akışına yazılan her şey bir dize olarak döndürülür. context, özelliklerinin kullanılacağı bir IOContext olabilir, bir özelliği ve değerini belirten bir Pair, veya birden fazla özelliği ve değerlerini belirten Pair'lerin bir demeti olabilir. sizehint, tamponun kapasitesini (bayt cinsinden) önerir.

İsteğe bağlı anahtar argümanı context, bir :key=>value çifti, bir :key=>value çiftleri demeti veya f'ye geçirilen I/O akışı için kullanılan özellikleri olan bir IO veya IOContext nesnesi olarak ayarlanabilir. İsteğe bağlı sizehint, dizeyi yazmak için kullanılan tampon için ayrılması önerilen boyuttur (bayt cinsinden).

Örnekler

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)

Bir istisna nesnesinin e tanımlayıcı bir temsilini gösterir. Bu yöntem, throw çağrısından sonra istisnayı görüntülemek için kullanılır.

Örnekler

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"))
HATA: MyException: test exception

dump(x; maxdepth=8)

Bir değerin temsilinin her parçasını gösterir. Çıktının derinliği maxdepth ile kesilir.

Örnekler

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

Verilen ifadenin temsilinin her bir parçasını gösterir. dump(:(expr)) ile eşdeğerdir.

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

Verilen I/O akışından veya dosyadan (varsayılan olarak stdin) bir satır metin okuyun. Bir dosyadan okurken, metnin UTF-8 ile kodlandığı varsayılır. Girişteki satırlar '\n' veya "\r\n" ile veya bir giriş akışının sonu ile biter. keep false olduğunda (varsayılan olarak olduğu gibi), bu sonlandırıcı yeni satır karakterleri, döndürülen satırdan önce kaldırılır. keep true olduğunda, bunlar satırın bir parçası olarak döndürülür.

Bir String döndürür. Bunun yerine başka bir akışa yerinde yazmak için copyline ile de bakın (bu, önceden tahsis edilmiş bir IOBuffer olabilir).

Daha genel ayırıcılar için okumak üzere readuntil ile de bakın.

Örnekler

julia> write("my_file.txt", "JuliaLang bir GitHub organizasyonudur.\nBirçok üyesi vardır.\n");

julia> readline("my_file.txt")
"JuliaLang bir GitHub organizasyonudur."

julia> readline("my_file.txt", keep=true)
"JuliaLang bir GitHub organizasyonudur.\n"

julia> rm("my_file.txt")

julia> print("Adınızı girin: ")
Adınızı girin:

julia> your_name = readline()
Logan
"Logan"

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

Bir I/O stream veya bir dosyadan, verilen ayırıcıya kadar bir dize okuyun. Ayırıcı bir UInt8, AbstractChar, dize veya vektör olabilir. Anahtar argüman keep, ayırıcının sonucun içinde yer alıp almayacağını kontrol eder. Metnin UTF-8 ile kodlandığı varsayılmaktadır.

Eğer delim bir AbstractChar veya bir dize ise bir String döndürün, aksi takdirde Vector{typeof(delim)} döndürün. Bunun yanı sıra, başka bir akışa (önceden tahsis edilmiş bir IOBuffer olabilir) yerinde yazmak için copyuntil fonksiyonuna da bakın.

Örnekler

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)

Bir I/O akışının veya bir dosyanın tüm satırlarını bir dize vektörü olarak okuyun. Davranış, readline fonksiyonunu aynı argümanlarla tekrar tekrar çağırmanın sonucunu kaydetmek ve elde edilen satırları bir dize vektörü olarak saklamakla eşdeğerdir. Tüm satırları bir kerede okumadan satırları yinelemek için eachline fonksiyonuna da bakın.

Örnekler

julia> write("my_file.txt", "JuliaLang bir GitHub organizasyonudur.\nBirçok üyesi vardır.\n");

julia> readlines("my_file.txt")
2-element Vector{String}:
 "JuliaLang bir GitHub organizasyonudur."
 "Birçok üyesi vardır."

julia> readlines("my_file.txt", keep=true)
2-element Vector{String}:
 "JuliaLang bir GitHub organizasyonudur.\n"
 "Birçok üyesi vardır.\n"

julia> rm("my_file.txt")

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

Bir I/O akışı veya dosyadan her satırı verecek bir iterable EachLine nesnesi oluşturur. İterasyon, keep parametresi ile birlikte akış argümanında readline çağrıları yaparak, sonundaki satır sonu karakterlerinin korunup korunmayacağını belirler. Bir dosya adı ile çağrıldığında, dosya iterasyonun başında bir kez açılır ve sonunda kapatılır. İterasyon kesilirse, dosya EachLine nesnesi çöp toplandığında kapatılacaktır.

Bir String'in her satırını yinelemek için eachline(IOBuffer(str)) kullanılabilir.

Iterators.reverse bir EachLine nesnesinde ters sırayla satırları okumak için kullanılabilir (dosyalar, tamponlar ve seek destekleyen diğer I/O akışları için) ve first veya last başlangıç veya son satırları çıkarmak için kullanılabilir.

Örnekler

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)

Bir I/O `stream` veya bir dosyadan bir metin satırını `out` akışına kopyalar ve `out`'u döner.

Bir dosyadan okurken, metnin UTF-8 ile kodlandığı varsayılır. Girişteki satırlar `'\n'` veya `"\r\n"` ile veya bir giriş akışının sonu ile biter. `keep` false olduğunda (varsayılan olarak olduğu gibi), bu son satır sonu karakterleri döndürülmeden önce satırdan kaldırılır. `keep` true olduğunda, bunlar satırın bir parçası olarak döndürülür.

[`readline`](@ref) ile benzer, bu `String` döndürür; aksine, `copyline` doğrudan `out`'a yazar, bir dize tahsis etmeden. (Bu, örneğin, verileri önceden tahsis edilmiş bir [`IOBuffer`](@ref) içine okumak için kullanılabilir.)

Daha genel ayırıcılar için okumak üzere [`copyuntil`](@ref) ile de bakabilirsiniz.

# Örnekler

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

Bir I/O `stream` veya bir dosyadan, verilen ayırıcıya kadar bir dizeyi `out` akışına kopyalar ve `out`'u döner. Ayırıcı bir `UInt8`, `AbstractChar`, dize veya vektör olabilir. Anahtar kelime argümanı `keep`, ayırıcının sonuca dahil edilip edilmeyeceğini kontrol eder. Metnin UTF-8 olarak kodlandığı varsayılmaktadır.

[`readuntil`](@ref) ile benzer; bu, bir `String` döner; aksine, `copyuntil` doğrudan `out`'a yazar, bir dize tahsis etmeden. (Bu, örneğin, önceden tahsis edilmiş bir [`IOBuffer`](@ref) içine veri okumak için kullanılabilir.)

# Örnekler

jldoctest 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]) -> (satırlar, sütunlar)

Bu IO nesnesine çıktı render etmek için kullanılabilecek ekranın nominal boyutunu döndürür. Hiçbir girdi sağlanmazsa, ortam değişkenleri LINES ve COLUMNS okunur. Eğer bunlar ayarlanmamışsa, varsayılan boyut olarak (24, 80) döndürülür.

Örnekler

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

TTY boyutunuzu almak için,

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

Zengin görüntü çıkış cihazları için soyut süper tür. TextDisplay bunun bir alt türüdür.

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

x'i, genellikle x için en zengin desteklenen multimedya çıktısını kullanarak, görüntüleme yığınındaki en üstteki uygun görüntüleme ile gösterin; düz metin stdout çıktısı bir yedek olarak kullanılır. display(d, x) varyantı, yalnızca verilen görüntüleme d üzerinde x'i görüntülemeye çalışır ve d bu tür nesneleri görüntüleyemiyorsa bir MethodError fırlatır.

Genel olarak, display çıktısının stdout'a gideceğini varsayamazsınız (print(x) veya show(x) ile karşılaştırıldığında). Örneğin, display(x) bir görüntü ile ayrı bir pencere açabilir. display(x), "şu anda mevcut çıktı cihaz(lar)ı için x'i en iyi şekilde göster" anlamına gelir. stdout'a gitmesi garanti edilen REPL benzeri metin çıktısı istiyorsanız, bunun yerine show(stdout, "text/plain", x) kullanın.

Ayrıca, yalnızca istenen MIME türünü kullanarak x'i görüntülemeye çalışan iki varyant vardır (örneğin, "image/png" gibi bir MIME türü dizesi), bu tür desteklenmiyorsa görüntüleme(ler) veya x için bir MethodError fırlatır. Bu varyantlarla, istenen MIME türünde "ham" veriyi sağlamak için x::AbstractString (metin tabanlı depolama için MIME türleri, örneğin text/html veya application/postscript) veya x::Vector{UInt8} (ikili MIME türleri için) geçirebilirsiniz.

Bir türün örneklerinin nasıl görüntüleneceğini özelleştirmek için, show yerine display'i aşırı yükleyin; bu, özel güzel yazdırma konusundaki kılavuzda açıklanmıştır.

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

Varsayılan olarak, redisplay fonksiyonları basitçe display çağrısını yapar. Ancak, bazı görüntüleme arka uçları mevcut x görüntüsünü (varsa) değiştirmek için redisplay'i geçersiz kılabilir. redisplay kullanmak, arka uca x'in birkaç kez yeniden görüntülenebileceği konusunda bir ipucu verir ve arka uç, görüntülemeyi (örneğin) bir sonraki etkileşimli isteme kadar ertelemeyi seçebilir.

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

Verilen mime türünün (string) mevcut görüntüleme yığınındaki herhangi bir görüntüleme tarafından görüntülenebilir olup olmadığını veya ikinci varyantta özellikle görüntüleme d tarafından görüntülenebilir olup olmadığını belirten bir boolean değeri döndürür.

show(io::IO, mime, x)

The display fonksiyonları, bir nesneyi x belirli bir mime türü olarak belirli bir I/O akışına io (genellikle bir bellek tamponu) yazmak için show çağrısında bulunur. Kullanıcı tanımlı bir tür T için zengin bir multimedya temsili sağlamak amacıyla, T için yeni bir show yöntemi tanımlamak yeterlidir; bu, show(io, ::MIME"mime", x::T) = ... şeklinde yapılır; burada mime bir MIME türü dizesidir ve fonksiyon gövdesi, x'in io'ya yazılacak temsili için write (veya benzeri) çağrısını içerir. (Not: MIME"" notasyonu yalnızca literal dizeleri destekler; daha esnek bir şekilde MIME türleri oluşturmak için MIME{Symbol("")} kullanın.)

Örneğin, bir MyImage türü tanımlarsanız ve bunu bir PNG dosyasına yazmayı biliyorsanız, show(io, ::MIME"image/png", x::MyImage) = ... şeklinde bir fonksiyon tanımlayarak resimlerinizi herhangi bir PNG uyumlu AbstractDisplay (örneğin IJulia) üzerinde görüntülemenizi sağlayabilirsiniz. Her zamanki gibi, yerleşik Julia fonksiyonu show'a yeni yöntemler eklemek için import Base.show kullandığınızdan emin olun.

Teknik olarak, MIME"mime" makrosu, verilen mime dizesi için bir singleton türü tanımlar; bu, belirli bir türdeki nesneleri nasıl görüntüleyeceğimizi belirlemede Julia'nın dağıtım mekanizmalarından yararlanmamıza olanak tanır.

Varsayılan MIME türü MIME"text/plain"'dir. text/plain çıktısı için show'u 2 argümanla çağıran bir geri dönüş tanımı vardır, bu nedenle bu durum için her zaman bir yöntem eklemek gerekli değildir. Ancak bir tür, özel insan tarafından okunabilir çıktılardan faydalanıyorsa, show(::IO, ::MIME"text/plain", ::T) tanımlanmalıdır. Örneğin, Day türü text/plain MIME türü için 1 day çıktısını kullanır ve Day(1) iki argümanlı show'un çıktısıdır.

Örnekler

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

Konteyner türleri genellikle show(io, MIME"text/plain"(), x) çağrısını yaparak 3 argümanlı show'u uygular; burada x elemanlarıdır ve ilk argüman olarak geçirilen bir IOContext içinde :compact => true ayarı yapılmıştır.

showable(mime, x)

Verilen mime türünde nesne x'in yazılıp yazılamayacağını belirten bir boolean değeri döndürür.

(Varsayılan olarak, bu, typeof(x) için karşılık gelen show yönteminin varlığına göre otomatik olarak belirlenir. Bazı türler özel showable yöntemleri sağlar; örneğin, mevcut MIME formatları x'in değerine bağlıysa.)

Örnekler

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

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

repr(mime, x; context=nothing)

x'in istenen mime türünde temsilini içeren bir AbstractString veya Vector{UInt8} döndürür; bu, show(io, mime, x) tarafından yazıldığı gibi (uygun bir show mevcut değilse MethodError fırlatır). Metinsel temsillere sahip MIME türleri için (örneğin "text/html" veya "application/postscript" gibi) bir AbstractString dönerken, ikili veriler Vector{UInt8} olarak döner. (istextmime(mime) fonksiyonu, Julia'nın belirli bir mime türünü metin olarak değerlendirip değerlendirmediğini döndürür.)

İsteğe bağlı anahtar argümanı context, show'a geçirilen I/O akışı için kullanılan özellikleri olan :key=>value çifti veya bir IO veya IOContext nesnesi olarak ayarlanabilir.

Özel bir durum olarak, eğer x bir AbstractString (metinsel MIME türleri için) veya bir Vector{UInt8} (ikili MIME türleri için) ise, repr fonksiyonu x'in zaten istenen mime formatında olduğunu varsayar ve basitçe x'i döndürür. Bu özel durum "text/plain" MIME türüne uygulanmaz. Bu, ham verilerin display(m::MIME, x)'e geçirilmesi için yararlıdır.

Özellikle, repr("text/plain", x) genellikle insan tüketimi için tasarlanmış x'in "güzel basılmış" bir versiyonudur. Bunun yerine show(x) ile daha yakın bir şekilde x'in değerinin Julia'da nasıl girileceğine karşılık gelen bir dize döndürmek için repr(x) ile de bakabilirsiniz.

Örnekler

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

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

MIME

Standart bir internet veri formatını temsil eden bir tür. "MIME", "Çok Amaçlı İnternet Posta Uzantıları"nın kısaltmasıdır, çünkü standart başlangıçta e-posta mesajlarına çoklu ortam eklerini tanımlamak için kullanılmıştır.

Bir MIME nesnesi, o formatta çıktı talep etmek için show fonksiyonuna ikinci argüman olarak geçirilebilir.

Örnekler

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

@MIME_str

MIME türlerini yazmak için bir kolaylık makrosudur, genellikle show yöntemlerine eklenirken kullanılır. Örneğin, show(io::IO, ::MIME"text/html", x::MyType) = ... sözdizimi, MyType'ın HTML temsilini nasıl yazacağınızı tanımlamak için kullanılabilir.

pushdisplay(d::AbstractDisplay)

Yeni bir d görüntüsünü global görüntü arka planı yığınına ekler. display(x) veya display(mime, x) çağrısı, yığındaki en üstteki uyumlu arka planda x'i görüntüler (yani, MethodError fırlatmayan en üstteki arka plan).

popdisplay()
popdisplay(d::AbstractDisplay)

Ekran arka planı yığınından en üstteki arka planı veya ikinci varyantta d'nin en üstteki kopyasını çıkarır.

TextDisplay(io::IO)

Bir TextDisplay <: AbstractDisplay döndürür, bu da herhangi bir nesneyi metin/plain MIME türü olarak (varsayılan olarak) görüntüler ve metin temsilini verilen I/O akışına yazar. (Bu, nesnelerin Julia REPL'de nasıl yazdırıldığını gösterir.)

istextmime(m::MIME)

Bir MIME türünün metin verisi olup olmadığını belirleyin. MIME türlerinin, metin verisi olduğu bilinen bir dizi tür dışında, ikili veri olduğu varsayılmaktadır (muhtemelen Unicode).

Örnekler

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

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

bytesavailable(io)

Bu akış veya tampondan bir okuma engellenmeden önce okunabilir durumda olan bayt sayısını döndürür.

Örnekler

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

julia> bytesavailable(io)
34

ntoh(x)

Bir değerin son bayt sırasını Ağ bayt sırasından (büyük-endian) Ana makine tarafından kullanılan sıraya dönüştürür.

hton(x)

Bir değerin son bit sırasını, Host tarafından kullanılan biçimden Ağ bayt sırasına (büyük-endian) dönüştürür.

ltoh(x)

Bir değerin son bit sırasını Küçük-endian'dan Ana Bilgisayar tarafından kullanılan biçime dönüştürür.

htol(x)

Bir değerin son bit sırasını Ana Bilgisayar tarafından kullanılan biçimden Küçük-endian biçimine dönüştürür.

ENDIAN_BOM

32 bitlik bayt sırası işareti, ana makinenin yerel bayt sırasını gösterir. Küçük sonlu makineler 0x04030201 değerini içerecektir. Büyük sonlu makineler 0x01020304 değerini içerecektir.