Essentials

exit(code=0)

Programı bir çıkış kodu ile durdurun. Varsayılan çıkış kodu sıfırdır ve bu, programın başarıyla tamamlandığını gösterir. Etkileşimli bir oturumda, exit() klavye kısayolu ^D ile çağrılabilir.

atexit(f)

Bir sıfır veya bir argümanlı f() fonksiyonunu işlem çıkışında çağrılmak üzere kaydedin. atexit() kancaları son giren ilk çıkar (LIFO) sırasına göre çağrılır ve nesne sonlandırıcılarından önce çalıştırılır.

Eğer f için bir tam sayı argümanı tanımlanmış bir yöntem varsa, f(n::Int32) olarak çağrılacaktır; burada n mevcut çıkış kodudur, aksi takdirde f() olarak çağrılacaktır.

Çıkış kancalarının exit(n) çağrısında bulunmasına izin verilir; bu durumda Julia çıkış kodu n ile çıkacaktır (orijinal çıkış kodu yerine). Eğer birden fazla çıkış kancası exit(n) çağrısında bulunursa, Julia, exit(n) çağrısında bulunan son çağrılan çıkış kancasına karşılık gelen çıkış kodu ile çıkacaktır. (Çünkü çıkış kancaları LIFO sırasına göre çağrılır, "son çağrılan" ifadesi "ilk kaydedilen" ile eşdeğerdir.)

Not: Tüm çıkış kancaları çağrıldıktan sonra, daha fazla çıkış kancası kaydedilemez ve tüm kancalar tamamlandıktan sonra atexit(f) çağrısı yapmak bir istisna fırlatır. Bu durum, arka planda hala eşzamanlı olarak çalışan Görevlerden çıkış kancaları kaydediyorsanız meydana gelebilir.

isinteractive() -> Bool

Julia'nın etkileşimli bir oturumda çalışıp çalışmadığını belirler.

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

Argümanı erişilebilen tüm benzersiz nesnelerin kullandığı bellek miktarını, bayt cinsinden hesaplar.

Anahtar Argümanlar

• exclude: gezintiden hariç tutulacak nesne türlerini belirtir.
• chargeall: normalde hariç tutulacak olan alanların boyutunu her zaman hesaplamak için nesne türlerini belirtir.

Ayrıca bkz. sizeof.

Örnekler

julia> Base.summarysize(1.0)
8

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

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

__precompile__(isprecompilable::Bool)

Bu fonksiyonu çağıran dosyanın ön derlenebilir olup olmadığını belirtir, varsayılan olarak true'dur. Bir modül veya dosya güvenli bir şekilde ön derlenebilir değilse, Julia'nın onu ön derlemeye çalışması durumunda bir hata fırlatmak için __precompile__(false) çağrısı yapmalıdır.

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

Modül m'nin global kapsamındaki giriş kaynak dosyasının içeriğini değerlendirir. baremodule ile tanımlananlar hariç her modülün, o modülde dosyayı değerlendiren m argümanını atlayan kendi include tanımı vardır. Giriş dosyasının son değerlendirilen ifadesinin sonucunu döner. Dahil etme sırasında, dosyanın bulunduğu dizine göre bir görev-yerel dahil etme yolu ayarlanır. İç içe çağrılar include, o yola göre arama yapar. Bu işlev genellikle kaynakları etkileşimli olarak yüklemek veya birden fazla kaynak dosyasına bölünmüş paketlerde dosyaları birleştirmek için kullanılır.

İsteğe bağlı ilk argüman mapexpr, dahil edilen kodu değerlendirilmeye başlamadan önce dönüştürmek için kullanılabilir: path içindeki her bir ayrıştırılmış ifade expr için, include işlevi aslında mapexpr(expr)'i değerlendirir. Eğer atlanırsa, mapexpr varsayılan olarak identity olur.

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

Girdi kaynak dosyasının içeriğini içeren modülün global kapsamına değerlendirir. baremodule ile tanımlananlar hariç her modülün kendi include tanımı vardır ve bu, dosyayı o modülde değerlendirir. Girdi dosyasının son değerlendirilen ifadesinin sonucunu döner. Dahil etme sırasında, dosyanın bulunduğu dizine göre bir görev-yerel dahil etme yolu ayarlanır. İç içe çağrılar include, o yola göre arama yapar. Bu işlev genellikle kaynakları etkileşimli olarak yüklemek veya birden fazla kaynak dosyasına bölünmüş paketlerde dosyaları birleştirmek için kullanılır. path argümanı, .. gibi göreli yol belirteçlerini çözmek ve /'yi uygun yol ayırıcıya dönüştürmek için normpath kullanılarak normalize edilir.

İsteğe bağlı ilk argüman mapexpr, dahil edilen kodu değerlendirilmeye başlamadan önce dönüştürmek için kullanılabilir: path içindeki her ayrıştırılmış ifade expr için, include işlevi aslında mapexpr(expr)'i değerlendirir. Eğer atlanırsa, mapexpr varsayılan olarak identity olur.

Başka bir modüle bir dosyayı değerlendirmek için Base.include kullanın.

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

include ile benzer, ancak kodu bir dosyadan değil, verilen string'den okur.

İsteğe bağlı ilk argüman mapexpr, dahil edilen kodu değerlendirilmeye başlamadan önce dönüştürmek için kullanılabilir: code içindeki her bir ayrıştırılmış ifade expr için, include_string fonksiyonu aslında mapexpr(expr)'i değerlendirir. Eğer belirtilmezse, mapexpr varsayılan olarak identity olur.

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

Bir modülde, path (göreceli veya mutlak) ile belirtilen dosyanın, dizinin veya sembolik bağlantının ön derleme için bir bağımlılık olduğunu belirtin; yani, track_content=true ise, path'in içeriği değişirse modülün yeniden derlenmesi gerekecektir (eğer path bir dizin ise içerik join(readdir(path)) ile eşittir). Eğer track_content=false ise, yeniden derleme, path'in değişiklik zamanı mtime değiştiğinde tetiklenir.

Bu, modülünüzün include aracılığıyla kullanılmayan bir yola bağımlı olması durumunda yalnızca gereklidir. Derleme dışında hiçbir etkisi yoktur.

__init__

__init__() fonksiyonu bir modül yüklendiğinde çalışma zamanında ilk kez hemen yürütülür. Modüldeki diğer tüm ifadeler yürütüldükten sonra bir kez çağrılır. Modül tamamen yüklendikten sonra çağrıldığı için, alt modüllerin __init__ fonksiyonları önce yürütülecektir. __init__'in iki tipik kullanımı, dış C kütüphanelerinin çalışma zamanı başlatma fonksiyonlarını çağırmak ve dış kütüphaneler tarafından döndürülen işaretçileri içeren global sabitleri başlatmaktır. Daha fazla ayrıntı için modüller hakkında kılavuz bölümüne bakın.

Örnekler

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)

Verilen types argümanları için çağrılacak f'nin (bir Method nesnesi) yöntemini döndürür.

Eğer types soyut bir türse, o zaman invoke tarafından çağrılacak yöntem döndürülür.

Ayrıca bakınız: parentmodule, @which, ve @edit.

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

f için yöntem tablosunu döndür.

Eğer types belirtilmişse, türleri eşleşen yöntemlerin bir dizisini döndür. Eğer module belirtilmişse, o modülde tanımlanan yöntemlerin bir dizisini döndür. Bir dizi olarak birden fazla modül de belirtilebilir.

Ayrıca bakınız: which, @which ve methodswith.

@show exs...

Bir veya daha fazla ifadeyi ve sonuçlarını stdout'a yazdırır ve son sonucu döndürür.

Ayrıca bakınız: show, @info, println.

Örnekler

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

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

ans

Sonuçlanan son değere atıfta bulunan bir değişken, etkileşimli isteme otomatik olarak aktarılır.

err

Son bir atılan hataları referans alan bir değişken, etkileşimli isteme otomatik olarak aktarılır. Atılan hatalar bir istisna yığını içinde toplanır.

active_project()

Aktif Project.toml dosyasının yolunu döndürür. Ayrıca bkz. Base.set_active_project.

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

Aktif Project.toml dosyasını projfile olarak ayarlayın. Ayrıca bkz. Base.active_project.

modül

modül, ayrı bir global değişken çalışma alanı olan bir Modül tanımlar. Bir modül içinde, diğer modüllerden hangi isimlerin görünür olduğunu kontrol edebilir (içe aktarma yoluyla) ve kendi isimlerinizin hangilerinin kamuya açık olduğunu belirtebilirsiniz ( export ve public aracılığıyla). Modüller, kodunuzun başka birinin koduyla birlikte kullanıldığında isim çakışmalarından endişe etmeden üst düzey tanımlar oluşturmanıza olanak tanır. Daha fazla ayrıntı için modüllerle ilgili kılavuz bölümüne bakın.

Örnekler

modül 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, modüller içinde, Julia'ya hangi isimlerin kullanıcıya sunulması gerektiğini belirtmek için kullanılır. Örneğin: export foo, foo ismini modülü using kullanırken erişilebilir hale getirir. Detaylar için modüller hakkındaki kılavuz bölümüne bakın.

public

public, modüller içinde, Julia'ya modülün hangi isimlerinin kamu API'sinin bir parçası olduğunu belirtmek için kullanılır. Örneğin: public foo, foo isminin kamuya açık olduğunu belirtir, ancak modülü using kullanırken erişilebilir hale getirmez. Ayrıntılar için modüller hakkındaki kılavuz bölümüne bakın.

import

import Foo modülünü veya paketi Foo yükleyecektir. İçe aktarılan Foo modülündeki isimlere nokta sözdizimi ile erişilebilir (örneğin, Foo.foo ismini erişmek için). Ayrıntılar için modüller hakkında kılavuz bölümüne bakın.

using

using Foo modül veya paket Foo'yu yükleyecek ve onun export edilmiş isimlerini doğrudan kullanım için erişilebilir hale getirecektir. İsimler, export edilmiş olsun ya da olmasın, nokta sözdizimi ile de kullanılabilir (örneğin, Foo.foo ile foo ismine erişmek için). Ayrıntılar için modüller hakkında kılavuz bölümüne bakın.

as

as, import veya using ile kapsamda getirilen bir tanımlayıcıyı yeniden adlandırmak için bir anahtar kelime olarak kullanılır; bu, ad çakışmalarını aşmak ve isimleri kısaltmak amacıyla yapılır. (import veya using ifadeleri dışında, as bir anahtar kelime değildir ve sıradan bir tanımlayıcı olarak kullanılabilir.)

import LinearAlgebra as LA, içe aktarılan LinearAlgebra standart kütüphanesini LA olarak kapsamda getirir.

import LinearAlgebra: eigen as eig, cholesky as chol, LinearAlgebra'dan eigen ve cholesky yöntemlerini sırasıyla eig ve chol olarak kapsamda getirir.

as, yalnızca bireysel tanımlayıcılar kapsamda getirildiğinde using ile çalışır. Örneğin, using LinearAlgebra: eigen as eig veya using LinearAlgebra: eigen as eig, cholesky as chol geçerlidir, ancak using LinearAlgebra as LA geçersiz bir sözdizimidir, çünkü LinearAlgebra'dan tüm dışa aktarılan isimleri LA olarak yeniden adlandırmak mantıksızdır.

baremodule

baremodule, using Base veya eval ve include için yerel tanımlar içermeyen bir modül bildirir. Yine de Core'u içe aktarır. Diğer bir deyişle,

module Mod

...

end

şuna eşdeğerdir:

baremodule Mod

using Base

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

...

end

function

Fonksiyonlar function anahtar kelimesi ile tanımlanır:

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

Ya da kısa form notasyonu:

add(a, b) = a + b

return anahtar kelimesinin kullanımı diğer dillerdeki ile tam olarak aynıdır, ancak genellikle isteğe bağlıdır. Açık bir return ifadesi olmayan bir fonksiyon, fonksiyon gövdesindeki son ifadeyi döndürecektir.

makro

makro, üretilen kodu bir programa eklemek için bir yöntem tanımlar. Bir makro, bir dizi argüman ifadesini döndürülen bir ifadeye eşler ve sonuçta elde edilen ifade, makronun çağrıldığı noktada programa doğrudan yerleştirilir. Makrolar, üretilen kodu eval çağırmadan çalıştırmanın bir yoludur, çünkü üretilen kod, çevresindeki programın bir parçası haline gelir. Makro argümanları ifadeler, literal değerler ve semboller içerebilir. Makrolar, değişken sayıda argüman (varargs) için tanımlanabilir, ancak anahtar kelime argümanlarını kabul etmez. Her makro ayrıca, makronun çağrıldığı satır numarasını ve dosya adını içeren __source__ argümanını ve makronun genişletildiği modülü belirten __module__ argümanını da otomatik olarak alır.

Bir makro yazma hakkında daha fazla bilgi için Metaprogramming bölümüne bakın.

Örnekler

julia> makro sayhello(name)
           return :( println("Merhaba, ", $name, "!") )
       end
@sayhello (1 yöntemli makro)

julia> @sayhello "Charlie"
Merhaba, Charlie!

julia> makro saylots(x...)
           return :( println("De: ", $(x...)) )
       end
@saylots (1 yöntemli makro)

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

return

return x, verilen değeri x çağıranına geri göndererek kapsayıcı fonksiyonun erken çıkmasına neden olur. Değer olmadan return kullanmak, return nothing ile eşdeğerdir (bkz. nothing).

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

Genel olarak, bir return ifadesini bir fonksiyon gövdesinin herhangi bir yerine, derinlemesine iç içe döngüler veya koşullar içinde yerleştirebilirsiniz, ancak do blokları ile dikkatli olun. Örneğin:

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

İlk örnekte, return bir çift sayı ile karşılaştığında test1'den çıkış yapar, bu nedenle test1([5,6,7]) 12 döner.

İkinci örneğin aynı şekilde davranmasını bekleyebilirsiniz, ancak aslında oradaki return yalnızca içteki fonksiyondan ( do bloğu içindeki) çıkış yapar ve bir değer map'e geri verir. test2([5,6,7]) ardından [5,12,7] döner.

Üst düzey bir ifadede (yani herhangi bir fonksiyonun dışında) kullanıldığında, return mevcut üst düzey ifadenin tamamının erken sona ermesine neden olur.

do

Anonim bir fonksiyon oluşturun ve bunu bir fonksiyon çağrısının ilk argümanı olarak geçirin. Örneğin:

map(1:10) do x
    2x
end

şu ile eşdeğerdir: map(x->2x, 1:10).

Birden fazla argüman kullanın:

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

begin

begin...end bir kod bloğunu belirtir.

begin
    println("Merhaba, ")
    println("Dünya!")
end

Genellikle begin gerekli olmayacaktır, çünkü function ve let gibi anahtar kelimeler, kod bloklarını örtük olarak başlatır. Ayrıca bkz. ;.

begin ayrıca bir koleksiyonun ilk indeksini veya bir dizinin ilk indeksini temsil etmek için dizinleme sırasında da kullanılabilir. Örneğin, a[begin] bir dizi anın ilk elemanıdır.

Örnekler

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, bir ifade bloğunun sonunu işaret eder; örneğin module, struct, mutable struct, begin, let, for vb.

end, ayrıca bir koleksiyonun son indeksini veya bir dizinin son indeksini temsil etmek için indeksleme sırasında da kullanılabilir.

Örnekler

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 blokları yeni bir katı kapsam oluşturur ve isteğe bağlı olarak yeni yerel bağlamalar tanıtır.

Diğer kapsam yapıları gibi, let blokları yeni tanıtılan yerel değişkenlerin erişilebilir olduğu kod bloğunu tanımlar. Ayrıca, sözdizimi, virgülle ayrılmış atamalar ve isteğe bağlı olarak let ile aynı satırda görünebilecek değişken adları için özel bir anlam taşır:

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

Bu satırda tanıtılan değişkenler let bloğuna özgüdür ve atamalar sırayla değerlendirilir; her sağ taraf, soldaki isim dikkate alınmadan kapsamda değerlendirilir. Bu nedenle, let x = x gibi bir şey yazmak mantıklıdır, çünkü iki x değişkeni farklıdır ve soldaki taraf, dış kapsamdan gelen x'i yerel olarak gölgeler. Bu, yerel kapsamlar her girişte yeni yerel değişkenler oluşturduğundan, yararlı bir deyim olabilir, ancak bu yalnızca kapsamlarını aşan değişkenler için gözlemlenebilir. Yukarıdaki örnekteki var2 gibi bir atama olmadan let değişkeni, henüz bir değere bağlanmamış yeni bir yerel değişken tanımlar.

Buna karşılık, begin blokları da birden fazla ifadeyi bir araya getirir, ancak kapsam tanıtmaz veya özel atama sözdizimine sahip değildir.

Örnekler

Aşağıdaki işlevde, map tarafından üç kez iteratif olarak güncellenen tek bir x vardır. Döndürülen kapanışlar, o bir x'in son değerini referans alır:

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

Ancak, yeni bir yerel değişken tanıtan bir let bloğu eklersek, her bir yinelemede yakalanan üç farklı değişkenle sonuçlanır, bu durumda aynı ismi (gölgeleme) kullanmayı seçmiş olsak bile.

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

Yeni yerel değişkenler tanıtan tüm kapsam yapıları, tekrar tekrar çalıştırıldığında bu şekilde davranır; let'in ayırt edici özelliği, aynı isimdeki dış değişkenleri gölgelerken yeni local'ları özlü bir şekilde tanımlama yeteneğidir. Örneğin, do işlevinin argümanını doğrudan kullanmak da benzer şekilde üç farklı değişkeni yakalar:

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 koşullu değerlendirme yapar, bu da kodun belirli bölümlerinin bir boolean ifadenin değerine bağlı olarak değerlendirilip değerlendirilmeyeceği anlamına gelir. İşte if/elseif/else koşullu sözdiziminin anatomisi:

if x < y
    println("x y'den küçüktür")
elseif x > y
    println("x y'den büyüktür")
else
    println("x y'ye eşittir")
end

Eğer koşul ifadesi x < y doğruysa, o zaman ilgili blok değerlendirilir; aksi takdirde koşul ifadesi x > y değerlendirilir ve eğer bu doğruysa, ilgili blok değerlendirilir; eğer hiçbir ifade doğru değilse, else bloğu değerlendirilir. elseif ve else blokları isteğe bağlıdır ve istenildiği kadar elseif bloğu kullanılabilir.

Bazı diğer dillerin aksine, koşullar Bool türünde olmalıdır. Koşulların Bool'a dönüştürülebilir olması yeterli değildir.

julia> if 1 end
HATA: TypeError: boolean bağlamında kullanılan non-boolean (Int64)

için

için döngüleri, bir değerler dizisi üzerinde yineleme yaparken bir dizi ifadeyi tekrar tekrar değerlendirir.

Yineleme değişkeni her zaman yeni bir değişkendir, kapsayıcı kapsamda aynı isimde bir değişken bulunsa bile. Yineleme için mevcut bir yerel değişkeni yeniden kullanmak için outer kullanın.

Örnekler

julia> için i [1, 4, 0] içinde
           println(i)
       son
1
4
0

while

while döngüleri, bir koşul ifadesini tekrar tekrar değerlendirir ve ifade doğru kaldığı sürece while döngüsünün gövdesini değerlendirmeye devam eder. Eğer koşul ifadesi, while döngüsüne ilk ulaşıldığında yanlışsa, gövde asla değerlendirilmez.

Örnekler

julia> i = 1
1

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

break

Bir döngüden hemen çık.

Örnekler

julia> i = 0
0

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

devam et

Mevcut döngü yinelemesini atla.

Örnekler

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

try/catch

Bir try/catch ifadesi, throw tarafından fırlatılan hataları (istisnaları) yakalamaya olanak tanır, böylece program yürütmesi devam edebilir. Örneğin, aşağıdaki kod bir dosya yazmayı dener, ancak dosya yazılamıyorsa kullanıcıyı uyarır ve yürütmeyi sonlandırmak yerine devam eder:

try
    open("/danger", "w") do f
        println(f, "Hello")
    end
catch
    @warn "Dosya yazılamadı."
end

veya, dosya bir değişkene okunamadığında:

lines = try
    open("/danger", "r") do f
        readlines(f)
    end
catch
    @warn "Dosya bulunamadı."
end

catch e sözdizimi (burada e herhangi bir değişken) fırlatılan istisna nesnesini catch bloğu içindeki verilen değişkene atar.

try/catch yapısının gücü, derin bir şekilde iç içe geçmiş bir hesaplamayı hemen çağıran fonksiyonlar yığınında çok daha yüksek bir seviyeye geri sarabilme yeteneğindedir.

sonunda

Verilen bir kod bloğu çıkarken, çıkış şekli ne olursa olsun bazı kodlar çalıştırın. Örneğin, açılmış bir dosyanın kapatılmasını garanti etmenin yolu şu şekildedir:

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

Kontrol try bloğundan çıktığında (örneğin, bir return nedeniyle veya normal bir şekilde bitirdiğinde), close(f) çalıştırılacaktır. Eğer try bloğu bir istisna nedeniyle çıkarsa, istisna yayılmaya devam edecektir. Bir catch bloğu try ve finally ile birleştirilebilir. Bu durumda finally bloğu, catch hatayı işledikten sonra çalışacaktır.

quote

quote bir blok içinde açıkça Expr yapıcıyı kullanmadan birden fazla ifade nesnesi oluşturur. Örneğin:

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

Diğer alıntı yöntemlerinden farklı olarak, :( ... ), bu form ifade ağacına QuoteNode öğeleri ekler; bu, ağacı doğrudan manipüle ederken dikkate alınmalıdır. Diğer amaçlar için, :( ... ) ve quote .. end blokları aynı şekilde işlenir.

local

local, yeni bir yerel değişken tanımlar. Daha fazla bilgi için değişken kapsamı üzerine kılavuz bölümüne bakın.

Örnekler

julia> function foo(n)
           x = 0
           for i = 1:n
               local x # döngüye özgü bir x tanımla
               x = i
           end
           x
       end
foo (generic function with 1 method)

julia> foo(10)
0

global

global x mevcut kapsamda ve onun iç kapsamlarında x'in o isimdeki küresel değişkene referans vermesini sağlar. Daha fazla bilgi için değişken kapsamı bölümüne bakın.

Örnekler

julia> z = 3
3

julia> function foo()
           global z = 6 # foo dışında tanımlanan z değişkenini kullan
       end
foo (generic function with 1 method)

julia> foo()
6

julia> z
6

for outer

Bir for döngüsünde yineleme için mevcut bir yerel değişkeni yeniden kullanın.

Daha fazla bilgi için değişken kapsamı ile ilgili kılavuz bölümüne bakın.

Ayrıca for bölümüne de bakın.

Örnekler

julia> function f()
           i = 0
           for i = 1:3
               # boş
           end
           return i
       end;

julia> f()
0

julia> function f()
           i = 0
           for outer i = 1:3
               # boş
           end
           return i
       end;

julia> f()
3

julia> i = 0 # global değişken
       for outer i = 1:3
       end
HATA: sözdizimi: "for outer" için dış yerel değişken bildirimi yok
[...]

const

const, değiştirilemeyecek değerleri olan global değişkenleri tanımlamak için kullanılır. Neredeyse tüm kodlarda (özellikle performansa duyarlı kodlarda) global değişkenler bu şekilde sabit olarak tanımlanmalıdır.

const x = 5

Birden fazla değişken tek bir const içinde tanımlanabilir:

const y, z = 7, 11

const yalnızca bir = işlemi için geçerlidir; bu nedenle const x = y = 1 ifadesi x'i sabit olarak tanımlar ama y'yi tanımlamaz. Öte yandan, const x = const y = 1 ifadesi hem x hem de y'yi sabit olarak tanımlar.

"Sabirlik" durumu, değiştirilebilir konteynerlere uzanmaz; yalnızca bir değişken ile değeri arasındaki ilişki sabittir. Eğer x bir dizi veya sözlükse (örneğin) elemanları hala değiştirebilir, ekleyebilir veya kaldırabilirsiniz.

Bazı durumlarda bir const değişkeninin değerini değiştirmek bir hata yerine uyarı verir. Ancak bu, öngörülemeyen davranışlara veya programınızın durumunu bozmasına neden olabilir ve bu nedenle kaçınılmalıdır. Bu özellik yalnızca etkileşimli kullanım sırasında kolaylık sağlamak amacıyla tasarlanmıştır.

struct

Julia'da en yaygın kullanılan tür, bir ad ve bir dizi alan ile belirtilen bir struct'tır.

struct Point
    x
    y
end

Alanların tür kısıtlamaları olabilir ve bu kısıtlamalar parametreli olabilir:

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

Bir struct ayrıca <: sözdizimi ile soyut bir üst türü de ilan edebilir:

struct Point <: AbstractPoint
    x
    y
end

struct'lar varsayılan olarak değiştirilemez; bu türlerden birinin bir örneği inşa edildikten sonra değiştirilemez. Değiştirilebilir örneklere sahip bir tür tanımlamak için mutable struct kullanın.

Yapıcıları nasıl tanımlayacağınız gibi daha fazla ayrıntı için Bileşik Türler bölümüne bakın.

mutable struct

mutable struct, struct ile benzer, ancak ayrıca türün alanlarının inşaattan sonra ayarlanmasına izin verir.

Bir mutable struct'ın bireysel alanları, onları değişmez hale getirmek için const olarak işaretlenebilir:

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

Daha fazla bilgi için Bileşik Türler bölümüne bakın.

@kwdef typedef

Bu, typedef ifadesinde belirtilen tür için otomatik olarak bir anahtar kelime tabanlı yapıcı tanımlayan bir yardımcı makrodur; bu ifade bir struct veya mutable struct ifadesi olmalıdır. Varsayılan argüman, field::T = default veya field = default biçiminde alanlar tanımlanarak sağlanır. Varsayılan bir değer sağlanmazsa, anahtar kelime argümanı, sonuçta oluşan tür yapıcısında zorunlu bir anahtar kelime argümanı haline gelir.

İç yapıcılar hala tanımlanabilir, ancak en az birinin, anahtar kelime dış yapıcı ile doğru çalışabilmesi için varsayılan iç yapıcı ile aynı biçimde (yani her alan için bir konum argümanı) argüman kabul etmesi gerekir.

Örnekler

julia> @kwdef struct Foo
           a::Int = 1         # belirtilen varsayılan
           b::String          # zorunlu anahtar kelime
       end
Foo

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

julia> Foo()
HATA: UndefKeywordError: anahtar kelime argümanı `b` atanmadı
Yığın izi:
[...]

soyut tür

soyut tür bir türü tanımlar ki bu tür örneklendirilemez ve yalnızca tür grafiğinde bir düğüm olarak hizmet eder, böylece ilişkili somut türlerin kümelerini tanımlar: bunlar, onların soyundan gelen somut türlerdir. Soyut türler, Julia'nın tür sistemini yalnızca bir nesne uygulamaları koleksiyonu olmaktan daha fazlası yapan kavramsal hiyerarşiyi oluşturur. Örneğin:

soyut tür Sayı son
soyut tür Gerçek <: Sayı son

Sayı hiçbir süper türe sahip değildir, oysa Gerçek Sayının soyut bir alt türüdür.

ilkel tür

ilkel tür yalnızca bir dizi bitten oluşan veriye sahip somut bir türü tanımlar. İlkel türlerin klasik örnekleri tam sayılar ve kayan nokta değerleridir. İşte bazı örnek yerleşik ilkel tür tanımları:

ilkel tür Char 32 son
ilkel tür Bool <: TamSayı 8 son

İsmin ardından gelen sayı, türün ne kadar depolama alanı gerektirdiğini gösterir. Şu anda yalnızca 8 bitin katları olan boyutlar desteklenmektedir. Bool tanımı, bir ilkel türün isteğe bağlı olarak bazı bir süper türün alt türü olarak nasıl tanımlanabileceğini gösterir.

nerede

where anahtar kelimesi, bazı değişkenlerin tüm değerleri üzerinde diğer türlerin yinelemeli birleşimi olarak düşünülebilecek bir UnionAll türü oluşturur. Örneğin, Vector{T} where T<:Real, eleman türü bir tür Real sayısı olan tüm Vectorları içerir.

Değişken bağı, atlanırsa varsayılan olarak Any olarak ayarlanır:

Vector{T} where T    # `where T<:Any` için kısadır

Değişkenler ayrıca alt sınırları da olabilir:

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

Ayrıca, iç içe where ifadeleri için de kısa bir sözdizimi vardır. Örneğin, bu:

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

şu şekilde kısaltılabilir:

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

Bu form genellikle yöntem imzalarında bulunur.

Bu formda, değişkenler en dıştaki ilk sırada listelenir. Bu, bir türün T{p1, p2, ...} sözdizimi kullanılarak parametre değerlerine "uygulanırken" değişkenlerin yer değiştirme sırasıyla eşleşir.

...

"Splat" operatörü, ..., bir dizi argümanı temsil eder. ..., bir işlev tanımında kullanılabilir; bu, işlevin rastgele sayıda argüman kabul ettiğini belirtir. ..., bir işlevi bir dizi argümana uygulamak için de kullanılabilir.

Örnekler

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

;

; Julia'da birçok C benzeri dilde olduğu gibi, önceki ifadenin sonunu ayırmak için kullanılır.

; bir satırın sonunda gerekli değildir, ancak birden fazla ifadeyi tek bir satırda ayırmak veya ifadeleri tek bir ifade haline getirmek için kullanılabilir.

REPL'de bir satırın sonuna ; eklemek, o ifadenin sonucunun yazdırılmasını engeller.

Fonksiyon bildirimlerinde ve isteğe bağlı olarak çağrılarda, ; normal argümanları anahtar kelimelerden ayırır.

Dizi literallerinde, noktalı virgülle ayrılmış argümanlar içeriklerini birleştirir. Tek bir ; ile yapılan bir ayırıcı dikey olarak birleştirir (yani birinci boyut boyunca), ;; yatay olarak birleştirir (ikinci boyut), ;;; üçüncü boyut boyunca birleştirir, vb. Böyle bir ayırıcı, kare parantezlerin son konumunda da kullanılabilir ve 1 uzunluğunda ek boyutlar ekler.

Parantezler içinde ilk konumda bir ; kullanılarak adlandırılmış bir demet oluşturulabilir. Atama işleminin sol tarafında aynı (; ...) sözdizimi, özellik ayrıştırması için de kullanılır.

Standart REPL'de, boş bir satıra ; yazarak kabuk moduna geçiş yapılır.

Örnekler

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) # ; veya bir son virgül olmadan bu x'e atama yapar
(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; # özellik ayrıştırması kullanarak b ve x değişkenlerini ayarla

julia> b, x
(2, 1)

julia> ; # ; yazıldığında, istem değişir (yerinde) olarak: shell>
shell> echo hello
hello

=

= atama operatörüdür.

• Değişken a ve ifade b için, a = b ifadesi anın bnin değerine referans vermesini sağlar.
• Fonksiyonlar f(x) için, f(x) = x yeni bir fonksiyon sabiti f tanımlar veya f zaten tanımlıysa fye yeni bir yöntem ekler; bu kullanım function f(x); x; end ile eşdeğerdir.
• a[i] = v setindex!(a,v,i) çağrısını yapar.
• a.b = c setproperty!(a,:b,c) çağrısını yapar.
• Bir fonksiyon çağrısı içinde, f(a=b) byi anahtar argüman anın değeri olarak geçirir.
• Virgüllerle birlikte parantez içinde, (a=1,) bir NamedTuple oluşturur.

Örnekler

ayı bye atamak bnin bir kopyasını oluşturmaz; bunun yerine copy veya deepcopy kullanın.

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

Fonksiyonlara geçirilen koleksiyonlar da kopyalanmaz. Fonksiyonlar, argümanlarının referans verdiği nesnelerin içeriğini değiştirebilir (mutate edebilir). (Bunu yapan fonksiyonların isimleri geleneksel olarak '!' ile sonlandırılır.)

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

Atama, bir iterable'dan değer alarak birden fazla değişken üzerinde paralel olarak çalışabilir:

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

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

julia> a, b
(1, 2)

Atama, birden fazla değişken üzerinde ardışık olarak çalışabilir ve sağdaki en sağdaki ifadenin değerini döndürür:

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

Sınır dışı indekslerde atama, bir koleksiyonu büyütmez. Eğer koleksiyon bir Vector ise, bunun yerine push! veya append! ile büyütülebilir.

julia> a = [1, 1]; a[3] = 2
HATA: BoundsError: 2-element Array{Int64, 1} at index [3] erişim denemesi
[...]

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

[] atamak bir koleksiyondan elemanları ortadan kaldırmaz; bunun yerine filter! kullanın.

julia> a = collect(1:3); a[a .<= 1] = []
HATA: DimensionMismatch: 1 hedefe 0 eleman atamaya çalışıldı
[...]

julia> filter!(x -> x > 1, a) # yerinde & dolayısıyla a = a[a .> 1] den daha verimli
2-element Array{Int64, 1}:
 2
 3

a ? b : c

Kısa formda koşullu ifadeler; "eğer a doğruysa, b'yi değerlendir, aksi takdirde c'yi değerlendir" şeklinde okunur. Ayrıca ternary operator olarak da bilinir.

Bu sözdizimi if a; b else c end ile eşdeğerdir, ancak genellikle b veya c değerinin daha büyük bir ifadenin parçası olarak kullanıldığını vurgulamak için kullanılır, b veya c'yi değerlendirmenin yan etkilerinden ziyade.

Daha fazla ayrıntı için kontrol akışı bölümüne bakın.

Örnekler

julia> x = 1; y = 2;

julia> x > y ? println("x daha büyük") : println("x daha büyük değil")
x daha büyük değil

julia> x > y ? "x daha büyük" : x == y ? "x ve y eşit" : "y daha büyük"
"y daha büyük"

Ana

Ana, en üst düzey modüldür ve Julia, Ana'yı mevcut modül olarak ayarlayarak başlar. İstemcide tanımlanan değişkenler Ana'da yer alır ve varinfo, Ana'daki değişkenleri listeler.

julia> @__MODULE__
Ana

Core

Core, dilin "gömülü" olarak kabul edilen tüm tanımlayıcıları içeren modüldür, yani çekirdek dilin bir parçası ve kütüphaneler değildir. Her modül, bu tanımlamalar olmadan hiçbir şey yapamayacağınız için, dolaylı olarak using Core belirtir.

Temel

Julia'nın temel kütüphanesi. Base, temel işlevselliği (base/ içeriği) içeren bir modüldür. Tüm modüller, çoğu durumda gerekli olduğu için, dolaylı olarak using Base içerir.

Base.Broadcast

Yaygınlaştırma uygulamasını içeren modül.

Belgeler

Belgeler modülü, Julia nesneleri için belge meta verilerini ayarlamak ve almak için kullanılabilecek @doc makrosunu sağlar.

Daha fazla bilgi için lütfen belgeleme bölümüne bakın.

Yineleyicilerle çalışmak için yöntemler.

libc'ye, C standart kütüphanesine arayüz.

Metaprogramlama için kullanım kolaylığı sağlayan fonksiyonlar.

Stack izlerini toplamak ve manipüle etmek için araçlar. Temelde hatalar oluşturmak için kullanılır.

Please provide the Markdown content you would like me to translate into Turkish.

Çoklu iş parçacığı desteği.

Base.GC

Çöp toplama yardımcı programları içeren modül.

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

x ve y'nin, hiçbir programın ayırt edemeyeceği anlamında özdeş olup olmadığını belirleyin. Öncelikle x ve y'nin türleri karşılaştırılır. Eğer bunlar özdeşse, değiştirilebilir nesneler bellek adresi ile, değiştirilemez nesneler (örneğin sayılar) ise bit düzeyinde içerik ile karşılaştırılır. Bu işlev bazen "egal" olarak adlandırılır. Her zaman bir Bool değeri döndürür.

Örnekler

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

julia> a == b
true

julia> a === b
false

julia> a === a
true

isa(x, type) -> Bool

x'in verilen type türünde olup olmadığını belirler. Ayrıca infiks operatör olarak da kullanılabilir, örneğin x isa type.

Örnekler

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

== ile benzer, ancak kayan nokta sayıları ve eksik değerlerin işlenmesi açısından farklılık gösterir. isequal, tüm kayan nokta NaN değerlerini birbirine eşit olarak kabul eder, -0.0 değerini 0.0 değerine eşit olmayan olarak değerlendirir ve missing değerini missing ile eşit kabul eder. Her zaman bir Bool değeri döner.

isequal, bir eşitlik ilişkisi olup - reflexif ( === ifadesi isequal'ı ima eder), simetrik (isequal(a, b) ifadesi isequal(b, a)'yı ima eder) ve geçişli (isequal(a, b) ve isequal(b, c) ifadesi isequal(a, c)'yi ima eder).

Uygulama

isequal'ın varsayılan uygulaması == çağrısı yapar, bu nedenle genellikle yalnızca == tanımlaması gereken bir tür, kayan nokta değerleri içermeyen bir türdür.

isequal, hash tabloları (Dict) tarafından kullanılan karşılaştırma fonksiyonudur. isequal(x,y) ifadesi, hash(x) == hash(y) ifadesini ima etmelidir.

Bu genellikle, özel bir == veya isequal yöntemi bulunan türlerin, karşılık gelen bir hash yöntemini uygulaması gerektiği anlamına gelir (ve tersine). Koleksiyonlar genellikle tüm içeriklerde isequal'ı özyinelemeli olarak çağırarak isequal'ı uygular.

Ayrıca, isequal, isless ile bağlantılıdır ve birlikte, tam bir sıralama tanımlamak için çalışırlar; burada isequal(x, y), isless(x, y) veya isless(y, x) ifadelerinden tam olarak biri true olmalıdır (diğer ikisi false).

Skalar türler genellikle == ile ayrı bir isequal uygulamasına ihtiyaç duymaz, yalnızca daha verimli bir uygulama sağlayan kayan nokta sayılarını temsil ediyorlarsa ( isnan, signbit ve =='ya dayalı olarak sağlanan genel bir geri dönüş).

Örnekler

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)

Bir argümanı x ile isequal kullanarak karşılaştıran bir fonksiyon oluşturun, yani y -> isequal(y, x) ile eşdeğer bir fonksiyon.

Dönen fonksiyon Base.Fix2{typeof(isequal)} türündedir ve özel yöntemler uygulamak için kullanılabilir.

isless(x, y)

x'in y'den küçük olup olmadığını, sabit bir toplam sıralama (isequal ile birlikte tanımlanmış) açısından test eder. isless, tüm türlerin (x, y) çiftleri için tanımlı değildir. Ancak, tanımlıysa, aşağıdaki koşulları sağlaması beklenir:

• Eğer isless(x, y) tanımlıysa, o zaman isless(y, x) ve isequal(x, y) de tanımlıdır ve bu üçünden tam olarak biri true döner.
• isless ile tanımlanan ilişki geçişkendir, yani isless(x, y) && isless(y, z) ise isless(x, z)'yi gerektirir.

Normalde sıralanmamış olan değerler, örneğin NaN, normal değerlere göre sıralanır. missing değerleri en sona sıralanır.

Bu, sort! tarafından kullanılan varsayılan karşılaştırmadır.

Uygulama

Toplam sıralaması olan sayısal olmayan türler bu işlevi uygulamalıdır. Sayısal türler yalnızca NaN gibi özel değerlere sahipse bunu uygulamak zorundadır. Kısmi sıralaması olan türler < uygulamalıdır. Sıralama ve ilgili işlevlerde kullanılabilecek alternatif sıralama yöntemlerini tanımlamak için Alternatif Sıralamalar belgesine bakın.

Örnekler

julia> isless(1, 3)
true

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

isunordered(x)

x değeri < ile sıralanabilir değilse, örneğin NaN veya missing ise true döner.

Bu predikat ile true olarak değerlendirilen değerler, isless gibi diğer sıralamalarla sıralanabilir olabilir.

ifelse(condition::Bool, x, y)

condition true ise x döner, aksi takdirde y döner. Bu, ? veya if'ten farklıdır çünkü sıradan bir işlevdir, bu nedenle tüm argümanlar önce değerlendirilir. Bazı durumlarda, if ifadesi yerine ifelse kullanmak, üretilen kodda dalı ortadan kaldırabilir ve sıkı döngülerde daha yüksek performans sağlayabilir.

Örnekler

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

typeassert(x, type)

x isa type değilse bir TypeError fırlatır. x::type sözdizimi bu fonksiyonu çağırır.

Örnekler

julia> typeassert(2.5, Int)
HATA: TypeError: typeassert içinde, beklenen Int64, Float64 türünde bir değer alındı
Stacktrace:
[...]

typeof(x)

x'in somut türünü al.

Ayrıca bkz. eltype.

Örnekler

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

Verilen nesnelerin bir demetini oluşturur.

Ayrıca bkz. Tuple, ntuple, NamedTuple.

Örnekler

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

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

julia> Tuple(Real[1, 2, pi])  # bir koleksiyon alır
(1, 2, π)

ntuple(f, n::Integer)

n uzunluğunda bir demet oluşturur, her bir öğeyi f(i) olarak hesaplar; burada i öğenin indeksidir.

Örnekler

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

ntuple(f, ::Val{N})

N uzunluğunda bir demet oluşturur, her bir elemanı f(i) olarak hesaplar; burada i elemanın indeksidir. Val(N) argümanını alarak, bu ntuple versiyonunun, uzunluğu bir tamsayı olarak alan versiyondan daha verimli kod üretebileceği mümkündür. Ancak ntuple(f, N), N derleme zamanında belirlenemediğinde ntuple(f, Val(N))'den daha tercih edilir.

Örnekler

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

objectid(x) -> UInt

x için nesne kimliğine dayalı bir hash değeri alır.

Eğer x === y ise objectid(x) == objectid(y) olur ve genellikle x !== y olduğunda objectid(x) != objectid(y) olur.

Ayrıca bkz. hash, IdDict.

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

Bir tam sayı hash kodu hesaplayın, böylece isequal(x,y) ifadesi hash(x)==hash(y) anlamına gelir. İsteğe bağlı ikinci argüman h, sonuçla karıştırılacak başka bir hash kodudur.

Yeni türler, genellikle içeriklerin hash'lerini birbirleriyle (ve h ile) karıştırmak için 2-argümanlı hash yöntemini özyinelemeli olarak çağırarak 2-argümanlı biçimi uygulamalıdır. Genellikle, hash uygulayan herhangi bir tür, yukarıda belirtilen özelliği garanti etmek için kendi == (dolayısıyla isequal) yöntemini de uygulamalıdır.

Hash değeri, yeni bir Julia süreci başlatıldığında değişebilir.

julia> a = hash(10)
0x95ea2955abd45275

julia> hash(10, a) # yalnızca başka bir hash fonksiyonunun çıktısını ikinci argüman olarak kullanın
0xd42bad54a8575b16

Ayrıca bkz: objectid, Dict, Set.

finalizer(f, x)

Bir f(x) fonksiyonunu, x için program erişimine kapalı referanslar kalmadığında çağrılacak şekilde kaydedin ve x'i döndürün. x'in tipi mutable struct olmalıdır, aksi takdirde fonksiyon bir hata fırlatır.

f, bir görev değişimi yaratmamalıdır, bu da println gibi çoğu G/Ç işlemini hariç tutar. (finalizer'ın dışındaki bağlam değişimini ertelemek için) @async makrosunu kullanmak veya C'deki G/Ç fonksiyonlarını doğrudan çağırmak için ccall kullanmak, hata ayıklama amaçları için faydalı olabilir.

f'nin yürütülmesi için garanti edilen bir dünya yaşı yoktur. f, finalizer'ın kaydedildiği dünya yaşında veya daha sonraki herhangi bir dünya yaşında çağrılabilir.

Örnekler

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

Bir finalizer, nesne oluşturulurken kaydedilebilir. Aşağıdaki örnekte, finalizer'ın yeni oluşturulan mutable struct x'i döndürmesini dolaylı olarak sağladığımıza dikkat edin.

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

finalize(x)

Hemen nesne x için kaydedilen sonlandırıcıları çalıştırın.

copy(x)

x'in yüzeysel bir kopyasını oluşturur: dış yapı kopyalanır, ancak tüm iç değerler kopyalanmaz. Örneğin, bir diziyi kopyalamak, orijinal ile aynı öğelere sahip yeni bir dizi üretir.

Ayrıca bkz. copy!, copyto!, deepcopy.

deepcopy(x)

x'in derin bir kopyasını oluşturur: her şey özyinelemeli olarak kopyalanır ve tamamen bağımsız bir nesne ortaya çıkar. Örneğin, bir dizinin derin kopyasını almak, içerdiği tüm nesnelerin derin kopyalarını oluşturur ve tutarlı ilişki yapısına sahip yeni bir dizi üretir (örneğin, orijinal dizideki ilk iki eleman aynı nesne ise, yeni dizinin ilk iki elemanı da aynı deepcopy edilmiş nesne olacaktır). Bir nesne üzerinde deepcopy çağırmak, genellikle onu serileştirmek ve ardından serileştirilmiş halini geri almakla aynı etkiye sahip olmalıdır.

Normalde gerekli olmasa da, kullanıcı tanımlı türler, deepcopy_internal(x::T, dict::IdDict) fonksiyonunun özel bir versiyonunu tanımlayarak varsayılan deepcopy davranışını geçersiz kılabilir (bu başka bir yerde kullanılmamalıdır), burada T özelleştirilecek türdür ve dict özyineleme içinde şu ana kadar kopyalanan nesneleri takip eder. Tanım içinde, deepcopy_internal yerine deepcopy kullanılmalı ve dict değişkeni uygun şekilde güncellenmelidir.

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

a.b sözdizimi getproperty(a, :b) çağrısını yapar. @atomic order a.b sözdizimi getproperty(a, :b, :order) çağrısını yapar ve @atomic a.b sözdizimi getproperty(a, :b, :sequentially_consistent) çağrısını yapar.

Örnekler

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

julia> function Base.getproperty(obj::MyType, sym::Symbol)
           if sym === :special
               return obj.x + 1
           else # getfield'e geri dön
               return getfield(obj, sym)
           end
       end

julia> obj = MyType(1);

julia> obj.special
2

julia> obj.x
1

getproperty yalnızca gerekli olduğunda aşırı yüklenmelidir, çünkü obj.f sözdiziminin davranışı alışılmadık olduğunda kafa karıştırıcı olabilir. Ayrıca, yöntemlerin kullanımı genellikle tercih edilir. Daha fazla bilgi için bu stil kılavuzu belgesine bakın: Doğrudan alan erişimi yerine dışa aktarılan yöntemleri tercih edin.

Ayrıca getfield, propertynames ve setproperty! ile ilgili bilgilere de bakın.

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

a.b = c sözdizimi setproperty!(a, :b, c) çağrısını yapar. @atomic order a.b = c sözdizimi setproperty!(a, :b, c, :order) çağrısını yapar ve @atomic a.b = c sözdizimi setproperty!(a, :b, c, :sequentially_consistent) çağrısını yapar.

Ayrıca setfield!, propertynames ve getproperty ile de bakabilirsiniz.

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

x.f üzerinde expected'dan desired'a bir karşılaştırma-değiştirme işlemi gerçekleştirin, egal'e göre. Fonksiyon çağrısı biçimi yerine @atomicreplace x.f expected => desired sözdizimi kullanılabilir.

Ayrıca bkz. replacefield! setproperty!, setpropertyonce!.

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

@atomic a.b, _ = c, a.b sözdizimi (c, swapproperty!(a, :b, c, :sequentially_consistent)) döner; burada her iki taraf için ortak bir getproperty ifadesi olmalıdır.

Ayrıca bkz. swapfield! ve setproperty!.

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

@atomic op(x.f, v) (ve onun eşdeğeri @atomic x.f op v) ifadesi modifyproperty!(x, :f, op, v, :sequentially_consistent) döndürür; burada ilk argüman bir getproperty ifadesi olmalı ve atomik olarak değiştirilir.

op(getproperty(x, f), v) çağrısı, varsayılan olarak x nesnesinin f alanında saklanabilecek bir değer döndürmelidir. Özellikle, setproperty!'in varsayılan davranışının aksine, convert fonksiyonu otomatik olarak çağrılmaz.

Ayrıca modifyfield! ve setproperty!'e de bakın.

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

Daha önce ayarlanmamışsa x.f'yi value olarak ayarlamak için bir karşılaştırma-değiştirme işlemi gerçekleştirin. @atomiconce x.f = value sözdizimi, işlev çağrısı biçimi yerine kullanılabilir.

Ayrıca setfieldonce!, setproperty!, replaceproperty! bakınız.

propertynames(x, private=false)

Bir nesnenin (x.property) özelliklerinin bir demetini veya vektörünü alır. Bu genellikle fieldnames(typeof(x)) ile aynıdır, ancak getproperty ile aşırı yükleme yapan türlerin, türün bir örneğinin özelliklerini almak için genellikle propertynames'i de aşırı yüklemesi gerekir.

propertynames(x) yalnızca x'in belgelenmiş arayüzünün bir parçası olan "genel" özellik adlarını döndürebilir. İç kullanım için tasarlanmış "özel" özellik adlarını da döndürmesini istiyorsanız, isteğe bağlı ikinci argüman için true geçin. REPL sekme tamamlama x. üzerinde yalnızca private=false özelliklerini gösterir.

Ayrıca bakınız: hasproperty, hasfield.

hasproperty(x, s::Symbol)

Nesne x'in s'yi kendi özelliklerinden biri olarak bulup bulmadığını belirten bir boolean döndürür.

Ayrıca bakınız: propertynames, hasfield.

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

Bir bileşen value'dan isim veya pozisyona göre bir alan çıkarın. İsteğe bağlı olarak, işlem için bir sıralama tanımlanabilir. Alan @atomic olarak tanımlandıysa, spesifikasyonın o konumdaki depolamalarla uyumlu olması şiddetle önerilir. Aksi takdirde, @atomic olarak tanımlanmamışsa, bu parametre belirtilirse :not_atomic olmalıdır. Ayrıca getproperty ve fieldnames ile de bakabilirsiniz.

Örnekler

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'i, value'in adlandırılmış bir alanına atayın. value değiştirilebilir olmalı ve x, fieldtype(typeof(value), name)'in bir alt türü olmalıdır. Ayrıca, bu işlem için bir sıralama belirtilebilir. Alan @atomic olarak tanımlandıysa, bu belirtim zorunludur. Aksi takdirde, @atomic olarak tanımlanmamışsa, belirtilirse :not_atomic olmalıdır. Ayrıca bkz. setproperty!.

Örnekler

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);
HATA: setfield!: değiştirilemez yapı türü Rational değiştirilemez

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

Atomik olarak op fonksiyonunu uyguladıktan sonra bir alanı almak ve ayarlamak için işlemleri gerçekleştirin.

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

Eğer donanım tarafından destekleniyorsa (örneğin, atomik artırma), bu uygun donanım talimatına optimize edilebilir, aksi takdirde bir döngü kullanacaktır.

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)

Belirli bir alanı verilen bir değere almak ve koşullu olarak ayarlamak için atomik olarak işlemleri gerçekleştirin.

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

Donanım tarafından destekleniyorsa, bu uygun donanım talimatına optimize edilebilir, aksi takdirde bir döngü kullanacaktır.

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

Atomik olarak bir alanı aynı anda almak ve ayarlamak için işlemleri gerçekleştirin:

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

Bir alanı daha önce ayarlanmamışsa, belirli bir değere ayarlamak için atomik olarak işlemleri gerçekleştirin.

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

Küresel bir değişkenin veya nesne alanının tanımlı olup olmadığını test eder. Argümanlar bir modül ve bir sembol veya bir bileşik nesne ve alan adı (sembol olarak) veya indeks olabilir. İsteğe bağlı olarak, işlem için bir sıralama tanımlanabilir. Alan @atomic olarak tanımlandıysa, spesifikasyonun o konuma yapılan depolamalarla uyumlu olması şiddetle önerilir. Aksi takdirde, @atomic olarak tanımlanmamışsa, belirtilirse bu parametre :not_atomic olmalıdır.

Bir dizi elemanının tanımlı olup olmadığını test etmek için isassigned kullanın.

Ayrıca @isdefined ile de bakabilirsiniz.

Örnekler

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

Değişken s'nin mevcut kapsamda tanımlı olup olmadığını test eder.

Ayrıca isdefined alan özellikleri için ve dizi indeksleri için isassigned veya diğer eşlemeler için haskey bakınız.

Örnekler

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'i T türünde bir değere dönüştür.

Eğer T bir Integer türü ise, x T tarafından temsil edilemeyecekse, örneğin x tam sayı değeri değilse veya T tarafından desteklenen aralığın dışındaysa, bir InexactError hatası oluşacaktır.

Örnekler

julia> convert(Int, 3.0)
3

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

Eğer T bir AbstractFloat türü ise, o zaman T tarafından temsil edilebilen x'e en yakın değeri döndürecektir. Inf, en yakın değeri belirlemek için floatmax(T)'den bir ulp daha büyük olarak kabul edilir.

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125

Eğer T bir koleksiyon türü ve x bir koleksiyon ise, convert(T, x)'in sonucu x'in tamamını veya bir kısmını aliaslayabilir.

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

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

julia> y === x
true

Ayrıca bakınız: round, trunc, oftype, reinterpret.

promote(xs...)

Tüm argümanları ortak bir türe dönüştürün ve hepsini (bir demet olarak) geri döndürün. Hiçbir argüman dönüştürülemezse, bir hata oluşur.

Ayrıca bakınız: promote_type, promote_rule.

Örnekler

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")
HATA: Int64 ve String türlerinin tanıtımı herhangi bir argümanı değiştirmeyi başaramadı
[...]

julia> promote_type(Int, String)
Any

oftype(x, y)

y'yi x'in türüne dönüştürür, yani convert(typeof(x), y).

Örnekler

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0

widen(x)

Eğer x bir tür ise, aritmetik işlemlerin + ve - herhangi bir x türünün tutabileceği değer kombinasyonu için taşma yapmayacağı veya hassasiyet kaybetmeyeceği şekilde tanımlanmış "daha büyük" bir tür döndürür.

128 bitten daha az sabit boyutlu tam sayı türleri için, widen iki katı bit sayısına sahip bir tür döndürecektir.

Eğer x bir değer ise, widen(typeof(x))'e dönüştürülür.

Örnekler

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

Kimlik fonksiyonu. Argümanını döner.

Ayrıca bakınız: one, oneunit, ve LinearAlgebra'nın Isi.

Örnekler

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

WeakRef(x)

w = WeakRef(x) Julia değeri x için bir zayıf referans oluşturur: w, x'e bir referans içeriyor olsa da, x'in çöp toplayıcı tarafından toplanmasını engellemez. w.value ya x'dir (eğer x henüz çöp toplayıcı tarafından toplanmamışsa) ya da nothingdır (eğer x çöp toplayıcı tarafından toplanmışsa).

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

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

julia> GC.gc()

julia> w           # bir referans `x` aracılığıyla korunur
WeakRef("a string")

julia> x = nothing # referansı temizle

julia> GC.gc()

julia> w
WeakRef(nothing)

supertype(T::DataType)

DataType T'nin süpertipini döndürür.

Örnekler

julia> supertype(Int32)
Signed

Core.Type{T}

Core.Type tüm tür nesnelerinin örnekleri olan soyut bir türdür. Tekil tür Core.Type{T}'nin tek örneği T nesnesidir.

Örnekler

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, adlandırılmış türleri, açıkça belirtilmiş üst türleri ve isteğe bağlı olarak parametreleri temsil eder. Sistemdeki her somut değer, bir DataType örneğidir.

Örnekler

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType

<:(T1, T2)

Alt türü operatörü: T1 türündeki tüm değerlerin T2 türünde de olduğu durumunda true döner.

Örnekler

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

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

>:(T1, T2)

Üst tür operatörü, T2 <: T1 ile eşdeğerdir.

typejoin(T, S, ...)

T ve S türlerinin en yakın ortak atasını döndürür, yani her ikisinin de miras aldığı en dar türü. Ek varargs üzerinde yinelemeler yapar.

Örnekler

julia> typejoin(Int, Float64)
Real

julia> typejoin(Int, Float64, ComplexF32)
Number

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

T ve S'nin kesişimini içeren bir tür hesaplayın. Genellikle bu, en küçük böyle bir tür veya ona yakın bir tür olacaktır.

Kesin davranışın garanti edildiği özel bir durum: T <: S olduğunda, typeintersect(S, T) == T == typeintersect(T, S).

promote_type(type1, type2, ...)

Promosyon, karışık türlerin değerlerini tek bir ortak türe dönüştürmeyi ifade eder. promote_type, operatörler (genellikle matematiksel) farklı türlerde argümanlar aldığında Julia'daki varsayılan promosyon davranışını temsil eder. promote_type genellikle, aşırı genişletme olmadan, her iki giriş türünün çoğu değerini en azından yaklaşık olarak temsil edebilecek bir tür döndürmeye çalışır. Bazı kayıplara tolerans gösterilir; örneğin, promote_type(Int64, Float64) Float64 döndürür, oysa ki katı olarak, tüm Int64 değerleri tam olarak Float64 değerleri olarak temsil edilemez.

Ayrıca bakınız: promote, promote_typejoin, promote_rule.

Örnekler

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

!!! uyarı "Bunu doğrudan aşırı yüklemeyin" Kendi türleriniz için promosyonu aşırı yüklemek istiyorsanız, promote_rule aşırı yüklemelisiniz. promote_type, türü belirlemek için dahili olarak promote_rule'ü çağırır. promote_type'ı doğrudan aşırı yüklemek belirsizlik hatalarına neden olabilir.

promote_rule(type1, type2)

type1 ve type2 türlerinin değerleri verildiğinde promote tarafından hangi türün kullanılacağını belirtir. Bu fonksiyon doğrudan çağrılmamalıdır, ancak yeni türler için uygun şekilde tanımlar eklenmelidir.

promote_typejoin(T, S)

T ve S'yi içeren bir tür hesaplayın; bu, her iki türün de bir üst türü veya uygun olduğunda bir Union olabilir. typejoin ile geri döner.

Bunun yerine promote, promote_type bakın.

Örnekler

julia> Base.promote_typejoin(Int, Float64)
Real

julia> Base.promote_type(Int, Float64)
Float64

isdispatchtuple(T)

T türünün bir tuple "leaf type" olup olmadığını belirleyin, yani dispatch'te bir tür imzası olarak görünebilir ve bir çağrıda görünebilecek alt türleri (veya üst türleri) yoktur. Eğer T bir tür değilse, false döndürün.

ismutable(v) -> Bool

Değer v değiştirilebilir ise yalnızca true döner. Değiştirilemezlik hakkında bir tartışma için Mutable Composite Types bölümüne bakın. Bu fonksiyon değerler üzerinde çalıştığı için, eğer bir DataType verirseniz, bu türdeki bir değerin değiştirilebilir olduğunu size söyleyecektir.

Ayrıca isbits, isstructtype bakın.

Örnekler

julia> ismutable(1)
false

julia> ismutable([1,2])
true

```

isimmutable(v) -> Bool

!!! uyarı Bunun yerine !ismutable(v) kullanmayı düşünün, çünkü isimmutable(v) gelecekteki bir sürümde !ismutable(v) ile değiştirilecektir. (Julia 1.5'ten beri)

Değer v eğer değiştirilemezse true döner. Değiştirilemezlik hakkında bir tartışma için Mutable Composite Types bölümüne bakın. Bu fonksiyon değerler üzerinde çalıştığı için, eğer bir tür verirseniz, DataType değerinin değiştirilebilir olduğunu size söyleyecektir.

Örnekler

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

ismutabletype(T) -> Bool

T türünün değiştirilebilir bir tür olarak ilan edilip edilmediğini belirleyin (yani mutable struct anahtar kelimesi kullanılarak). Eğer T bir tür değilse, false döndürün.

isabstracttype(T)

T türünün soyut bir tür olarak ilan edilip edilmediğini belirleyin (yani abstract type sözdizimini kullanarak). Bunun isconcretetype(T)'nin olumsuzlaması olmadığını unutmayın. Eğer T bir tür değilse, false döndürün.

Örnekler

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

isprimitivetype(T) -> Bool

T türünün bir ilkel tür olarak ilan edilip edilmediğini belirleyin (yani primitive type sözdizimini kullanarak). Eğer T bir tür değilse, false döndürün.

Base.issingletontype(T)

T türünün tam olarak bir örneği olup olmadığını belirleyin; örneğin, yalnızca diğer tekil değerler dışında alanı olmayan bir yapı türü. Eğer T somut bir tür değilse, false döndürün.

isstructtype(T) -> Bool

T türünün bir yapı türü olarak (yani struct veya mutable struct anahtar kelimesi kullanılarak) tanımlanıp tanımlanmadığını belirleyin. Eğer T bir tür değilse, false döndürün.

nameof(t::DataType) -> Symbol

Bir (potansiyel olarak UnionAll ile sarılmış) DataType'in adını (ebeveyn modülü olmadan) bir sembol olarak alır.

Örnekler

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

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

fieldnames(x::DataType)

Bir DataType'in alan adlarını içeren bir demet alır.

Ayrıca bkz. propertynames, hasfield.

Örnekler

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

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

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

Bir DataType'in i numaralı alanının adını alır.

Örnekler

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

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

Bir bileşik Veri Tipi T içindeki bir alanın (isim veya indeks ile belirtilen) beyan edilen türünü belirleyin.

Örnekler

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

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

fieldtypes(T::Type)

Bir bileşik DataType T içindeki tüm alanların belirtilen türlerini bir demet olarak döndürür.

Örnekler

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

julia> fieldtypes(Foo)
(Int64, String)

fieldcount(t::Type)

Verilen türün bir örneğinin sahip olacağı alan sayısını alır. Bu türün belirlenmesi için çok soyut olması durumunda bir hata fırlatılır.

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

T'nin name adında kendi alanlarından birine sahip olup olmadığını belirten bir boolean döndürür.

Ayrıca bkz. fieldnames, fieldcount, hasproperty.

Örnekler

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false

nfields(x) -> Int

Verilen nesnedeki alan sayısını alır.

Örnekler

julia> a = 1//2;

julia> nfields(a)
2

julia> b = 1
1

julia> nfields(b)
0

julia> ex = ErrorException("Kötü bir şey yaptım");

julia> nfields(ex)
1

Bu örneklerde, a bir Rational olup iki alana sahiptir. b bir Int olup hiç alanı olmayan bir ilkel bit türüdür. ex bir ErrorException olup bir alana sahiptir.

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

Belirli bir m modülünde bir globalin const olarak tanımlanıp tanımlanmadığını belirleyin.

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

Bir alanın s, verilen bir tür t içinde const olarak tanımlanıp tanımlanmadığını belirleyin.

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

Bir alanın s, verilen bir tür t içinde @atomic olarak tanımlanıp tanımlanmadığını belirleyin.

sizeof(T::DataType)
sizeof(obj)

Verilen DataType T'nin, varsa, kanonik ikili temsilinin boyutu, bayt cinsinden. Veya DataType olmayan obj nesnesinin boyutu, bayt cinsinden.

Ayrıca Base.summarysize bakınız.

Örnekler

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) # padding nedeniyle alanların `sizeof` toplamı değil
16

julia> sizeof(Int64) + sizeof(Bool) # yukarıdakinden farklı
9

Eğer DataType T'nin belirli bir boyutu yoksa, bir hata fırlatılır.

julia> sizeof(AbstractArray)
HATA: Soyut tür AbstractArray'ın kesin bir boyutu yoktur.
Yığın izi:
[...]

isconcretetype(T)

T türünün somut bir tür olup olmadığını belirleyin, yani doğrudan örnekleri (değerler x böyle ki typeof(x) === T) olabilir. isabstracttype(T)'nin olumsuzlaması olmadığını unutmayın. Eğer T bir tür değilse, false döndürün.

Ayrıca bakınız: isbits, isabstracttype, issingletontype.

Örnekler

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)

x bir isbitstype türünün örneği ise true döner.

isbitstype(T)

T türü "sade veri" türü ise true döndürür; bu, değişmez olduğu ve yalnızca primitive türler ve diğer isbitstype türleri içeren başka değerlere referans içermediği anlamına gelir. Tipik örnekler arasında UInt8, Float64 ve Complex{Float64} gibi sayısal türler bulunmaktadır. Bu türler, tür parametreleri olarak geçerli oldukları, isdefined / isassigned durumunu takip etmeyebilecekleri ve C ile uyumlu tanımlı bir düzenleri olduğu için önemlidir. Eğer T bir tür değilse, false döndürün.

Ayrıca bkz. isbits, isprimitivetype, ismutable.

Örnekler

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

fieldoffset(type, i)

Bir türün i alanının veri başlangıcına göre bayt ofseti. Örneğin, bir yapı hakkında bilgi özetlemek için aşağıdaki şekilde kullanabiliriz:

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

Bu türün örnekleri için bellek tahsisatının minimum hizalamasını döndürür. Herhangi bir isconcretetype üzerinde çağrılabilir, ancak Bellek için, tüm nesnenin değil, elemanların hizalamasını verecektir.

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

Bu türün örneklerinin alanlarının bellekte, arada hiçbir dolgu biti olmadan paketlenip paketlenmediğini döndürür (dolgu bitleri, yapı alanlarına uygulandığında eşitlik testini benzersiz bir şekilde etkilemeyen bitler olarak tanımlanır). Herhangi bir isconcretetype üzerinde çağrılabilir.

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

Bu türün örneklerinin gc tarafından yönetilen belleğe referanslar içerebilir mi olduğunu döndürür. Herhangi bir isconcretetype üzerinde çağrılabilir.

typemin(T)

Verilen (gerçek) sayısal Veri Tipi T için temsil edilebilen en düşük değerdir.

Ayrıca bakınız: floatmin, typemax, eps.

Örnekler

julia> typemin(Int8)
-128

julia> typemin(UInt32)
0x00000000

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

julia> nextfloat(-Inf32)  # en küçük sonlu Float32 kayan nokta sayısı
-3.4028235f38

typemax(T)

Verilen (gerçek) sayısal DataType için temsil edilebilen en yüksek değeri döndürür.

Ayrıca bakınız: floatmax, typemin, eps.

Örnekler

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> typemax(Float32)
Inf32

julia> floatmax(Float32)  # en büyük sonlu Float32 kayan nokta sayısı
3.4028235f38

floatmin(T = Float64)

T türü tarafından temsil edilebilen en küçük pozitif normal sayıyı döndürür.

Örnekler

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

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308

floatmax(T = Float64)

T türü için temsil edilebilen en büyük sonlu sayıyı döndürür.

Ayrıca bakınız: typemax, floatmin, eps.

Örnekler

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

julia> typemax(Float64)
Inf

maxintfloat(T=Float64)

Verilen T kayan nokta türünde tam olarak temsil edilen en büyük ardışık tam sayı değerine sahip kayan nokta sayısıdır (varsayılan olarak Float64).

Yani, maxintfloat, n+1'in T türünde tam olarak temsil edilemediği en küçük pozitif tam sayı değerine sahip kayan nokta sayısı n'yi döndürür.

Bir Integer türü değeri gerektiğinde, Integer(maxintfloat(T)) kullanın.

maxintfloat(T, S)

Verilen kayan nokta türü T içinde temsil edilebilen en büyük ardışık tam sayı ve aynı zamanda tam sayı türü S tarafından temsil edilebilen en büyük tam sayıyı aşmayan bir değerdir. Eşdeğer olarak, bu maxintfloat(T) ve typemax(S) değerinin minimumudur.

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

T türünün makine epsilon değerini döndürür (T = Float64 varsayılan olarak). Bu, 1 ile typeof(one(T)) tarafından temsil edilebilen bir sonraki en büyük değer arasındaki boşluk olarak tanımlanır ve eps(one(T)) ile eşdeğerdir. (eps(T), T'nin göreceli hata sınırı olduğundan, one gibi "boyutsuz" bir miktardır.)

Örnekler

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)

x'in sondaki birim (ulp) değerini döndürür. Bu, x'deki ardışık temsil edilebilir kayan nokta değerleri arasındaki mesafedir. Çoğu durumda, x'in her iki tarafındaki mesafe farklıysa, daha büyük olanı alınır, yani

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

Bu kuralın istisnaları, en küçük ve en büyük sonlu değerlerdir (örneğin, Float64 için nextfloat(-Inf) ve prevfloat(Inf)), bu değerler daha küçük olanı yuvarlar.

Bu davranışın nedeni, eps'in kayan nokta yuvarlama hatasını sınırlamasıdır. Varsayılan RoundNearest yuvarlama modunda, $y$ bir reel sayı ve $x$ $y$'ye en yakın kayan nokta sayısı ise, o zaman

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

Ayrıca bakınız: nextfloat, issubnormal, floatmax.

Örnekler

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)      # en büyük sonlu Float64
1.7976931348623157e308

julia> x + eps(x)/2            # yukarı yuvarlar
Inf

julia> x + prevfloat(eps(x)/2) # aşağı yuvarlar
1.7976931348623157e308

instances(T::Type)

Verilen türün tüm örneklerinin bir koleksiyonunu döndürür, eğer uygunsa. Genellikle sıralı türler için kullanılır (bkz. @enum).

Örnekler

julia> @enum Color red blue green

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

Any::DataType

Any, tüm türlerin birleşimidir. Herhangi bir x için isa(x, Any) == true tanımlayıcı özelliğine sahiptir. Bu nedenle Any, olası değerlerin tüm evrenini tanımlar. Örneğin, Integer, Int, Int8 ve diğer tam sayı türlerini içeren Any'nin bir alt kümesidir.

Union{Types...}

Bir Union türü, argüman türlerinin herhangi birinin tüm örneklerini içeren soyut bir türdür. Bu, T <: Union{T,S} ve S <: Union{T,S} anlamına gelir.

Diğer soyut türler gibi, tüm argümanları soyut olmasa bile, örneklendirilemez.

Örnekler

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

julia> 1 isa IntOrString # Int örneği birliğe dahil
true

julia> "Hello!" isa IntOrString # String de dahil
true

julia> 1.0 isa IntOrString # Float64 dahil değildir çünkü ne Int ne de AbstractString'dir
false

Genişletilmiş Yardım

Çoğu diğer parametrik türün aksine, birleşimler parametrelerinde kovaryandır. Örneğin, Union{Real, String} bir alt türdur Union{Number, AbstractString}.

Boş birleşim Union{} Julia'nın en alt türüdür.

Union{}

Union{}, boş Union türlerin, değer içermeyen türdür. Yani, isa(x, Union{}) == false tanımlayıcı özelliğine sahiptir her x için. Base.Bottom, onun takma adı olarak tanımlanmıştır ve Union{} türünün Core.TypeofBottom olduğu belirtilmiştir.

Örnekler

julia> isa(nothing, Union{})
false

UnionAll

Bir tür parametresi üzerindeki tüm değerlerin birleşimi. UnionAll, bazı parametrelerin değerlerinin bilinmediği parametrik türleri tanımlamak için kullanılır. UnionAll Türleri bölümüne bakın.

Örnekler

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Tuple{Types...}

Bir tuple, farklı türlerdeki herhangi bir değeri tutabilen sabit uzunlukta bir konteynerdir, ancak değiştirilemez (değişmez). Değerlere indeksleme ile erişilebilir. Tuple literalleri virgüller ve parantezler ile yazılır:

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}

Uzunluğu 1 olan bir tuple, bir virgül ile yazılmalıdır, (1,), çünkü (1) sadece parantez içine alınmış bir değerdir. () boş (uzunluğu 0) tuple'ı temsil eder.

Bir tuple, bir Tuple türü kullanılarak bir iterator'dan oluşturulabilir:

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

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

Tuple türleri, parametrelerinde kovaryandır: Tuple{Int} bir Tuple{Any} alt türüdür. Bu nedenle Tuple{Any} soyut bir tür olarak kabul edilir ve tuple türleri yalnızca parametreleri somut olduğunda somut hale gelir. Tuple'lar alan adlarına sahip değildir; alanlara yalnızca indeks ile erişilir. Tuple türleri herhangi bir sayıda parametreye sahip olabilir.

Tuple Types bölümüne bakın.

Ayrıca Vararg, NTuple, ntuple, tuple, NamedTuple ile ilgili daha fazla bilgiye bakın.

NTuple{N, T}

N uzunluğunda ve tüm elemanları T tipinde olan bir demetin tipini temsil etmenin kompakt bir yolu.

Örnekler

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

Ayrıca bkz. ntuple.

NamedTuple

NamedTuplelar, adından da anlaşılacağı gibi, adlandırılmış Tuplelar. Yani, her bir girişin benzersiz bir adı olduğu, değerlerin tuple benzeri bir koleksiyonu; bu adlar Symbol olarak temsil edilir. Tuplelar gibi, NamedTuplelar da değiştirilemez; inşa edildikten sonra ne adlar ne de değerler yerinde değiştirilemez.

Adlandırılmış bir tuple, anahtarlarla bir tuple literal olarak oluşturulabilir, örneğin (a=1, b=2), veya açılış parantezinden sonra noktalı virgül ile bir tuple literal olarak, örneğin (; a=1, b=2) (bu form ayrıca aşağıda açıklanan programatik olarak üretilen adları da kabul eder), veya bir NamedTuple türü kullanılarak bir yapıcı olarak, örneğin NamedTuple{(:a, :b)}((1,2)).

Adlandırılmış bir tuple'daki bir adla ilişkili değere erişim, alan erişim sözdizimi kullanılarak yapılabilir, örneğin x.a, veya getindex kullanılarak, örneğin x[:a] veya x[(:a, :b)]. Adların bir tuple'ı keys kullanılarak elde edilebilir ve değerlerin bir tuple'ı values kullanılarak elde edilebilir.

@NamedTuple makrosu, NamedTuple türlerini rahatça tanımlamak için kullanılabilir.

Örnekler

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

Anahtar argümanları programatik olarak tanımlama şekline benzer bir şekilde, bir adlandırılmış tuple, bir tuple literal içinde noktalı virgülden sonra name::Symbol => value çiftleri vererek oluşturulabilir. Bu ve name=value sözdizimi karıştırılabilir:

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

Ad-değer çiftleri, bir adlandırılmış tuple'ı veya her biri bir sembolü ilk değer olarak tutan iki değerli koleksiyonlar üreten herhangi bir yineleyiciyi açarak da sağlanabilir:

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) # son b, nt1'den gelen değeri geçersiz kılar
(a = 1, b = 20, c = 3, d = 4)

julia> (; zip(keys, values)...) # zip, (:a, 1) gibi tuple'lar üretir
(a = 1, b = 2, c = 3)

Anahtar argümanlarda olduğu gibi, tanımlayıcılar ve nokta ifadeleri adları ima eder:

julia> x = 0
0

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

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

@NamedTuple{anahtar1::Tip1, anahtar2::Tip2, ...}
@NamedTuple begin anahtar1::Tip1; anahtar2::Tip2; ...; end

Bu makro, NamedTuple türlerini tanımlamak için daha kullanışlı bir sözdizimi sağlar. Verilen anahtarlar ve türlerle bir NamedTuple türü döndürür; bu, NamedTuple{(:anahtar1, :anahtar2, ...), Tuple{Tip1,Tip2,...}} ile eşdeğerdir. ::Tip bildirimi atlandığında, bu Any olarak alınır. begin ... end biçimi, bildirimlerin birden fazla satıra bölünmesine izin verir (bir struct bildirimine benzer), ancak aksi takdirde eşdeğerdir. NamedTuple makrosu, NamedTuple türlerini örneğin REPL'de yazdırırken kullanılır.

Örneğin, (a=3.1, b="merhaba") demeti NamedTuple{(:a, :b), Tuple{Float64, String}} türüne sahiptir; bu da @NamedTuple ile şu şekilde tanımlanabilir:

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, ...}

Bu makro, @NamedTuple ile aynı sözdiziminden anahtar argümanların tür temsilini oluşturmanın pratik bir yolunu sağlar. Örneğin, func([positional arguments]; kw1=1.0, kw2="2") gibi bir fonksiyon çağrımız olduğunda, bu makroyu kullanarak anahtar argümanların iç tür temsilini @Kwargs{kw1::Float64, kw2::String} olarak oluşturabiliriz. Makro sözdizimi, bir anahtar yönteminin imza türünü yığın izleme görünümünde basıldığında basitleştirmek için özel olarak tasarlanmıştır.

julia> @Kwargs{init::Int} # anahtar argümanların iç temsil
Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}

julia> sum("julia"; init=1)
HATA: MethodError: +(::Char, ::Char) için eşleşen bir yöntem yok
`+` fonksiyonu mevcut, ancak bu argüman türleri kombinasyonu için tanımlı bir yöntem yok.

En yakın adaylar:
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:585
  +(::Integer, ::AbstractChar)
   @ Base char.jl:247
  +(::T, ::Integer) where T<:AbstractChar
   @ Base char.jl:237

Yığın izi:
  [1] add_sum(x::Char, y::Char)
    @ Base ./reduce.jl:24
  [2] BottomRF
    @ Base ./reduce.jl:86 [iç içe]
  [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 [iç içe]
  [5] mapfoldl_impl(f::typeof(identity), op::typeof(Base.add_sum), nt::Int64, itr::String)
    @ Base ./reduce.jl:44 [iç içe]
  [6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64)
    @ Base ./reduce.jl:175 [iç içe]
  [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:307 [iç içe]
  [8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:535 [iç içe]
  [9] sum(a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:564 [iç içe]
 [10] üst düzey kapsam
    @ REPL[12]:1

Val(c)

Val{c}() döngü zamanı verisi içermez. Bu türler, c değerini kullanarak fonksiyonlar arasında bilgi geçişi yapmak için kullanılabilir; c bir isbits değeri veya bir Symbol olmalıdır. Bu yapının amacı, sabitler üzerinde doğrudan (derleme zamanında) dağıtım yapabilmektir; sabitin değerini döngü zamanında test etme gerekliliğini ortadan kaldırmaktır.

Örnekler

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

julia> f(::Val{false}) = "Kötü"
f (generic function with 2 methods)

julia> f(Val(true))
"İyi"

Vararg{T,N}

Bir tuple türünün son parametresi Tuple özel değeri Vararg olabilir; bu, herhangi bir sayıda son elemanı belirtir. Vararg{T,N} tam olarak N adet T türünde elemanı ifade eder. Son olarak, Vararg{T} sıfır veya daha fazla T türünde elemanı ifade eder. Vararg tuple türleri, varargs yöntemleri tarafından kabul edilen argümanları temsil etmek için kullanılır (kılavuzdaki Varargs Fonksiyonları bölümüne bakın.)

Ayrıca NTuple ile ilgili bilgiye bakın.

Örnekler

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

Hiçbir şey

Alanı olmayan ve nothing türü olan bir tür.

Ayrıca bakınız: isnothing, Some, Missing.

isnothing(x)

x === nothing ise true döner, aksi takdirde false döner.

Ayrıca bkz. something, Base.notnothing, ismissing.

notnothing(x)

Eğer x === nothing ise bir hata fırlatır ve değilse x'i döner.

Some{T}

Union{Some{T}, Nothing} içinde bir değer yokluğunu (nothing) ve bir nothing değerinin varlığını (yani Some(nothing)) ayırt etmek için kullanılan bir sarmalayıcı tür.

Bir Some nesnesi tarafından sarılmış değere erişmek için something kullanın.

bir şey(x...)

Argümanlar arasında nothing ile eşit olmayan ilk değeri döndürün, eğer varsa. Aksi takdirde bir hata fırlatın. Some türündeki argümanlar açılır.

Ayrıca bkz. coalesce, skipmissing, @something.

Örnekler

julia> bir şey(nothing, 1)
1

julia> bir şey(Some(1), nothing)
1

julia> bir şey(Some(nothing), 2) === nothing
true

julia> bir şey(missing, nothing)
missing

julia> bir şey(nothing, nothing)
HATA: ArgumentError: Değer argümanı yok

@something(x...)

something makrosunun kısa devre versiyonu.

Örnekler

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

julia> a = 1;

julia> a = @something a f(2) f(3) error("`a` için varsayılan bulunamadı")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("`b` için varsayılan bulunamadı")
f(2)
f(3)
HATA: `b` için varsayılan bulunamadı
[...]

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

julia> b === nothing
true

Enum{T<:Integer}

@enum ile tanımlanan tüm sıralı türlerin soyut üst türüdür.

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

EnumName adında bir Enum{BaseType} alt türü oluşturur ve value1 ve value2 enum üye değerleri ile isteğe bağlı olarak atanmış x ve y değerlerini içerir. EnumName, diğer türler gibi kullanılabilir ve enum üye değerleri, aşağıdaki gibi normal değerler olarak kullanılabilir.

Örnekler

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

julia> f(x::Fruit) = "Ben bir değerim: $(Int(x)) olan bir Meyve'yim"
f (generic function with 1 method)

julia> f(apple)
"Ben bir değerim: 1 olan bir Meyve'yim"

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

Değerler ayrıca bir begin bloğu içinde de belirtilebilir, örneğin:

@enum EnumName begin
    value1
    value2
end

Varsayılan olarak Int32 olan BaseType, Integer'ın bir ilkel alt türü olmalıdır. Üye değerleri, enum türü ile BaseType arasında dönüştürülebilir. read ve write bu dönüşümleri otomatik olarak gerçekleştirir. Enum, varsayılan olmayan bir BaseType ile oluşturulursa, Integer(value1) value1 tam sayısını BaseType türü ile döndürecektir.

Bir enum'un tüm örneklerini listelemek için instances kullanın, örneğin:

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

Bir enum örneğinden bir sembol oluşturmak mümkündür:

julia> Symbol(apple)
:apple

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

Parçalanmış julia kodundaki (AST'ler) bileşik ifadeleri temsil eden bir tür. Her ifade, hangi tür ifade olduğunu belirten bir head Symbol'ü (örneğin bir çağrı, for döngüsü, koşullu ifade vb.) ve alt ifadeleri (örneğin bir çağrının argümanları) içerir. Alt ifadeler, args adında bir Vector{Any} alanında saklanır.

Metaprogramming konusundaki kılavuz bölümüne ve geliştirici belgelerine Julia ASTs bakın.

Örnekler

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

Sembol

Parselanmış julia kodundaki (AST'ler) tanımlayıcıları temsil etmek için kullanılan nesne türü. Ayrıca genellikle bir varlığı tanımlamak için bir ad veya etiket olarak kullanılır (örneğin, bir sözlük anahtarı olarak). Symbollar : alıntı operatörü kullanılarak girilebilir:

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

Symbollar ayrıca Symbol(x...) yapıcıyı çağırarak dizelerden veya diğer değerlerden oluşturulabilir.

Symbollar değişmezdir ve uygulamaları, aynı ada sahip tüm Symbollar için aynı nesneyi yeniden kullanır.

Dizelerin aksine, Symbollar "atomik" veya "skalar" varlıklar olup karakterler üzerinde yineleme desteklemez.

Symbol(x...) -> Symbol

Argümanların string temsillerini birleştirerek bir Symbol oluşturur.

Örnekler

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

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

Modül

Bir Modül, ayrı bir global değişken çalışma alanıdır. Ayrıntılar için modül ve modüller hakkında kılavuz bölümü bakınız.

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

Belirtilen isimle bir modül döndürür. Bir baremodule, Module(:ModuleName, false) ile karşılık gelir.

Hiçbir isim içermeyen boş bir modül, Module(:ModuleName, false, false) ile oluşturulabilir. Bu modül Base veya Core'u içermeyecek ve kendisine bir referans içermeyecektir.

Fonksiyon

Tüm fonksiyonların soyut türü.

Örnekler

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin) (sin fonksiyonunun tekil türü, Function alt türü)

julia> ans <: Function
true

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

Verilen genel işlevin, world tarafından verilen üst sınırda bir dünya yaşı ile eşleşen verilen Tuple argüman türlerine sahip bir yöntemi olup olmadığını belirleyin.

Eğer bir anahtar argüman adı kwnames tuple'ı sağlanmışsa, bu aynı zamanda f'nin t ile eşleşen yönteminin verilen anahtar argüman adlarına sahip olup olmadığını da kontrol eder. Eğer eşleşen yöntem değişken sayıda anahtar argüman kabul ediyorsa, örneğin kwargs... ile, kwnames içinde verilen herhangi bir ad geçerli kabul edilir. Aksi takdirde, sağlanan adlar yöntemin anahtar argümanlarının bir alt kümesi olmalıdır.

Ayrıca bkz. applicable.

Örnekler

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 rastgele kwargs kabul eder
true

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

Verilen genel işlevin, verilen argümanlara uygulanabilir bir yöntemi olup olmadığını belirleyin.

Ayrıca bkz. hasmethod.

Örnekler

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

İki yöntem m1 ve m2'nin bazı çağrı imzaları için belirsiz olup olmadığını belirleyin. Bu test, aynı işlevin diğer yöntemleri bağlamında gerçekleştirilir; izole olarak, m1 ve m2 belirsiz olabilir, ancak belirsizliği çözen üçüncü bir yöntem tanımlanmışsa, bu false döner. Alternatif olarak, izole olarak m1 ve m2 sıralanabilir, ancak üçüncü bir yöntem bunlarla sıralanamazsa, birlikte bir belirsizlik yaratabilirler.

Parametrik türler için, ambiguous_bottom anahtar kelime argümanı Union{}'nin tür parametrelerinin belirsiz bir kesişimi olarak sayılıp sayılmayacağını kontrol eder - true olduğunda belirsiz olarak kabul edilir, false olduğunda edilmez.

Örnekler

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

Verilen genel işlev f için belirtilen türler argtypes ile belirtilen argümanlar args üzerinde eşleşen bir yöntemi çağırın ve anahtar kelime argümanları kwargs geçirin. args argümanları, argtypes içinde belirtilen türlerle uyumlu olmalıdır, yani dönüşüm otomatik olarak gerçekleştirilmez. Bu yöntem, en spesifik eşleşen yöntem dışında bir yöntemi çağırmaya olanak tanır; bu, daha genel bir tanımın davranışının açıkça gerektiği durumlarda yararlıdır (genellikle aynı işlevin daha spesifik bir yönteminin uygulanmasının bir parçası olarak).

Yazmadığınız işlevler için invoke kullanırken dikkatli olun. Verilen argtypes için hangi tanımın kullanıldığı, işlevin belirli argtypes ile çağrılmasının kamu API'sinin bir parçası olduğunu açıkça belirtmediği sürece bir uygulama ayrıntısıdır. Örneğin, aşağıdaki örnekte f1 ve f2 arasındaki değişiklik genellikle uyumlu olarak kabul edilir çünkü değişiklik, normal (non-invoke) çağrıda çağıran tarafından görünmez. Ancak, invoke kullanırsanız değişiklik görünür hale gelir.

Örnekler

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 çağrısını yapmak için pratik bir yol sağlar ve @invoke f(arg1::T1, arg2::T2; kwargs...) ifadesini invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...) şeklinde genişletir. Bir argümanın türü belirtilmediğinde, bu argümanın Core.Typeof ile değiştirilir. Bir argümanın türü belirtilmemiş veya açıkça Any olarak tanımlanmış bir yöntemi çağırmak için, argümanı ::Any ile anotlayın.

Aşağıdaki sözdizimini de destekler:

• @invoke (x::X).f ifadesi invoke(getproperty, Tuple{X,Symbol}, x, :f) şeklinde genişletilir.
• @invoke (x::X).f = v::V ifadesi invoke(setproperty!, Tuple{X,Symbol,V}, x, :f, v) şeklinde genişletilir.
• @invoke (xs::Xs)[i::I] ifadesi invoke(getindex, Tuple{Xs,I}, xs, i) şeklinde genişletilir.
• @invoke (xs::Xs)[i::I] = v::V ifadesi invoke(setindex!, Tuple{Xs,V,I}, xs, v, i) şeklinde genişletilir.

Örnekler

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...) çağrısını yapar, ancak f'nin en son yönteminin çalıştırılmasını garanti eder. Bu, uzun süreli olay döngüleri veya eski sürümlerini çağırabilecek geri çağırma işlevleri gibi özel durumlarda yararlıdır. (Dezavantajı, invokelatest'in f'yi doğrudan çağırmaktan biraz daha yavaş olması ve sonucun türünün derleyici tarafından çıkarılamamasıdır.)

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

invokelatest çağırmak için kullanışlı bir yol sağlar. @invokelatest f(args...; kwargs...) basitçe Base.invokelatest(f, args...; kwargs...) olarak genişletilecektir.

Aşağıdaki sözdizimini de destekler:

• @invokelatest x.f Base.invokelatest(getproperty, x, :f) olarak genişletilir
• @invokelatest x.f = v Base.invokelatest(setproperty!, x, :f, v) olarak genişletilir
• @invokelatest xs[i] Base.invokelatest(getindex, xs, i) olarak genişletilir
• @invokelatest xs[i] = v Base.invokelatest(setindex!, xs, v, i) olarak genişletilir

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, or new{A,B,...}

İç yapıcılar için mevcut olan özel bir işlev, türün yeni bir nesnesini oluşturur. new{A,B,...} biçimi, parametreli türler için parametrelerin değerlerini açıkça belirtir. Daha fazla bilgi için İç Yapıcı Yöntemler bölümüne bakın.

|>(x, f)

Fonksiyonu f argüman x'e uygulayan infiks operatör. Bu, f(g(x)) ifadesinin x |> g |> f şeklinde yazılmasına olanak tanır. Anonim fonksiyonlarla kullanıldığında, istenen zinciri elde etmek için tanımın etrafında parantezlerin genellikle gerekli olduğu durumlar vardır.

Örnekler

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

Fonksiyonları birleştirin: yani (f ∘ g)(args...; kwargs...) demek f(g(args...; kwargs...)) anlamına gelir. ∘ sembolü Julia REPL'inde (ve uygun şekilde yapılandırılmış çoğu editörde) \circ<tab> yazarak girilebilir.

Fonksiyon birleştirmesi ön ek biçiminde de çalışır: ∘(f, g) f ∘ g ile aynıdır. Ön ek biçimi birden fazla fonksiyonun birleştirilmesini destekler: ∘(f, g, h) = f ∘ g ∘ h ve bir iterable fonksiyon koleksiyonunu birleştirmek için ∘(fs...). ∘'ye verilen son argüman ilk önce çalıştırılır.

Örnekler

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

Ayrıca ComposedFunction, !f::Function bakın.

ComposedFunction{Outer,Inner} <: Function

İki çağrılabilir nesnenin outer::Outer ve inner::Inner bileşimini temsil eder. Yani

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

Bir ComposedFunction örneği oluşturmanın tercih edilen yolu bileşim operatörünü ∘ kullanmaktır:

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

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

Bileşen parçaları ComposedFunction'ın alanlarında saklanır ve aşağıdaki gibi alınabilir:

julia> composition = sin ∘ cos
sin ∘ cos

julia> composition.outer === sin
true

julia> composition.inner === cos
true

Ayrıca bkz. ∘.

splat(f)

Eşdeğer

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

yani, bir fonksiyon verildiğinde, orijinal fonksiyona bir argüman alıp onu yayarak yeni bir fonksiyon döndürür. Bu, çok argümanlı bir fonksiyonu tek bir argüman bekleyen bir bağlamda geçirebilmek için bir adaptör olarak kullanışlıdır, ancak o tek argüman olarak bir demet geçirir.

Örnekler

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)

İlk argümanı "x" değerine sabitlenmiş iki argümanlı f fonksiyonunun kısmen uygulanmış bir versiyonunu temsil eden bir tür. Diğer bir deyişle, Fix1(f, x) y->f(x, y) ile benzer şekilde davranır.

Ayrıca bkz. Fix2.

Fix2(f, x)

İkinci argümanı "x" değerine sabitlenmiş iki argümanlı f fonksiyonunun kısmen uygulanmış bir versiyonunu temsil eden bir tür. Diğer bir deyişle, Fix2(f, x) y->f(y, x) ile benzer şekilde davranır.

Core.eval(m::Module, expr)

Verilen modülde bir ifadeyi değerlendirir ve sonucu döndürür.

eval(expr)

Bir ifadenin içindeki modülün global kapsamındaki değerini hesaplar. baremodule ile tanımlanmayan her Module, o modülde ifadeleri değerlendiren kendi 1-argümanlı eval tanımına sahiptir.

@eval [mod,] ex

Bir ifadeyi içine değerler yerleştirilmiş olarak eval kullanarak değerlendirin. İki argüman sağlanırsa, ilki değerlendirilecek modüldür.

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

Dosyayı anonim bir modüle yükleyin, tüm ifadeleri değerlendirin ve son ifadenin değerini döndürün. İsteğe bağlı args argümanı, betiğin giriş argümanlarını ayarlamak için kullanılabilir (yani, küresel ARGS değişkeni). Tanımların (örneğin, yöntemler, küreseller) anonim modülde değerlendirildiğini ve mevcut modülü etkilemediğini unutmayın.

Örnekler

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)

Sadece bir makrodan dönen bir Expr bağlamında geçerlidir. Makro hijyen geçişinin gömülü değişkenleri gensym değişkenlerine dönüştürmesini engeller. Daha fazla ayrıntı ve örnekler için kılavuzun Metaprogramlama bölümündeki Makrolar kısmına bakın.

@inbounds(blk)

Dizi sınır kontrolünü ifadeler içinde ortadan kaldırır.

Aşağıdaki örnekte, dizi A'nın i elemanına referans verirken aralık kontrolü atlanır ve bu da performansı artırır.

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

!!! uyarı @inbounds kullanmak, sınır dışı indeksler için yanlış sonuçlar/çökmeler/bozulmalar döndürebilir. Kullanıcı, bunu manuel olarak kontrol etmekten sorumludur. @inbounds yalnızca, yerel olarak mevcut bilgilerden tüm erişimlerin sınır içinde olduğundan emin olunduğunda kullanılmalıdır. Özellikle, yukarıdaki gibi bir işlevde eachindex(A) yerine 1:length(A) kullanmak güvenli bir şekilde sınır içinde değildir çünkü A'nın ilk indeksi, AbstractArray'ı alt tür olarak tanımlayan tüm kullanıcı tanımlı türler için 1 olmayabilir.

@boundscheck(blk)

İfadenin blk olarak sınır kontrol bloğu olarak işaretlenmesini sağlar, böylece @inbounds tarafından göz ardı edilmesine izin verir.

Örnekler

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()
HATA: BoundsError: 2 elemanlı UnitRange{Int64} dizisinde [-1] indeksine erişim denemesi
Stacktrace:
 [1] throw_boundserror(::UnitRange{Int64}, ::Tuple{Int64}) at ./abstractarray.jl:455
 [2] checkbounds at ./abstractarray.jl:420 [inline]
 [3] g at ./none:2 [inline]
 [4] f1() at ./none:1
 [5] üst düzey kapsam

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

!!! uyarı @boundscheck notasyonu, bir kütüphane yazarı olarak, diğer kodların sınır kontrollerinizi @inbounds ile kaldırmasına izin vermek için opt-in yapmanızı sağlar. Orada belirtildiği gibi, çağıran, @inbounds kullanmadan önce erişimlerinin geçerli olduğunu doğrulamak için erişebilecekleri bilgileri kullanmalıdır. Örneğin, AbstractArray alt sınıflarınıza indeksleme yaparken, indeksleri axes ile karşılaştırarak kontrol etmek gerekir. Bu nedenle, @boundscheck notasyonları, davranışının doğru olduğundan emin olduktan sonra yalnızca bir getindex veya setindex! uygulamasına eklenmelidir.

@propagate_inbounds

Derleyiciye bir işlevi, çağıranın inbounds bağlamını koruyarak iç içe almasını söyler.

@inline

Derleyiciye bu fonksiyonun inline edilmesinin değerli olduğunu belirtir.

Küçük fonksiyonlar genellikle @inline anotasyonuna ihtiyaç duymaz, çünkü derleyici bunu otomatik olarak yapar. Daha büyük fonksiyonlarda @inline kullanarak, derleyiciye inline etmesi için ekstra bir teşvik verilebilir.

@inline, bir fonksiyon tanımının hemen öncesinde veya bir fonksiyon gövdesi içinde uygulanabilir.

# uzun tanımı anotasyonla
@inline function longdef(x)
    ...
end

# kısa tanımı anotasyonla
@inline shortdef(x) = ...

# bir `do` bloğu oluşturan anonim fonksiyonu anotasyonla
f() do
    @inline
    ...
end

@inline block

Derleyiciye block içindeki çağrıların inline edilmesinin değerli olduğunu belirtir.

# Derleyici `f`'yi inline etmeye çalışacak
@inline f(...)

# Derleyici `f`, `g` ve `+`'yı inline etmeye çalışacak
@inline f(...) + g(...)

@noinline function explicit_noinline(args...)
    # gövde
end

let
    @inline explicit_noinline(args...) # inline edilecek
end

@noinline let a0, b0 = ...
    a = @inline f(a0)  # derleyici bu çağrıyı inline etmeye çalışacak
    b = f(b0)          # derleyici bu çağrıyı inline etmeye çalışmayacak
    return a, b
end

@noinline

Derleyiciye bir fonksiyonu iç içe geçirmemesi gerektiğini belirtir.

Küçük fonksiyonlar genellikle otomatik olarak iç içe geçirilir. Küçük fonksiyonlar üzerinde @noinline kullanarak otomatik iç içe geçirme engellenebilir.

@noinline, bir fonksiyon tanımının hemen öncesinde veya bir fonksiyon gövdesi içinde uygulanabilir.

# uzun tanım için not ekle
@noinline function longdef(x)
    ...
end

# kısa tanım için not ekle
@noinline shortdef(x) = ...

# bir `do` bloğunun oluşturduğu anonim fonksiyona not ekle
f() do
    @noinline
    ...
end

@noinline block

Derleyiciye block içindeki çağrıları iç içe geçirmemesi gerektiğini belirtir.

# Derleyici `f`'yi iç içe geçirmemeye çalışacak
@noinline f(...)

# Derleyici `f`, `g` ve `+`'yı iç içe geçirmemeye çalışacak
@noinline f(...) + g(...)

@inline function explicit_inline(args...)
    # gövde
end

let
    @noinline explicit_inline(args...) # iç içe geçirilmeyecek
end

@inline let a0, b0 = ...
    a = @noinline f(a0)  # derleyici bu çağrıyı iç içe geçirmeyecek
    b = f(b0)            # derleyici bu çağrıyı iç içe geçirmeye çalışacak
    return a, b
end

@nospecialize

Bir fonksiyon argümanı adına uygulandığında, derleyiciye o argümanın farklı türler için özelleştirilmemesi gerektiğini, bunun yerine o argüman için belirtilen türün kullanılmasını belirtir. Bu, bir resmi argüman listesi içindeki bir argümana veya fonksiyon gövdesinde uygulanabilir. Bir argümana uygulandığında, makro tüm argüman ifadesini sarmalıdır, örneğin, @nospecialize(x::Real) veya @nospecialize(i::Integer...) şeklinde, yalnızca argüman adını sarmak yerine. Fonksiyon gövdesinde kullanıldığında, makro, herhangi bir koddan önce ve ifade konumunda yer almalıdır.

Argüman olmadan kullanıldığında, üst kapsamın tüm argümanlarına uygulanır. Yerel kapsamda, bu, içindeki fonksiyonun tüm argümanları anlamına gelir. Küresel (en üst düzey) kapsamda, bu, mevcut modülde daha sonra tanımlanan tüm yöntemler anlamına gelir.

Özelleştirme, @specialize kullanılarak varsayılan duruma sıfırlanabilir.

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

Örnekler

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

Burada, @nospecialize notasyonu, aşağıdakinin eşdeğeri olan bir sonuç verir:

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

Bu, g için yalnızca bir yerel kod versiyonunun üretilmesini sağlar, bu da herhangi bir AbstractArray için genel olanıdır. Ancak, belirli dönüş türü hala hem g hem de f için çıkarılır ve bu, f ve g'nin çağrıcılarını optimize etmede hala kullanılır.

@specialize

Bir argümanın özel hale getirme ipucunu varsayılan hale geri döndürür. Ayrıntılar için bkz. @nospecialize.

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

Derleyiciye @nospecialize ile belirtilen argümanların türlerini kullanarak f'yi çıkarsamasını söyler. Bu, çıkarım sırasında derleyici tarafından üretilen özel türlerin sayısını sınırlamak için kullanılabilir.

Örnekler

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

Bu örnekte, f her bir A türü için çıkarılacak, ancak g yalnızca belirtilen argüman türü A::AbstractArray ile bir kez çıkarılacak, bu da derleyicinin bunun üzerinde aşırı çıkarım süresi görmeyeceği anlamına gelir, çünkü bunun somut dönüş türünü çıkaramaz. @nospecializeinfer olmadan, f([1.0]), g'nin dönüş türünü Float64 olarak çıkarır, bu da çıkarımın g(::Vector{Float64}) için çalıştığını gösterir, özel kod üretimi yasağına rağmen.

Base.@constprop ayar [ex]

Açıklamalı fonksiyon için interprosedürel sabit yayılma modunu kontrol edin.

İki ayar desteklenmektedir:

• Base.@constprop :aggressive [ex]: sabit yayılmayı agresif bir şekilde uygulayın. Dönüş türünün argümanların değerine bağlı olduğu bir yöntem için, bu ek derleme süresi maliyeti karşılığında iyileştirilmiş çıkarım sonuçları sağlayabilir.
• Base.@constprop :none [ex]: sabit yayılmayı devre dışı bırakın. Bu, Julia'nın aksi takdirde sabit yayılma için değerli görebileceği fonksiyonlar için derleme sürelerini azaltabilir. Yaygın durumlar, Bool veya Symbol değerli argümanlar veya anahtar kelime argümanları olan fonksiyonlardır.

Base.@constprop, bir fonksiyon tanımından hemen önce veya bir fonksiyon gövdesi içinde uygulanabilir.

# uzun biçim tanımını not edin
Base.@constprop :aggressive function longdef(x)
    ...
end

# kısa biçim tanımını not edin
Base.@constprop :aggressive shortdef(x) = ...

# bir `do` bloğunun oluşturduğu anonim fonksiyonu not edin
f() do
    Base.@constprop :aggressive
    ...
end

gensym([tag])

Diğer değişken adlarıyla (aynı modülde) çakışmayacak bir sembol oluşturur.

@gensym

Bir değişken için bir gensym sembolü oluşturur. Örneğin, @gensym x y ifadesi x = gensym("x"); y = gensym("y") şeklinde dönüştürülür.

var

var"#example#" sözdizimi, #example# geçerli bir Julia tanımlayıcı adı olmasa da, Symbol("#example#") adında bir değişkene atıfta bulunur.

Bu, geçerli tanımlayıcıların oluşturulması için farklı kurallara sahip programlama dilleriyle birlikte çalışabilirlik için yararlı olabilir. Örneğin, R değişkeni draw.segments'e atıfta bulunmak için, Julia kodunuzda var"draw.segments" kullanabilirsiniz.

Ayrıca, makro hijyeninden geçmiş veya normalde ayrıştırılamayan değişken adlarını içeren julia kaynak kodunu show etmek için de kullanılır.

Bu sözdiziminin ayrıştırıcı desteği gerektirdiğini ve normal bir dize makrosu @var_str olarak uygulanmak yerine doğrudan ayrıştırıcı tarafından genişletildiğini unutmayın.

@goto name

@goto name koşulsuz olarak @label name konumundaki ifadeye atlar.

@label ve @goto farklı üst düzey ifadelere atlamalar oluşturamaz. Denemeler bir hata ile sonuçlanır. Yine de @goto kullanmak için, @label ve @goto'yu bir blok içinde kapsayın.

@label name

name sembolik etiketi ile bir ifadeyi etiketler. Etiket, @goto name ile koşulsuz bir atlamanın son noktasını işaret eder.

@simd

Bir for döngüsünü, derleyicinin döngü yeniden sıralamasına izin vermek için ekstra özgürlükler almasına olanak tanımak üzere not edin.

!!! uyarı Bu özellik deneysel olup, Julia'nın gelecekteki sürümlerinde değişebilir veya kaybolabilir. @simd makrosunun yanlış kullanımı beklenmedik sonuçlara yol açabilir.

@simd for döngüsünde yinelemeli nesne bir boyutlu bir aralık olmalıdır. @simd kullanarak, döngünün birkaç özelliğini beyan ediyorsunuz:

• İterasyonların rastgele veya örtüşen sırada yürütülmesi güvenlidir, özellikle azaltma değişkenleri için özel dikkate alınmalıdır.
• Azaltma değişkenleri üzerindeki kayan nokta işlemleri yeniden sıralanabilir veya birleştirilebilir, bu da @simd olmadan farklı sonuçlar doğurabilir.

Birçok durumda, Julia, @simd kullanmadan iç for döngülerini otomatik olarak vektörleştirebilir. @simd kullanmak, derleyiciye daha fazla durumlarda bunu mümkün kılmak için biraz ekstra esneklik verir. Her iki durumda da, iç döngünüzün vektörleştirmeye izin vermek için aşağıdaki özelliklere sahip olması gerekir:

• Döngü en içteki döngü olmalıdır.
• Döngü gövdesi düz hat kodu olmalıdır. Bu nedenle, tüm dizi erişimleri için şu anda @inbounds gereklidir. Derleyici, tüm operandları koşulsuz olarak değerlendirmek güvenli olduğunda kısa &&, || ve ?: ifadelerini düz hat koduna dönüştürebilir. Döngüde ?: yerine ifelse fonksiyonunu kullanmayı düşünün, eğer bunu yapmak güvenliyse.
• Erişimlerin bir adım deseni olmalı ve "toplama" (rastgele indeks okumaları) veya "dağıtma" (rastgele indeks yazmaları) olamaz.
• Adım birim adım olmalıdır.

• Döngü taşınan bellek bağımlılıkları yoktur.
• Hiçbir yineleme, ileriye doğru ilerlemek için önceki bir yinelemeyi beklemez.

@polly

Derleyiciye bir fonksiyona poliedral optimizasyon aracı Polly'yi uygulamasını söyler.

@generated f

@generated, bir fonksiyonu oluşturmak için kullanılan bir anotasyondur. Oluşturulan fonksiyonun gövdesinde yalnızca argümanların türleri okunabilir (değerler değil). Fonksiyon, çağrıldığında değerlendirilen bir alıntı ifadesi döndürür. @generated makrosu, global kapsamı değiştiren veya değişken öğelere bağımlı olan fonksiyonlar üzerinde kullanılmamalıdır.

Daha fazla ayrıntı için Metaprogramming bölümüne bakın.

Örnekler

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 ayar... [ex]

Derleyicinin etki modellemesini geçersiz kılın. Bu makro birkaç bağlamda kullanılabilir:

1. Bir yöntem tanımından hemen önce, uygulanan yöntemin tüm etki modellemesini geçersiz kılmak için.
2. Hiçbir argümanı olmayan bir işlev gövdesinde, kapsayıcı yöntemin tüm etki modellemesini geçersiz kılmak için.
3. Bir kod bloğuna uygulandığında, uygulanan kod bloğunun yerel etki modellemesini geçersiz kılmak için.

Örnekler

julia> Base.@assume_effects :terminates_locally function fact(x)
           # kullanım 1:
           # bu :terminates_locally `fact`'in sabit katlanmasına izin verir
           res = 1
           0 ≤ x < 20 || error("kötü faktöriyel")
           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
               # kullanım 2:
               # bu :terminates_locally bu anonim işlevin sabit katlanmasına izin verir
               Base.@assume_effects :terminates_locally
               res = 1
               0 ≤ x < 20 || error("kötü faktöriyel")
               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("kötü faktöriyel")
               # kullanım 3:
               # bu :terminates_locally notasyonu ile derleyici kirletmeyi atlar
               # `:terminates` etkisi bu `while` bloğu içinde, ebeveyn
               # anonim işlevin sabit katlanmasına izin verir
               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}

!!! uyarı Bu makronun yanlış kullanımı tanımsız davranışa (çökmeler, yanlış cevaplar veya diğer zor izlenebilir hatalar dahil) yol açar. Dikkatli kullanın ve kesinlikle gerekli olmadıkça son çare olarak kullanın. Böyle bir durumda bile, etki beyanının gücünü en aza indirmek için tüm olası adımları ATARAK almalısınız (örneğin, :nothrow yeterli olsaydı :total kullanmayın).

Genel olarak, her ayar değeri, derleyicinin bu davranışın gerçekten doğru olduğunu kanıtlamasını gerektirmeden, işlevin davranışı hakkında bir beyan yapar. Bu beyanlar tüm dünya yaşları için yapılır. Bu nedenle, varsayımı geçersiz kılabilecek daha sonra genişletilebilecek genel işlevlerin kullanımını sınırlamak tavsiye edilir (bu tanımsız davranışa yol açar).

Aşağıdaki ayarlar desteklenmektedir.

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

Genişletilmiş yardım

:consistent

:consistent ayarı, egal (===) girdiler için:

• Sonlanma şeklinin (dönüş değeri, istisna, sonsuz döngü) her zaman aynı olacağını beyan eder.
• Eğer yöntem dönerse, sonuçlar her zaman egal olacaktır.

:effect_free

:effect_free ayarı, yöntemin dışsal olarak anlamsal olarak görünür yan etkilerden arınmış olduğunu beyan eder. Aşağıda dışsal olarak anlamsal olarak görünür yan etkilerin eksik bir listesi bulunmaktadır:

• Küresel bir değişkenin değerini değiştirmek.
• Yığını değiştirmek (örneğin, bir dizi veya değiştirilebilir değer), aşağıda belirtilenler dışında
• Yöntem tablosunu değiştirmek (örneğin, eval çağrıları aracılığıyla)
• Dosya/Ağ vb. G/Ç
• Görev değiştirme

Ancak, aşağıdakiler açıkça anlamsal olarak görünür değildir, hatta gözlemlenebilir olsalar bile:

• Bellek tahsisleri (hem değiştirilebilir hem de değiştirilemez)
• Geçen zaman
• Çöp toplama
• Yöntemin ömrünü aşmayan nesnelerin yığın değişiklikleri (yani, yöntemde tahsis edilen ve kaçmayan).
• Döndürülen değer (dışsal olarak görünür, ancak bir yan etki değildir)

Buradaki kural, dışsal olarak görünür bir yan etkinin, işlev çalıştırılmadığında programın geri kalanının yürütülmesini etkileyecek herhangi bir şey olduğudur.

:nothrow

:nothrow ayarları, bu yöntemin bir istisna fırlatmadığını (yani her zaman bir değer döndüreceğini veya asla dönmeyeceğini) beyan eder.

:terminates_globally

:terminates_globally ayarları, bu yöntemin nihayetinde sonlanacağını (ya normal ya da anormal), yani sonsuz döngüye girmeyeceğini beyan eder.

:terminates_locally

:terminates_locally ayarı, :terminates_globally gibi, ancak yalnızca notasyonlu yöntemin içindeki sözdizimsel kontrol akışına uygulanır. Bu nedenle, yöntemin bazı diğer yöntemleri çağırması durumunda sonlanmama olasılığını mümkün kılan çok daha zayıf (ve dolayısıyla daha güvenli) bir beyanıdır.

:notaskstate

:notaskstate ayarı, yöntemin yerel görev durumunu (görev yerel depolama, RNG durumu vb.) kullanmadığını veya değiştirmediğini beyan eder ve bu nedenle görevler arasında gözlemlenebilir sonuçlar olmadan güvenle taşınabilir.

:inaccessiblememonly

:inaccessiblememonly ayarı, yöntemin dışarıdan erişilebilir değiştirilebilir belleği erişmediğini veya değiştirmediğini beyan eder. Bu, yöntemin, döndürüldükten önce diğer yöntemler veya üst düzey yürütme tarafından erişilemeyen yeni tahsis edilmiş nesnelerin değiştirilebilir belleğini erişmesine veya değiştirmesine izin verir, ancak herhangi bir değiştirilebilir küresel durumu veya argümanları tarafından işaret edilen değiştirilebilir belleği erişemez veya değiştiremez.

:noub

:noub ayarı, yöntemin herhangi bir tanımsız davranış gerçekleştirmeyeceğini beyan eder (herhangi bir girdi için). Tanımsız davranışın teknik olarak yöntemin diğer etki beyanlarını (örneğin :consistent veya :effect_free) ihlal etmesine neden olabileceğini unutmayın, ancak bunu modellemiyoruz ve tanımsız davranışın yokluğunu varsayıyoruz.

:nortcall

:nortcall ayarı, yöntemin Core.Compiler.return_type çağrısı yapmadığını ve bu yöntemin çağırabileceği diğer yöntemlerin de Core.Compiler.return_type çağrısı yapmadığını beyan eder.

:foldable

Bu ayar, derleyicinin bir çağrıyı derleme zamanında sabit katlama garantisi vermesi için gereken etki seti için uygun bir kısayoldur. Şu anda aşağıdaki ayarlara eşdeğerdir:

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

:removable

Bu ayar, derleyicinin kullanılmayan bir çağrının sonucunu derleme zamanında silme garantisi vermesi için gereken etki seti için uygun bir kısayoldur. Şu anda aşağıdaki ayarlara eşdeğerdir:

• :effect_free
• :nothrow
• :terminates_globally

:total

Bu ayar, mümkün olan en yüksek etki setidir. Şu anda aşağıdaki diğer ayarları ima eder:

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

!!! uyarı :total, çok güçlü bir beyan olup, gelecekteki Julia sürümlerinde ek anlamlar kazanabilir (örneğin, ek etkiler eklenip :total tanımına dahil edilebilir). Sonuç olarak, dikkatli kullanılmalıdır. Mümkün olduğunda, belirli bir uygulama için gereken en az etki beyanı setini kullanmayı tercih edin. Bir dizi işlev için büyük sayıda etki geçersiz kılmaları uygulandığında, :total kullanımı yerine özel bir makro önerilir.

Olumsuz etkiler

Etki adları, daha önceki bir meta etkiden etkiyi kaldırmak için ! ile ön eklenebilir. Örneğin, :total !:nothrow, çağrının genel olarak toplam olduğunu, ancak yine de fırlatabileceğini belirtir.

@deprecate eski yeni [export_eski=true]

eski metodunu depreke et ve yeni çağrısını belirt, bu süreçte belirtilen imzaya sahip yeni bir eski metodu tanımla.

eskinin dışa aktarılmasını önlemek için export_eski'yi false olarak ayarla.

Ayrıca Base.depwarn() bak.

Örnekler

julia> @deprecate eski(x) yeni(x)
eski (1 metod içeren genel fonksiyon)

julia> @deprecate eski(x) yeni(x) false
eski (1 metod içeren genel fonksiyon)

Açık tür notları olmadan @deprecate çağrıları, Any türünde herhangi bir sayıda konumsal ve anahtar kelime argümanı kabul eden depreke edilmiş metodlar tanımlayacaktır.

Deprekasyonu belirli bir imzaya kısıtlamak için, eskinin argümanlarını not edin. Örneğin,

julia> yeni(x::Int) = x;

julia> yeni(x::Float64) = 2x;

julia> @deprecate eski(x::Int) yeni(x);

julia> methods(eski)
# Ana'dan "eski" genel fonksiyonu için 1 metod:
 [1] eski(x::Int64)
     @ deprecated.jl:94

yeni(x::Int) ile aynısını yansıtan eski(x::Int) metodunu tanımlayacak ve depreke edecek, ancak yeni(x::Float64) metodunu tanımlamayacak veya depreke etmeyecektir.

Base.depwarn(msg::String, funcsym::Symbol; force=false)

msg'yi bir deprecasyon uyarısı olarak yazdırır. funcsym sembolü, çağıran fonksiyonun adını temsil eder ve deprecasyon uyarısının her çağrı yerinde yalnızca ilk kez yazdırılmasını sağlamak için kullanılır. Uyarının her zaman gösterilmesini istiyorsanız force=true olarak ayarlayın, bu durumda Julia --depwarn=no ile başlatılmış olsa bile (varsayılan) uyarı her zaman gösterilecektir.

Ayrıca @deprecate bakınız.

Örnekler

function deprecated_func()
    Base.depwarn("Don't use `deprecated_func()`!", :deprecated_func)

    1 + 1
end

Eksik

Alanı olmayan bir tür, tekil örneği missing eksik değerleri temsil etmek için kullanılır.

Ayrıca bakınız: skipmissing, nonmissingtype, Nothing.

eksik

Missing türünün tekil örneği, eksik bir değeri temsil eder.

Ayrıca bakınız: NaN, skipmissing, nonmissingtype.

coalesce(x...)

Argümanlar arasında missing ile eşit olmayan ilk değeri döndürür, eğer varsa. Aksi takdirde missing döner.

Ayrıca bkz. skipmissing, something, @coalesce.

Örnekler

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # `nothing` döner

julia> coalesce(missing, missing)
missing

@coalesce(x...)

Kısa devre versiyonu coalesce.

Örnekler

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

julia> a = 1;

julia> a = @coalesce a f(2) f(3) error("`a` hala eksik")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b` hala eksik")
f(2)
f(3)
HATA: `b` hala eksik
[...]

ismissing(x)

x'in missing olup olmadığını belirtir.

Ayrıca bakınız: skipmissing, isnothing, isnan.

skipmissing(itr)

itr içindeki missing değerlerini atlayarak elemanlar üzerinde bir iteratör döndürür. Döndürülen nesne, itr indekslenebilir ise itr'nin indeksleri kullanılarak indekslenebilir. Eksik değerlere karşılık gelen indeksler geçerli değildir: bunlar keys ve eachindex tarafından atlanır ve bunları kullanmaya çalıştığınızda bir MissingException hatası fırlatılır.

itr içindeki eksik olmayan değerleri içeren bir Array elde etmek için collect kullanın. itr çok boyutlu bir dizi olsa bile, sonuç her zaman bir Vector olacaktır çünkü eksikleri kaldırırken girişin boyutlarını korumak mümkün değildir.

Ayrıca coalesce, ismissing, something ile de bakabilirsiniz.

Örnekler

julia> x = skipmissing([1, missing, 2])
skipmissing(Union{Missing, Int64}[1, missing, 2])

julia> sum(x)
3

julia> x[1]
1

julia> x[2]
HATA: MissingException: indeks (2,) üzerindeki değer eksik
[...]

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)

Eğer T, Missing içeren bir türler birleşimiyse, Missing kaldırılmış yeni bir tür döndür.

Örnekler

julia> nonmissingtype(Union{Int64,Missing})
Int64

julia> nonmissingtype(Any)
Any

run(command, args...; wait::Bool = true)

Bir komut nesnesini çalıştırır, geri tırnaklarla oluşturulmuştur (bkz. kılavuzdaki Dış Programları Çalıştırma bölümü). Bir şeyler ters giderse, hata fırlatır; bu, sürecin sıfırdan farklı bir durum kodu ile çıkması da dahil (eğer wait true ise).

args... komuta dosya tanımlayıcıları geçirmenize olanak tanır ve normal unix dosya tanımlayıcıları gibi sıralanır (örneğin stdin, stdout, stderr, FD(3), FD(4)...).

Eğer wait false ise, süreç asenkron olarak çalışır. Daha sonra onun için bekleyebilir ve döndürülen süreç nesnesinde success çağrısı yaparak çıkış durumunu kontrol edebilirsiniz.

Eğer wait false ise, sürecin G/Ç akışları devnull'a yönlendirilir. Eğer wait true ise, G/Ç akışları ana süreçle paylaşılır. G/Ç yönlendirmesini kontrol etmek için pipeline kullanın.

devnull

Yazılan tüm verileri atmak için bir akış yönlendirmesinde kullanılır. Temelde Unix'teki /dev/null veya Windows'taki NUL ile eşdeğerdir. Kullanım:

run(pipeline(`cat test.txt`, devnull))

success(command)

Bir komut nesnesini çalıştırır, geri tırnaklarla oluşturulmuştur (kılavuzdaki Dış Programları Çalıştırma bölümüne bakın) ve başarılı olup olmadığını (0 kodu ile çıkıp çıkmadığını) belirtir. Süreç başlatılamazsa bir istisna yükseltilir.

process_running(p::Process)

Bir işlemin şu anda çalışıp çalışmadığını belirleyin.

process_exited(p::Process)

Bir işlemin çıkıp çıkmadığını belirleyin.

kill(p::Process, signum=Base.SIGTERM)

Bir işleme sinyal gönderir. Varsayılan olarak işlemi sonlandırır. İşlem zaten çıkmışsa başarılı bir şekilde döner, ancak işlemi öldürme başarısız olursa (örneğin, yetersiz izinler gibi) bir hata fırlatır.

Sys.set_process_title(title::AbstractString)

Süreç başlığını ayarlayın. Bazı işletim sistemlerinde etkisizdir.

Sys.get_process_title()

Süreç başlığını alır. Bazı sistemlerde her zaman boş bir dize döndürecektir.

ignorestatus(command)

Bir komut nesnesini işaretleyerek, çalıştırıldığında sonuç kodu sıfırdan farklıysa hata fırlatmayacak şekilde ayarlayın.

detach(command)

Bir komut nesnesini işaretleyerek yeni bir işlem grubunda çalıştırılmasını sağlar, böylece Julia işlemini aşabilir ve Ctrl-C kesintilerinin ona iletilmemesini sağlar.

Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir)
Cmd(exec::Vector{String})

Yeni bir Cmd nesnesi oluşturun, cmd'den bir dış program ve argümanları temsil ederken, isteğe bağlı anahtar argümanların ayarlarını değiştirin:

• ignorestatus::Bool: Eğer true ise (varsayılan false), o zaman Cmd sıfır olmayan bir dönüş kodu varsa hata fırlatmayacaktır.
• detach::Bool: Eğer true ise (varsayılan false), o zaman Cmd yeni bir işlem grubunda çalıştırılacak, böylece julia işlemini aşacak ve Ctrl-C'nin ona geçmesini engelleyecektir.
• windows_verbatim::Bool: Eğer true ise (varsayılan false), o zaman Windows'ta Cmd argümanları içeren boşluklar da dahil olmak üzere, argümanların alıntılanmadan veya kaçış karakteri olmadan işleme bir komut satırı dizesi gönderecektir. (Windows'ta, argümanlar bir programa tek bir "komut satırı" dizesi olarak gönderilir ve programlar bunu argümanlara ayırmaktan sorumludur. Varsayılan olarak, boş argümanlar ve boşluk veya sekme içeren argümanlar komut satırında çift tırnak " ile alıntılanır ve \ veya " karakterleri önüne ters eğik çizgi konularak gönderilir. windows_verbatim=true, komut satırını standart dışı yollarla ayrıştıran programları başlatmak için yararlıdır.) Diğer işletim sistemlerinde etkisi yoktur.
• windows_hide::Bool: Eğer true ise (varsayılan false), o zaman Windows'ta Cmd çalıştırıldığında yeni bir konsol penceresi görüntülenmeyecektir. Eğer zaten açık bir konsol varsa veya diğer işletim sistemlerinde etkisi yoktur.
• env: Cmd'yi çalıştırırken kullanılacak ortam değişkenlerini ayarlayın. env, dizeleri dizelere eşleyen bir sözlük, "var=val" biçiminde bir dizi dize veya "var"=>val çiftlerinden oluşan bir dizi veya demet olabilir. Mevcut ortamı değiştirmek (yerine koymak yerine) için env'yi copy(ENV) ile başlatın ve ardından env["var"]=val olarak ayarlayın. Tüm öğeleri değiştirmeden bir Cmd nesnesi içinde bir ortam bloğuna eklemek için, güncellenmiş ortamla bir Cmd nesnesi döndürecek olan addenv() fonksiyonunu kullanın.
• dir::AbstractString: Komut için bir çalışma dizini belirtin (mevcut dizin yerine).

Belirtilmeyen anahtarlar için, cmd'den mevcut ayarlar kullanılır.

Cmd(exec) yapıcısının exec'in bir kopyasını oluşturmadığını unutmayın. exec'teki sonraki değişiklikler Cmd nesnesinde yansıtılacaktır.

Bir Cmd nesnesi oluşturmanın en yaygın yolu komut literalleri (ters tırnaklar) iledir, örneğin:

`ls -l`

Bu daha sonra ayarlarını değiştirmek için Cmd yapıcısına geçirilebilir, örneğin:

Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)

setenv(command::Cmd, env; dir)

Verilen command'ı çalıştırırken kullanılacak ortam değişkenlerini ayarlayın. env, ya string'leri string'lere eşleyen bir sözlük, ya "var=val" biçiminde bir string dizisi ya da sıfır veya daha fazla "var"=>val çift argümanı olabilir. Mevcut ortamı değiştirmek (yerine koymak yerine) için, env'yi copy(ENV) ile oluşturun ve ardından env["var"]=val olarak ayarlayın ya da addenv kullanın.

dir anahtar kelime argümanı, komut için bir çalışma dizini belirtmek için kullanılabilir. dir, command için zaten belirtilmemişse mevcut çalışma dizini olan varsayılan dir'ye ayarlanır.

Ayrıca bkz. Cmd, addenv, ENV, pwd.

addenv(command::Cmd, env...; inherit::Bool = true)

Yeni ortam eşlemelerini verilen Cmd nesnesine birleştirir ve yeni bir Cmd nesnesi döndürür. Tekrar eden anahtarlar değiştirilir. Eğer command zaten herhangi bir ortam değeri içermiyorsa, inherit true ise addenv() çağrısı sırasında mevcut ortamı miras alır. Değeri nothing olan anahtarlar ortamdan silinir.

Ayrıca bkz. Cmd, setenv, ENV.

withenv(f, kv::Pair...)

f'yi, sıfır veya daha fazla "var"=>val argümanı kv ile geçici olarak değiştirilmiş (yerine geçmek yerine setenv gibi) bir ortamda çalıştırır. withenv, genellikle withenv(kv...) do ... end sözdizimi aracılığıyla kullanılır. Bir ortam değişkenini (eğer ayarlanmışsa) geçici olarak kaldırmak için nothing değeri kullanılabilir. withenv döndüğünde, orijinal ortam geri yüklenmiştir.

!!! uyarı Ortamı değiştirmek, iş parçacığı güvenli değildir. Ana süreçten farklı bir ortamla dış komutlar çalıştırmak için, withenv yerine addenv kullanmayı tercih edin.

setcpuaffinity(original_command::Cmd, cpus) -> command::Cmd

command'ın CPU bağlılığını, bir CPU ID'leri (1 tabanlı) listesi cpus ile ayarlayın. cpus = nothing geçmek, original_command'ın herhangi bir CPU bağlılığı varsa bunu kaldırmak anlamına gelir.

Bu fonksiyon yalnızca Linux ve Windows'ta desteklenmektedir. macOS'ta desteklenmemektedir çünkü libuv bağlılık ayarlamayı desteklememektedir.

Örnekler

Linux'ta, taskset komut satırı programı setcpuaffinity'nin nasıl çalıştığını görmek için kullanılabilir.

julia> run(setcpuaffinity(`sh -c 'taskset -p $$'`, [1, 2, 5]));
pid 2273's current affinity mask: 13

Maske değeri 13'ün, ilk, ikinci ve beşinci bitlerin (en az anlamlı konumdan sayarak) açık olduğunu yansıttığını unutmayın:

julia> 0b010011
0x13

pipeline(from, to, ...)

Bir veri kaynağından bir hedefe bir boru hattı oluşturur. Kaynak ve hedef, komutlar, G/Ç akışları, dizeler veya diğer pipeline çağrılarının sonuçları olabilir. En az bir argüman bir komut olmalıdır. Dizeler dosya adlarını ifade eder. İki veya daha fazla argümanla çağrıldığında, soldan sağa doğru zincirlenir. Örneğin, pipeline(a,b,c) ifadesi pipeline(pipeline(a,b),c) ile eşdeğerdir. Bu, çok aşamalı boru hatlarını belirtmek için daha özlü bir yol sağlar.

Örnekler:

run(pipeline(`ls`, `grep xyz`))
run(pipeline(`ls`, "out.txt"))
run(pipeline("out.txt", `grep xyz`))

pipeline(command; stdin, stdout, stderr, append=false)

Verilen command'a I/O yönlendirin. Anahtar kelime argümanları, komutun hangi akışlarının yönlendirileceğini belirtir. append, dosya çıktısının dosyaya eklenip eklenmeyeceğini kontrol eder. Bu, 2-argümanlı pipeline fonksiyonunun daha genel bir versiyonudur. pipeline(from, to) bir komut olduğunda pipeline(from, stdout=to) ile eşdeğerdir ve from başka bir veri kaynağı olduğunda pipeline(to, stdin=from) ile eşdeğerdir.

Örnekler:

run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
run(pipeline(`update`, stdout="log.txt", append=true))

gethostname() -> String

Yerel makinenin ana bilgisayar adını alır.

getpid() -> Int32

Julia'nın işlem kimliğini alır.

getpid(process) -> Int32

Çocuk işlem kimliğini alır, eğer hala mevcutsa.

time() -> Float64

Epoch'tan itibaren geçen süreyi saniye cinsinden, oldukça yüksek (tipik olarak, mikro saniye) çözünürlükle alır.

time_ns() -> UInt64

Zamanı nanosecond cinsinden alır. 0'a karşılık gelen zaman tanımsızdır ve her 5.8 yılda bir döner.

@time expr
@time "açıklama" expr

Bir ifadeyi yürütmek için bir makro, yürütme süresini, yapılan tahsis sayısını ve yürütmenin neden olduğu toplam tahsis edilen bayt sayısını yazdırır, ardından ifadenin değerini döndürür. Çöp toplama (gc), yeni kod derleme veya geçersiz kılınmış kodu yeniden derleme için harcanan süre bir yüzde olarak gösterilir. Beklemek zorunda kalan bir ReentrantLock varsa, bu bir sayı olarak gösterilir.

Zaman raporundan önce yazdırmak için isteğe bağlı bir açıklama dizesi sağlayın.

Bazı durumlarda sistem, @time ifadesinin içine bakacak ve üst düzey ifadenin yürütülmesinden önce çağrılan kodun bir kısmını derleyecektir. Bu olduğunda, bazı derleme süreleri sayılmaz. Bu süreyi dahil etmek için @time @eval ... komutunu çalıştırabilirsiniz.

Ayrıca @showtime, @timev, @timed, @elapsed, @allocated ve @allocations ile de bakabilirsiniz.

julia> x = rand(10,10);

julia> @time x * x;
  0.606588 saniye (2.19 M tahsis: 116.555 MiB, %3.75 gc süresi, %99.94 derleme süresi)

julia> @time x * x;
  0.000009 saniye (1 tahsis: 896 bayt)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 saniye (8 tahsis: 336 bayt)
2

julia> @time "Bir saniyelik uyku" sleep(1)
Bir saniyelik uyku: 1.005750 saniye (5 tahsis: 144 bayt)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 saniye (5 tahsis: 144 bayt)
2: 1.001263 saniye (5 tahsis: 144 bayt)
3: 1.003676 saniye (5 tahsis: 144 bayt)

@showtime expr

@time gibi, ancak referans için değerlendirilen ifadeyi de yazdırır.

Ayrıca bkz. @time.

julia> @showtime sleep(1)
sleep(1): 1.002164 saniye (4 tahsis: 128 bayt)

@timev expr
@timev "açıklama" expr

Bu, @time makrosunun ayrıntılı bir versiyonudur. Öncelikle @time ile aynı bilgileri yazdırır, ardından sıfırdan farklı bellek tahsis sayıcılarını gösterir ve ardından ifadenin değerini döndürür.

Zaman raporundan önce yazdırmak için isteğe bağlı bir açıklama dizesi sağlayabilirsiniz.

Ayrıca @time, @timed, @elapsed, @allocated ve @allocations ile de bakabilirsiniz.

julia> x = rand(10,10);

julia> @timev x * x;
  0.546770 saniye (2.20 M tahsis: 116.632 MiB, %4.23 gc süresi, %99.94 derleme süresi)
geçen süre (ns): 546769547
gc süresi (ns):      23115606
tahsis edilen bayt:   122297811
havuz tahsisleri:       2197930
havuz dışı GC tahsisleri:1327
malloc() çağrıları:    36
realloc() çağrıları:   5
GC duraklamaları:         3

julia> @timev x * x;
  0.000010 saniye (1 tahsis: 896 bayt)
geçen süre (ns): 9848
tahsis edilen bayt:   896
havuz tahsisleri:       1

@timed

Bir ifadeyi yürütmek ve ifadenin değerini, geçen süreyi saniye cinsinden, toplam tahsis edilen baytları, çöp toplama süresini, çeşitli bellek tahsis sayıcılarıyla bir nesneyi, derleme süresini saniye cinsinden ve yeniden derleme süresini saniye cinsinden döndüren bir makro. Bir ReentrantLock beklemek zorunda kaldığında herhangi bir kilit çatışması sayısı olarak gösterilir.

Bazı durumlarda sistem, @timed ifadesinin içine bakacak ve üst düzey ifadenin yürütülmesi başlamadan önce çağrılan kodun bir kısmını derleyecektir. Bu olduğunda, bazı derleme süreleri sayılmayacaktır. Bu süreyi dahil etmek için @timed @eval ... komutunu çalıştırabilirsiniz.

Ayrıca @time, @timev, @elapsed, @allocated, @allocations ve @lock_conflicts ile de bakabilirsiniz.

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

Bir ifadeyi değerlendirmek için bir makro, sonuç değerini atlayarak, yerine yürütmenin kaç saniye sürdüğünü kayan nokta sayısı olarak döndürür.

Bazı durumlarda sistem @elapsed ifadesinin içine bakacak ve üst düzey ifadenin yürütülmesi başlamadan önce çağrılan kodun bir kısmını derleyecektir. Bu olduğunda, bazı derleme süreleri sayılmayacaktır. Bu süreyi dahil etmek için @elapsed @eval ... komutunu çalıştırabilirsiniz.

Ayrıca @time, @timev, @timed, @allocated ve @allocations ile de bakabilirsiniz.

julia> @elapsed sleep(0.3)
0.301391426

@allocated

Bir ifadeyi değerlendirmek için kullanılan bir makro, sonuç değerini atarak, bunun yerine ifadenin değerlendirilmesi sırasında tahsis edilen toplam byte sayısını döndürür.

Ayrıca @allocations, @time, @timev, @timed ve @elapsed ile de bakınız.

julia> @allocated rand(10^6)
8000080

@allocations

Bir ifadeyi değerlendirmek, elde edilen değeri atmak ve bunun yerine ifadenin değerlendirilmesi sırasında toplam tahsis sayısını döndürmek için bir makro.

Ayrıca bkz. @allocated, @time, @timev, @timed ve @elapsed.

julia> @allocations rand(10^6)
2

@lock_conflicts

Bir ifadeyi değerlendirmek, elde edilen değeri atmak ve bunun yerine değerlendirme sırasında kilit çatışmalarının toplam sayısını döndürmek için bir makro. Burada, bir ReentrantLock üzerinde bir kilit denemesi, kilit zaten tutulduğundan beklemeye neden oldu.

Ayrıca bkz. @time, @timev ve @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

Bu türün bir singleton'ı, ortam değişkenlerine bir hash tablosu arayüzü sağlar.

ENV

Singleton EnvDict'e referans, sistem ortam değişkenlerine bir sözlük arayüzü sağlar.

(Windows'ta, sistem ortam değişkenleri büyük/küçük harf duyarsızdır ve ENV buna karşılık olarak tüm anahtarları görüntüleme, yineleme ve kopyalama için büyük harfe dönüştürür. Taşınabilir kod, değişkenleri büyük/küçük harf ile ayırt etme yeteneğine güvenmemeli ve görünüşte küçük harfli bir değişken ayarlamanın büyük harfli bir ENV anahtarı ile sonuçlanabileceğine dikkat etmelidir.)

!!! uyarı Ortamı değiştirmek thread-safe değildir.

Örnekler

julia> ENV
Base.EnvDict with "50" entries:
  "SECURITYSESSIONID"            => "123"
  "USER"                         => "username"
  "MallocNanoZone"               => "0"
  ⋮                              => ⋮

julia> ENV["JULIA_EDITOR"] = "vim"
"vim"

julia> ENV["JULIA_EDITOR"]
"vim"

Ayrıca bakınız: withenv, addenv.

Sys.STDLIB::String

stdlib paketlerini içeren dizinin tam yolunu içeren bir dize.

Sys.isunix([os])

OS'nin Unix benzeri bir arayüz sağlayıp sağlamadığını test etmek için bir predikattır. İşletim Sistemi Varyasyonunu Yönetme belgesine bakın.

Sys.isapple([os])

Apple Macintosh OS X veya Darwin türevi bir işletim sistemi olup olmadığını test etmek için kullanılan predikat. İşletim Sistemi Varyasyonunu Yönetme belgesine bakın.

Sys.islinux([os])

OS'un bir Linux türevi olup olmadığını test etmek için bir predikattir. İşletim Sistemi Varyasyonunu Yönetme belgesine bakın.

Sys.isbsd([os])

BSD türevi bir işletim sistemi olup olmadığını test etmek için bir predikattır. İşletim Sistemi Varyasyonunu Yönetme belgesine bakın.

Sys.isfreebsd([os])

FreeBSD türevi bir işletim sistemi olup olmadığını test etmek için bir predikat. İşletim Sistemi Varyasyonunu Yönetme belgesine bakın.

```

Sys.isopenbsd([os])

OpenBSD türevi bir işletim sistemi olup olmadığını test etmek için bir predikattır. İşletim Sistemi Varyasyonunu Yönetme belgesine bakın.

Sys.isnetbsd([os])

NetBSD türevi bir işletim sistemi olup olmadığını test etmek için bir predikattır. İşletim Sistemi Varyasyonunu Yönetme belgesine bakın.

Sys.isdragonfly([os])

DragonFly BSD türevi bir işletim sistemi olup olmadığını test etmek için bir predikat. İşletim Sistemi Varyasyonunu Yönetme belgesine bakın.

Sys.iswindows([os])

Microsoft Windows NT türevi bir işletim sistemi olup olmadığını test etmek için kullanılan predikat. İşletim Sistemi Varyasyonunu Yönetme belgesine bakın.

Sys.windows_version()

Windows NT Kernel için sürüm numarasını VersionNumber olarak döndürür, yani v"major.minor.build" veya Windows'ta çalışmıyorsa v"0.0.0" döndürür.

Sys.free_memory()

RAM'deki toplam boş belleği bayt cinsinden alır.

Sys.total_memory()

RAM'deki toplam bellek miktarını (şu anda kullanılan miktar dahil) bayt cinsinden alır. Bu miktar, örneğin, Linux kontrol grupları tarafından kısıtlanmış olabilir. Kısıtlanmamış miktar için Sys.total_physical_memory()'e bakın.

Sys.free_physical_memory()

Sistemin serbest belleğini bayt cinsinden alır. Tüm miktar mevcut işlem için kullanılabilir olmayabilir; gerçekten mevcut miktar için Sys.free_memory() kullanın.

Sys.total_physical_memory()

RAM'deki toplam belleği (şu anda kullanılanlar dahil) bayt cinsinden alır. Tüm miktar mevcut işlem için kullanılabilir olmayabilir; Sys.total_memory()'ye bakın.

Sys.uptime()

Mevcut sistem çalışma süresini saniye cinsinden alır.

Sys.isjsvm([os])

Julia'nın bir JavaScript VM (JSVM) içinde çalışıp çalışmadığını test etmek için bir predikattir; örneğin, bir web tarayıcısında WebAssembly JavaScript gömülmesi gibi.

Sys.loadavg()

Yükleme ortalamasını alır. Bakınız: https://en.wikipedia.org/wiki/Load_(computing).

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.

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

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

Sys.username() -> String

Geçerli kullanıcı için kullanıcı adını döndürür. Kullanıcı adı belirlenemiyorsa veya boşsa, bu işlev bir hata fırlatır.

Bir ortam değişkeni aracılığıyla geçersiz kılınabilir bir kullanıcı adı almak için, örneğin USER, şunu kullanmayı düşünün:

user = get(Sys.username, ENV, "USER")

Ayrıca homedir bakınız.

@static

Bir ifadeyi analiz zamanı kısmen değerlendirin.

Örneğin, @static Sys.iswindows() ? foo : bar ifadesi Sys.iswindows()'u değerlendirir ve ifadeye ya foo ya da bar ekler. Bu, başka platformlarda geçersiz olacak bir yapının bulunduğu durumlarda yararlıdır, örneğin var olmayan bir işleve ccall yapmak gibi. @static if Sys.isapple() foo end ve @static foo <&&,||> bar da geçerli bir sözdizimidir.

VersionNumber

Sürüm numarası türü, anlamlı sürümleme (semver) spesifikasyonlarını takip eder ve ana, alt ve yaman sayısal değerlerden oluşur; ardından ön sürüm ve yapı alfanümerik notasyonlar gelir.

VersionNumber nesneleri, tüm standart karşılaştırma operatörleri (==, <, <=, vb.) ile karşılaştırılabilir ve sonuç semver kurallarını takip eder.

VersionNumber aşağıdaki kamu alanlarına sahiptir:

• v.major::Integer
• v.minor::Integer
• v.patch::Integer
• v.prerelease::Tuple{Vararg{Union{Integer, AbstractString}}}
• v.build::Tuple{Vararg{Union{Integer, AbstractString}}}

Ayrıca, semver formatındaki literal dizelerden VersionNumber nesnelerini verimli bir şekilde oluşturmak için @v_str, Julia'nın VersionNumber'ı için VERSION ve kılavuzda Sürüm Numarası Literalleri ile ilgili bilgileri de inceleyebilirsiniz.

Örnekler

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

Bir dizeyi VersionNumber biçimine dönüştürmek için kullanılan dize makrosu.

Örnekler

julia> v"1.2.3"
v"1.2.3"

julia> v"2.0.1-rc1"
v"2.0.1-rc1"

error(message::AbstractString)

Verilen mesajla bir ErrorException yükseltir.

error(msg...)

string(msg...) ile oluşturulmuş bir mesaj ile bir ErrorException yükseltir.

throw(e)

Bir nesneyi bir istisna olarak fırlatır.

Ayrıca bakınız: rethrow, error.

rethrow()

Mevcut istisnayı bir catch bloğundan yeniden fırlatır. Yeniden fırlatılan istisna, yakalanmamış gibi yayılmaya devam edecektir.

backtrace()

Mevcut program noktasının bir geri izleme nesnesini alın.

catch_backtrace()

Mevcut istisnanın geri izini almak için, catch blokları içinde kullanılmak üzere.

current_exceptions(task::Task=current_task(); [backtrace::Bool=true])

Şu anda işlenen istisnaların yığınını alın. İç içe yakalama blokları için yığında birden fazla mevcut istisna olabilir; bu durumda en son fırlatılan istisna yığının en sonunda yer alır. Yığın, (exception,backtrace) adlı demetlerin AbstractVector'ı olan bir ExceptionStack olarak döndürülür. Eğer backtrace false ise, her çiftteki geri izleme nothing olarak ayarlanacaktır.

Açıkça task geçmek, rastgele bir görevdeki mevcut istisna yığınını döndürecektir. Bu, yakalanmamış istisnalar nedeniyle başarısız olan görevleri incelemek için yararlıdır.

@assert cond [metin]

cond false ise bir AssertionError fırlatır. Bu, kullanıcıların hata ayıklama yardımı olarak kontrol etmeyi tercih edebileceği, doğru olduğu varsayılan koşullar için yazılan assertions için tercih edilen sözdizimidir. İsteğe bağlı mesaj metin, assertion başarısız olduğunda görüntülenir.

!!! uyarı Bir assert bazı optimizasyon seviyelerinde devre dışı bırakılabilir. Bu nedenle, assert yalnızca bir hata ayıklama aracı olarak kullanılmalı ve kimlik doğrulama doğrulaması (örneğin, şifreleri doğrulama veya dizi sınırlarını kontrol etme) için kullanılmamalıdır. Kod, bir fonksiyonun doğru davranışı için cond'un çalıştırılmasının yan etkilerine güvenmemelidir.

Örnekler

julia> @assert iseven(3) "3 bir tek sayıdır!"
HATA: AssertionError: 3 bir tek sayıdır!

julia> @assert isodd(3) "Sayılara ne kadar tek bile olsa?"

Experimental.register_error_hint(handler, exceptiontype)

Bir "ipucu" fonksiyonu handler(io, exception) kaydedin, bu fonksiyon kullanıcıların hataları aşmalarına yönelik potansiyel yollar önerebilir. handler, exception'ı incelemeli ve bir ipucu için uygun koşulların karşılanıp karşılanmadığını kontrol etmeli, eğer öyleyse io'ya çıktı üretmelidir. Paketler, __init__ fonksiyonları içinde register_error_hint çağırmalıdır.

Belirli istisna türleri için, handler'ın ek argümanlar alması gerekmektedir:

• MethodError: handler(io, exc::MethodError, argtypes, kwargs) sağlayın, bu, birleştirilmiş argümanları konumsal ve anahtar kelime argümanlarına ayırır.

Bir ipucu verildiğinde, çıktı genellikle \n ile başlamalıdır.

Özel istisna türleri tanımlarsanız, showerror metodunuz ipuçlarını Experimental.show_error_hints çağırarak destekleyebilir.

Örnekler

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
                    # Renk gerekli değildir, bu sadece mümkün olduğunu göstermek içindir.
                    print(io, "\nAcaba çağırmak mı istediniz ")
                    printstyled(io, "`any_number`?", color=:cyan)
               end
           end
       end

       end

Sonra Hinter.only_int'i bir Int olmayan bir şeyle çağırırsanız (böylece bir MethodError tetiklenir), ipucu verir:

julia> Hinter.only_int(1.0)
HATA: MethodError: no method matching only_int(::Float64)
`only_int` fonksiyonu mevcut, ancak bu argüman türleri kombinasyonu için tanımlı bir yöntem yok.
Acaba `any_number` mı çağırmak istediniz?
En yakın adaylar:
    ...

!!! uyarı Bu arayüz deneysel olup, bildirimde bulunmaksızın değişikliklere veya kaldırmalara tabi olabilir. Değişikliklere karşı kendinizi korumak için, herhangi bir kaydı if isdefined(Base.Experimental, :register_error_hint) ... end bloğu içine koymayı düşünün.

Experimental.show_error_hints(io, ex, args...)

Belirli bir istisna türü typeof(ex) için Experimental.register_error_hint tarafından tüm işleyicileri çağırın. args, o tür için işleyici tarafından beklenen diğer argümanları içermelidir.

!!! uyarı Bu arayüz deneysel olup, bildirimde bulunmaksızın değişikliğe veya kaldırılmaya tabidir.

ArgumentError(msg)

Bir işleve geçirilen argümanlar geçersizdir. msg açıklayıcı bir hata mesajıdır.

AssertionError([msg])

Doğrulanan koşul true olarak değerlendirilmedi. İsteğe bağlı argüman msg, açıklayıcı bir hata dizesidir.

Örnekler

julia> @assert false "this is not true"
HATA: AssertionError: this is not true

AssertionError genellikle @assert içinden fırlatılır.

BoundsError([a],[i])

Bir diziye, a, yapılan bir indeksleme işlemi, i indeksinde bir sınır dışı öğeye erişmeye çalıştı.

Örnekler

julia> A = fill(1.0, 7);

julia> A[8]
HATA: BoundsError: 7 elemanlı Vector{Float64} dizisinde [8] indeksine erişim denemesi


julia> B = fill(1.0, (2,3));

julia> B[2, 4]
HATA: BoundsError: 2×3 Matrix{Float64} dizisinde [2, 4] indeksine erişim denemesi


julia> B[9]
HATA: BoundsError: 2×3 Matrix{Float64} dizisinde [9] indeksine erişim denemesi

BileşenHatası

Bir Görev tarafından atılan istisnaların bir Vector'ını (örneğin, bir kanaldan uzaktan çalışan bir işçi tarafından üretilen veya asenkron olarak yürütülen yerel G/Ç yazma işlemi veya pmap altında bir uzaktan işçi) istisnaların dizisi hakkında bilgi ile sarmalayın. Örneğin, bir grup işçi birkaç görevi yürütüyorsa ve birden fazla işçi başarısız olursa, ortaya çıkan BileşenHatası, her işçiden nerede ve neden istisna(lar)ın meydana geldiğini belirten bir "paket" bilgi içerecektir.

DimensionMismatch([msg])

Çağrılan nesnelerin boyutları eşleşmiyor. İsteğe bağlı argüman msg, açıklayıcı bir hata dizesidir.

DivideError()

Tam bölmesi 0 olan bir payda değeri ile denendi.

Örnekler

julia> 2/0
Inf

julia> div(2, 0)
HATA: DivideError: tam bölme hatası
Yığın izi:
[...]

DomainError(val)
DomainError(val, msg)

Bir fonksiyon veya yapıcıya verilen val argümanı geçerli alanın dışındadır.

Örnekler

julia> sqrt(-1)
HATA: DomainError ile -1.0:
sqrt negatif bir reel argüman ile çağrıldı ancak yalnızca karmaşık bir argüman ile çağrıldığında karmaşık bir sonuç döndürecektir. sqrt(Complex(x)) ile denemeyi deneyin.
Stacktrace:
[...]

EOFError()

Bir dosyadan veya akıştan okunacak daha fazla veri yoktu.

Hataİstisnası(msg)

Genel hata türü. Hata mesajı, .msg alanında, daha spesifik ayrıntılar sağlayabilir.

Örnekler

julia> ex = Hataİstisnası("Kötü bir şey yaptım");

julia> ex.msg
"Kötü bir şey yaptım"

InexactError(name::Symbol, T, val)

val'ı T türüne tam olarak dönüştüremiyor name fonksiyonunun bir yönteminde.

Örnekler

julia> convert(Float64, 1+2im)
HATA: InexactError: Float64(1 + 2im)
Yığın İzleme:
[...]

InterruptException()

Süreç bir terminal kesintisi (CTRL+C) ile durduruldu.

Not edin ki, -i (etkileşimli) seçeneği olmadan başlatılan Julia betiğinde, InterruptException varsayılan olarak atılmaz. Betikte Base.exit_on_sigint(false) çağrısı, REPL'in davranışını geri kazanabilir. Alternatif olarak, bir Julia betiği şu şekilde başlatılabilir:

julia -e "include(popfirst!(ARGS))" script.jl

CTRL+C sırasında yürütme sırasında InterruptException atılmasına izin vermek için.

KeyError(key)

Bir AbstractDict (Dict) veya Set benzeri nesneye yapılan bir indeksleme işlemi, mevcut olmayan bir öğeye erişmeye veya silmeye çalıştı.

LoadError(file::AbstractString, line::Int, error)

Bir dosya include edilirken, require edilirken veya using yapılırken bir hata oluştu. Hata ayrıntıları .error alanında mevcut olmalıdır.

MethodError(f, args)

Gerekli tür imzasına sahip bir yöntem, verilen genel işlevde mevcut değildir. Alternatif olarak, benzersiz en-spesifik yöntem yoktur.

MissingException(msg)

missing değeri desteklenmeyen bir durumda karşılaşıldığında fırlatılan istisna. msg alanındaki hata mesajı, daha spesifik ayrıntılar sağlayabilir.

OutOfMemoryError()

Bir işlem, sistemin veya çöp toplayıcının düzgün bir şekilde yönetemesi için çok fazla bellek ayırdı.

ReadOnlyMemoryError()

Bir işlem, yalnızca okunabilir olan belleğe yazmaya çalıştı.

OverflowError(msg)

Bir ifadenin sonucu belirtilen tür için çok büyük ve bir sarma (wraparound) oluşturacaktır.

ProcessFailedException

Bir işlemin sorunlu çıkış durumunu gösterir. Komutlar veya boru hatları çalıştırıldığında, bu, sıfırdan farklı bir çıkış kodunun döndüğünü (yani çağrılan işlemin başarısız olduğunu) belirtmek için fırlatılır.

TaskFailedException

Bu istisna, görev t başarısız olduğunda bir wait(t) çağrısı tarafından fırlatılır. TaskFailedException, başarısız olan görev t'yi sarar.

StackOverflowError()

Fonksiyon çağrısı, çağrı yığınının boyutunu aştı. Bu genellikle bir çağrının sonsuz döngüye girmesi durumunda olur.

SystemError(prefix::AbstractString, [errno::Int32])

Bir sistem çağrısı, bir hata kodu ile başarısız oldu (bu errno global değişkeninde).

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

Bir tür doğrulama hatası veya bir yerleşik işlevin yanlış argüman türü ile çağrılması.

UndefKeywordError(var::Symbol)

Gerekli anahtar argüman var, bir fonksiyon çağrısında atanmadı.

Örnekler

julia> function my_func(;my_arg)
           return my_arg + 1
       end
my_func (generic function with 1 method)

julia> my_func()
HATA: UndefKeywordError: anahtar argüman `my_arg` atanmadı
Stacktrace:
 [1] my_func() at ./REPL[1]:2
 [2] üst düzey kapsam at REPL[2]:1

UndefRefError()

Verilen nesne için öğe veya alan tanımlı değil.

Örnekler

julia> struct MyType
           a::Vector{Int}
           MyType() = new()
       end

julia> A = MyType()
MyType(#undef)

julia> A.a
HATA: UndefRefError: tanımsız referansa erişim
Yığın izi:
[...]

UndefVarError(var::Symbol, [scope])

Mevcut kapsamda bir sembol tanımlı değil.

Örnekler

julia> a
HATA: UndefVarError: `a` tanımlı değil `Main` içinde

julia> a = 1;

julia> a
1

StringIndexError(str, i)

i geçerli olmayan bir indeks olduğunda str'ye erişmeye çalışırken bir hata oluştu.

InitError(mod::Symbol, error)

Bir modülün __init__ fonksiyonu çalıştırılırken bir hata oluştu. Gerçek atılan hata, .error alanında mevcuttur.

retry(f;  delays=ExponentialBackOff(), check=nothing) -> Function

Fonksiyon f'yi çağıran anonim bir fonksiyon döndürür. Bir istisna oluşursa, f tekrar tekrar çağrılır, her seferinde check true döndüğünde, delays'de belirtilen saniye sayısı kadar bekledikten sonra. check, delays'in mevcut durumunu ve Exception'ı girmelidir.

Örnekler

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)

Bir Float64 iteratörü, n uzunluğunda ve elemanları factor * (1 ± jitter) aralığında üssel olarak artar. İlk eleman first_delay'dir ve tüm elemanlar max_delay'e sıkıştırılmıştır.