Essentials

exit(code=0)

프로그램을 종료 코드와 함께 종료합니다. 기본 종료 코드는 0이며, 이는 프로그램이 성공적으로 완료되었음을 나타냅니다. 대화형 세션에서는 키보드 단축키 ^D를 사용하여 exit()를 호출할 수 있습니다.

atexit(f)

프로세스 종료 시 호출될 제로 또는 하나의 인수를 가진 함수 f()를 등록합니다. atexit() 훅은 후입선출(LIFO) 순서로 호출되며 객체 파이널라이저보다 먼저 실행됩니다.

f에 하나의 정수 인수에 대해 정의된 메서드가 있는 경우, 현재 종료 코드인 n을 사용하여 f(n::Int32)로 호출됩니다. 그렇지 않으면 f()로 호출됩니다.

종료 훅은 exit(n)을 호출할 수 있으며, 이 경우 Julia는 종료 코드 n으로 종료됩니다(원래 종료 코드 대신). 여러 종료 훅이 exit(n)을 호출하면, Julia는 exit(n)을 호출한 마지막 종료 훅에 해당하는 종료 코드로 종료됩니다. (종료 훅이 LIFO 순서로 호출되기 때문에 "마지막 호출"은 "첫 번째 등록"과 동일합니다.)

참고: 모든 종료 훅이 호출된 후에는 더 이상 종료 훅을 등록할 수 없으며, 모든 훅이 완료된 후 atexit(f)를 호출하면 예외가 발생합니다. 이 상황은 종료 중에 여전히 동시에 실행될 수 있는 백그라운드 작업에서 종료 훅을 등록하는 경우 발생할 수 있습니다.

isinteractive() -> Bool

줄리아가 대화형 세션에서 실행되고 있는지 여부를 결정합니다.

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

인수에서 도달 가능한 모든 고유 객체가 사용하는 메모리 양(바이트 단위)을 계산합니다.

키워드 인수

• exclude: 탐색에서 제외할 객체의 유형을 지정합니다.
• chargeall: 일반적으로 제외되는 필드라도 항상 모든 필드의 크기를 계산할 객체의 유형을 지정합니다.

자세한 내용은 sizeof를 참조하세요.

예제

julia> Base.summarysize(1.0)
8

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

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

__precompile__(isprecompilable::Bool)

이 함수를 호출하는 파일이 사전 컴파일 가능한지 여부를 지정하며, 기본값은 true입니다. 모듈이나 파일이 안전하게 사전 컴파일할 수 없는 경우, Julia가 이를 사전 컴파일하려고 할 때 오류를 발생시키기 위해 __precompile__(false)를 호출해야 합니다.

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

모듈 m의 전역 범위에서 입력 소스 파일의 내용을 평가합니다. baremodule로 정의된 모듈을 제외한 모든 모듈은 m 인수를 생략한 자체 include 정의를 가지고 있으며, 이는 해당 모듈에서 파일을 평가합니다. 입력 파일의 마지막 평가된 표현식의 결과를 반환합니다. 포함하는 동안, 작업 로컬 포함 경로가 파일이 있는 디렉토리로 설정됩니다. 중첩된 include 호출은 해당 경로를 기준으로 검색합니다. 이 함수는 일반적으로 소스를 대화식으로 로드하거나 여러 소스 파일로 나누어진 패키지의 파일을 결합하는 데 사용됩니다.

선택적 첫 번째 인수 mapexpr는 포함된 코드를 평가하기 전에 변환하는 데 사용할 수 있습니다: path에서 구문 분석된 각 표현식 expr에 대해 include 함수는 실제로 mapexpr(expr)을 평가합니다. 생략할 경우, mapexpr은 identity로 기본 설정됩니다.

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

입력 소스 파일의 내용을 포함하는 모듈의 전역 범위에서 평가합니다. baremodule로 정의된 모듈을 제외한 모든 모듈은 자체 include 정의를 가지고 있으며, 이는 해당 모듈에서 파일을 평가합니다. 입력 파일의 마지막 평가된 표현식의 결과를 반환합니다. 포함하는 동안, 작업 로컬 포함 경로가 파일이 있는 디렉토리로 설정됩니다. 중첩된 include 호출은 해당 경로를 기준으로 검색합니다. 이 함수는 일반적으로 소스를 대화식으로 로드하거나 여러 소스 파일로 나누어진 패키지의 파일을 결합하는 데 사용됩니다. 인수 path는 normpath를 사용하여 정규화되며, 이는 ..와 같은 상대 경로 토큰을 해결하고 /를 적절한 경로 구분 기호로 변환합니다.

선택적 첫 번째 인수 mapexpr는 포함된 코드가 평가되기 전에 변환하는 데 사용할 수 있습니다: path에서 구문 분석된 각 표현식 expr에 대해 include 함수는 실제로 mapexpr(expr)을 평가합니다. 생략할 경우, mapexpr은 기본적으로 identity로 설정됩니다.

다른 모듈에 파일을 평가하려면 Base.include를 사용하세요.

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

include와 유사하지만, 파일이 아닌 주어진 문자열에서 코드를 읽습니다.

선택적 첫 번째 인수 mapexpr는 포함된 코드를 평가하기 전에 변환하는 데 사용할 수 있습니다: code에서 구문 분석된 각 표현식 expr에 대해 include_string 함수는 실제로 mapexpr(expr)을 평가합니다. 생략할 경우, mapexpr는 기본적으로 identity로 설정됩니다.

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

모듈에서 path로 지정된 파일, 디렉토리 또는 심볼릭 링크(상대 경로 또는 절대 경로)가 사전 컴파일을 위한 의존성임을 선언합니다. 즉, track_content=true인 경우 path의 내용이 변경되면 모듈을 다시 컴파일해야 합니다(만약 path가 디렉토리인 경우 내용은 join(readdir(path))와 같습니다). track_content=false인 경우 path의 수정 시간 mtime이 변경될 때 다시 컴파일이 트리거됩니다.

이는 모듈이 include를 통해 사용되지 않는 경로에 의존하는 경우에만 필요합니다. 컴파일 외부에서는 아무런 효과가 없습니다.

__init__

__init__() 함수는 모듈이 런타임에서 처음 로드된 직후에 즉시 실행됩니다. 모듈의 모든 다른 문장이 실행된 후에 한 번 호출됩니다. 모듈을 완전히 가져온 후에 호출되기 때문에, 하위 모듈의 __init__ 함수가 먼저 실행됩니다. __init__의 두 가지 전형적인 용도는 외부 C 라이브러리의 런타임 초기화 함수를 호출하고 외부 라이브러리에서 반환된 포인터와 관련된 전역 상수를 초기화하는 것입니다. 더 자세한 내용은 모듈에 대한 매뉴얼 섹션을 참조하십시오.

예제

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

which(f, types)

주어진 types의 인수에 대해 호출될 f의 메서드(Method 객체)를 반환합니다.

types가 추상 타입인 경우, invoke에 의해 호출될 메서드가 반환됩니다.

또한 참조: parentmodule, @which, 및 @edit.

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

f에 대한 메서드 테이블을 반환합니다.

types가 지정된 경우, 해당 유형과 일치하는 메서드의 배열을 반환합니다. module이 지정된 경우, 해당 모듈에 정의된 메서드의 배열을 반환합니다. 모듈 목록도 배열로 지정할 수 있습니다.

참고: which, @which 및 methodswith.

@show exs...

하나 이상의 표현식과 그 결과를 stdout에 출력하고, 마지막 결과를 반환합니다.

참고: show, @info, println.

예제

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

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

ans

마지막으로 계산된 값을 참조하는 변수로, 대화형 프롬프트에 자동으로 가져옵니다.

err

마지막으로 발생한 오류를 참조하는 변수로, 대화형 프롬프트에 자동으로 가져옵니다. 발생한 오류는 예외 스택에 수집됩니다.

active_project()

활성 Project.toml 파일의 경로를 반환합니다. Base.set_active_project도 참조하십시오.

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

활성 Project.toml 파일을 projfile로 설정합니다. Base.active_project도 참조하세요.

module

module는 Module를 선언하며, 이는 별도의 전역 변수 작업 공간입니다. 모듈 내에서는 다른 모듈에서 어떤 이름이 보이는지를 제어할 수 있으며(가져오기를 통해), 자신의 이름 중 어떤 것이 공개될 것인지(내보내기 및 공개를 통해)를 지정할 수 있습니다. 모듈을 사용하면 다른 사람의 코드와 함께 사용할 때 이름 충돌에 대해 걱정하지 않고 최상위 정의를 만들 수 있습니다. 더 많은 세부정보는 모듈에 대한 매뉴얼 섹션을 참조하십시오.

예제

module Foo
import Base.show
export MyType, foo

struct MyType
    x
end

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

export

export는 모듈 내에서 Julia에게 어떤 이름이 사용자에게 제공되어야 하는지를 알려주는 데 사용됩니다. 예를 들어: export foo는 using 모듈을 사용할 때 이름 foo를 사용할 수 있게 만듭니다. 자세한 내용은 모듈에 대한 매뉴얼 섹션을 참조하세요.

public

public는 모듈 내에서 Julia에게 어떤 이름이 모듈의 공개 API의 일부인지 알려주는 데 사용됩니다. 예를 들어: public foo는 이름 foo가 공개적임을 나타내지만, 모듈을 using할 때 사용할 수 있도록 하지는 않습니다. 자세한 내용은 모듈에 대한 매뉴얼 섹션을 참조하십시오.

import

import Foo는 모듈 또는 패키지 Foo를 로드합니다. 가져온 Foo 모듈의 이름은 점 표기법을 사용하여 접근할 수 있습니다(예: Foo.foo로 이름 foo에 접근). 자세한 내용은 모듈에 대한 매뉴얼 섹션을 참조하세요.

using

using Foo는 모듈 또는 패키지 Foo를 로드하고 그 export된 이름을 직접 사용할 수 있도록 합니다. 이름은 점 표기법을 통해서도 사용할 수 있습니다(예: Foo.foo로 이름 foo에 접근). 이름이 export되었는지 여부에 관계없이 가능합니다. 자세한 내용은 모듈에 대한 매뉴얼 섹션을 참조하세요.

as

as는 import 또는 using에 의해 범위로 가져온 식별자의 이름을 바꾸기 위해 키워드로 사용되며, 이름 충돌을 피하고 이름을 줄이는 데 목적이 있습니다. (import 또는 using 문 외부에서는 as는 키워드가 아니며 일반 식별자로 사용할 수 있습니다.)

import LinearAlgebra as LA는 가져온 LinearAlgebra 표준 라이브러리를 LA로 범위에 가져옵니다.

import LinearAlgebra: eigen as eig, cholesky as chol는 LinearAlgebra에서 eigen 및 cholesky 메서드를 각각 eig 및 chol로 범위에 가져옵니다.

as는 개별 식별자가 범위로 가져올 때만 using과 함께 작동합니다. 예를 들어, using LinearAlgebra: eigen as eig 또는 using LinearAlgebra: eigen as eig, cholesky as chol는 작동하지만, using LinearAlgebra as LA는 유효하지 않은 구문입니다. 이는 LinearAlgebra에서 모든 내보낸 이름을 LA로 바꾸는 것이 말이 되지 않기 때문입니다.

baremodule

baremodule는 using Base 또는 eval 및 include의 로컬 정의가 포함되지 않은 모듈을 선언합니다. 여전히 Core를 가져옵니다. 다시 말해,

module Mod

...

end

는 다음과 동일합니다.

baremodule Mod

using Base

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

...

end

함수

함수는 function 키워드로 정의됩니다:

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

또는 짧은 형식 표기법:

add(a, b) = a + b

return 키워드의 사용은 다른 언어와 정확히 동일하지만, 종종 선택적입니다. 명시적인 return 문이 없는 함수는 함수 본문의 마지막 표현식을 반환합니다.

매크로

매크로는 생성된 코드를 프로그램에 삽입하는 방법을 정의합니다. 매크로는 인수 표현식의 시퀀스를 반환된 표현식에 매핑하며, 결과 표현식은 매크로가 호출된 지점에서 프로그램에 직접 대체됩니다. 매크로는 eval을 호출하지 않고 생성된 코드를 실행하는 방법이며, 생성된 코드는 단순히 주변 프로그램의 일부가 됩니다. 매크로 인수에는 표현식, 리터럴 값 및 기호가 포함될 수 있습니다. 매크로는 가변 개수의 인수(varargs)에 대해 정의할 수 있지만, 키워드 인수는 허용하지 않습니다. 모든 매크로는 또한 암묵적으로 __source__ 인수를 전달받으며, 이는 매크로가 호출된 줄 번호와 파일 이름을 포함하고, __module__은 매크로가 확장되는 모듈입니다.

매크로 작성 방법에 대한 자세한 정보는 메타프로그래밍 매뉴얼 섹션을 참조하십시오.

예제

julia> macro sayhello(name)
           return :( println("Hello, ", $name, "!") )
       end
@sayhello (매크로 1개의 메서드가 있음)

julia> @sayhello "Charlie"
Hello, Charlie!

julia> macro saylots(x...)
           return :( println("Say: ", $(x...)) )
       end
@saylots (매크로 1개의 메서드가 있음)

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

return

return x는 포함된 함수가 조기에 종료되도록 하여 주어진 값 x를 호출자에게 반환합니다. 값 없이 단독으로 사용된 return은 return nothing과 동일합니다(자세한 내용은 nothing를 참조하세요).

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

일반적으로 함수 본문 내의 어디에서나 return 문을 배치할 수 있으며, 깊이 중첩된 루프나 조건문 내에서도 사용할 수 있지만, do 블록에서는 주의해야 합니다. 예를 들어:

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

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

첫 번째 예제에서 return은 짝수에 도달하자마자 test1을 종료하므로, test1([5,6,7])은 12를 반환합니다.

두 번째 예제가 같은 방식으로 작동할 것이라고 예상할 수 있지만, 사실 return은 내부 함수(즉, do 블록 내)에서만 종료되고 map에 값을 반환합니다. 따라서 test2([5,6,7])는 [5,12,7]을 반환합니다.

최상위 표현식(즉, 어떤 함수 외부)에서 사용될 때, return은 현재의 전체 최상위 표현식을 조기에 종료시킵니다.

do

익명 함수를 생성하고 이를 함수 호출의 첫 번째 인수로 전달합니다. 예를 들어:

map(1:10) do x
    2x
end

는 map(x->2x, 1:10)와 같습니다.

다음과 같이 여러 인수를 사용할 수 있습니다:

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

begin

begin...end는 코드 블록을 나타냅니다.

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

일반적으로 begin은 필요하지 않습니다. function 및 let와 같은 키워드는 암묵적으로 코드 블록을 시작합니다. ;도 참조하십시오.

begin은 인덱싱할 때 컬렉션의 첫 번째 인덱스 또는 배열의 차원의 첫 번째 인덱스를 나타내는 데 사용할 수 있습니다. 예를 들어, a[begin]은 배열 a의 첫 번째 요소입니다.

예제

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

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

end

end는 표현식 블록의 결론을 나타내며, 예를 들어 module, struct, mutable struct, begin, let, for 등이 있습니다.

end는 또한 인덱싱할 때 컬렉션의 마지막 인덱스 또는 배열의 차원의 마지막 인덱스를 나타내는 데 사용될 수 있습니다.

예제

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

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

let

let 블록은 새로운 하드 스코프를 생성하고 선택적으로 새로운 로컬 바인딩을 도입합니다.

다른 스코프 구성 요소와 마찬가지로, let 블록은 새로 도입된 로컬 변수가 접근 가능한 코드 블록을 정의합니다. 또한, 구문은 쉼표로 구분된 할당 및 let과 같은 줄에 선택적으로 나타날 수 있는 변수 이름에 대해 특별한 의미를 가집니다:

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

이 줄에서 도입된 변수는 let 블록에 로컬이며, 할당은 순서대로 평가되며, 각 오른쪽 항은 왼쪽 항의 이름을 고려하지 않고 스코프 내에서 평가됩니다. 따라서 let x = x와 같은 것을 작성하는 것이 의미가 있습니다. 두 x 변수는 서로 다르며, 왼쪽 항이 외부 스코프의 x를 로컬로 가리는 것입니다. 이는 로컬 스코프에 들어갈 때마다 새 로컬 변수가 새로 생성되기 때문에 유용한 관용구가 될 수 있지만, 이는 클로저를 통해 스코프를 초과하는 변수가 있는 경우에만 관찰할 수 있습니다. 위의 예에서 var2와 같이 할당이 없는 let 변수는 아직 값에 바인딩되지 않은 새로운 로컬 변수를 선언합니다.

대조적으로, begin 블록은 여러 표현식을 함께 그룹화하지만 스코프를 도입하거나 특별한 할당 구문을 가지지 않습니다.

예제

아래 함수에서는 map에 의해 세 번 반복적으로 업데이트되는 단일 x가 있습니다. 반환된 클로저는 모두 최종 값에서 그 하나의 x를 참조합니다:

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

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

그러나 새로운 로컬 변수를 도입하는 let 블록을 추가하면, 같은 이름을 사용하기로 선택했음에도 불구하고 각 반복에서 캡처되는 세 개의 서로 다른 변수가 생깁니다.

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

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

새로운 로컬 변수를 도입하는 모든 스코프 구성 요소는 반복적으로 실행될 때 이렇게 동작합니다. let의 특징은 동일한 이름의 외부 변수를 가릴 수 있는 새로운 local을 간결하게 선언할 수 있는 능력입니다. 예를 들어, do 함수의 인수를 직접 사용하면 세 개의 서로 다른 변수를 캡처합니다:

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

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

if/elseif/else

if/elseif/else는 조건 평가를 수행하며, 이는 코드의 일부가 부울 표현식의 값에 따라 평가되거나 평가되지 않도록 합니다. 다음은 if/elseif/else 조건 구문의 구조입니다:

if x < y
    println("x는 y보다 작습니다")
elseif x > y
    println("x는 y보다 큽니다")
else
    println("x는 y와 같습니다")
end

조건 표현식 x < y가 참이면 해당 블록이 평가됩니다. 그렇지 않으면 조건 표현식 x > y가 평가되고, 만약 그것이 참이면 해당 블록이 평가됩니다. 두 표현식 모두 참이 아니면 else 블록이 평가됩니다. elseif 및 else 블록은 선택 사항이며, 원하는 만큼 많은 elseif 블록을 사용할 수 있습니다.

다른 일부 언어와 달리 조건은 Bool 유형이어야 합니다. 조건이 Bool로 변환 가능하다고 해서 충분하지 않습니다.

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

for

for 루프는 값의 시퀀스를 반복하면서 문 블록을 반복적으로 평가합니다.

반복 변수는 항상 새로운 변수이며, 동일한 이름의 변수가 포함된 범위에 존재하더라도 마찬가지입니다. 반복을 위해 기존의 지역 변수를 재사용하려면 outer를 사용하세요.

예제

julia> for i in [1, 4, 0]
           println(i)
       end
1
4
0

while

while 루프는 조건 표현식을 반복적으로 평가하며, 표현식이 참인 동안 while 루프의 본문을 계속 평가합니다. while 루프에 처음 도달했을 때 조건 표현식이 거짓이면 본문은 절대 평가되지 않습니다.

예제

julia> i = 1
1

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

break

루프에서 즉시 빠져나옵니다.

예제

julia> i = 0
0

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

continue

현재 루프 반복의 나머지를 건너뜁니다.

예제

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

try/catch

try/catch 문은 throw로 발생한 오류(예외)를 가로채어 프로그램 실행을 계속할 수 있도록 합니다. 예를 들어, 다음 코드는 파일을 쓰려고 시도하지만, 파일을 쓸 수 없는 경우 사용자에게 경고하고 실행을 종료하는 대신 계속 진행합니다:

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

또는, 파일을 변수에 읽을 수 없는 경우:

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

catch e 구문(여기서 e는 임의의 변수)은 catch 블록 내에서 발생한 예외 객체를 주어진 변수에 할당합니다.

try/catch 구조의 힘은 깊게 중첩된 계산을 즉시 호출 함수 스택의 훨씬 높은 수준으로 풀어낼 수 있는 능력에 있습니다.

마지막으로

주어진 코드 블록이 어떻게 종료되든지 간에 코드를 실행합니다. 예를 들어, 열린 파일이 닫히도록 보장하는 방법은 다음과 같습니다:

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

제어가 try 블록을 떠날 때(예: return으로 인해, 또는 그냥 정상적으로 종료되는 경우) close(f)가 실행됩니다. try 블록이 예외로 인해 종료되면, 예외는 계속 전파됩니다. catch 블록은 try 및 finally와 결합될 수 있습니다. 이 경우 finally 블록은 catch가 오류를 처리한 후에 실행됩니다.

quote

quote는 명시적인 Expr 생성자를 사용하지 않고 블록 내에서 여러 표현식 객체를 생성합니다. 예를 들어:

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

다른 인용 방법인 :( ... )와 달리, 이 형태는 표현식 트리에 QuoteNode 요소를 도입하며, 이는 트리를 직접 조작할 때 고려해야 합니다. 다른 용도로는 :( ... )와 quote .. end 블록이 동일하게 처리됩니다.

local

local은 새로운 지역 변수를 도입합니다. 더 많은 정보는 변수 범위에 대한 매뉴얼 섹션을 참조하세요.

예제

julia> function foo(n)
           x = 0
           for i = 1:n
               local x # 루프 지역 x 도입
               x = i
           end
           x
       end
foo (generic function with 1 method)

julia> foo(10)
0

global

global x는 현재 범위와 그 내부 범위에서 x가 해당 이름의 전역 변수를 참조하도록 만듭니다. 더 많은 정보는 변수 범위에 대한 매뉴얼 섹션을 참조하세요.

예제

julia> z = 3
3

julia> function foo()
           global z = 6 # foo 외부에서 정의된 z 변수를 사용합니다.
       end
foo (generic function with 1 method)

julia> foo()
6

julia> z
6

for outer

for 루프에서 반복을 위해 기존의 지역 변수를 재사용합니다.

자세한 내용은 변수 범위에 대한 매뉴얼 섹션을 참조하십시오.

또한 for를 참조하십시오.

예제

julia> function f()
           i = 0
           for i = 1:3
               # 비어 있음
           end
           return i
       end;

julia> f()
0

julia> function f()
           i = 0
           for outer i = 1:3
               # 비어 있음
           end
           return i
       end;

julia> f()
3

julia> i = 0 # 전역 변수
       for outer i = 1:3
       end
ERROR: syntax: no outer local variable declaration exists for "for outer"
[...]

const

const는 값이 변경되지 않는 전역 변수를 선언하는 데 사용됩니다. 거의 모든 코드(특히 성능에 민감한 코드)에서 전역 변수는 이와 같은 방식으로 상수로 선언되어야 합니다.

const x = 5

하나의 const 내에서 여러 변수를 선언할 수 있습니다:

const y, z = 7, 11

const는 하나의 = 연산에만 적용되므로, const x = y = 1은 x를 상수로 선언하지만 y는 그렇지 않습니다. 반면에, const x = const y = 1은 x와 y 모두를 상수로 선언합니다.

"상수성"은 변경 가능한 컨테이너로 확장되지 않으며, 변수와 그 값 간의 연관성만이 상수입니다. 예를 들어 x가 배열이나 사전인 경우에도 요소를 수정, 추가 또는 제거할 수 있습니다.

일부 경우 const 변수의 값을 변경하면 오류 대신 경고가 발생합니다. 그러나 이는 예측할 수 없는 동작을 초래하거나 프로그램의 상태를 손상시킬 수 있으므로 피해야 합니다. 이 기능은 대화형 사용 중 편의를 위해서만 의도되었습니다.

struct

Julia에서 가장 일반적으로 사용되는 유형은 이름과 필드 집합으로 지정된 struct입니다.

struct Point
    x
    y
end

필드는 유형 제한을 가질 수 있으며, 이는 매개변수화될 수 있습니다:

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

struct는 <: 구문을 통해 추상 슈퍼 유형을 선언할 수도 있습니다:

struct Point <: AbstractPoint
    x
    y
end

struct는 기본적으로 불변입니다; 이러한 유형의 인스턴스는 생성 후 수정할 수 없습니다. 인스턴스를 수정할 수 있는 유형을 선언하려면 mutable struct를 대신 사용하십시오.

생성자 정의와 같은 더 많은 세부정보는 Composite Types 매뉴얼 섹션을 참조하십시오.

mutable struct

mutable struct는 struct와 유사하지만, 추가로 생성 후 타입의 필드를 설정할 수 있습니다.

mutable struct의 개별 필드는 const로 표시하여 불변으로 만들 수 있습니다:

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

자세한 내용은 Composite Types 매뉴얼 섹션을 참조하세요.

@kwdef typedef

이 매크로는 typedef 표현식에서 선언된 타입에 대한 키워드 기반 생성자를 자동으로 정의하는 도우미 매크로입니다. 여기서 typedef는 struct 또는 mutable struct 표현식이어야 합니다. 기본 인자는 field::T = default 또는 field = default 형식으로 필드를 선언하여 제공됩니다. 기본값이 제공되지 않으면 키워드 인자는 결과 타입 생성자에서 필수 키워드 인자가 됩니다.

내부 생성자는 여전히 정의할 수 있지만, 적어도 하나는 기본 내부 생성자와 동일한 형식(즉, 필드당 하나의 위치 인자)을 수용해야 키워드 외부 생성자와 올바르게 작동합니다.

예제

julia> @kwdef struct Foo
           a::Int = 1         # 지정된 기본값
           b::String          # 필수 키워드
       end
Foo

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

julia> Foo()
ERROR: UndefKeywordError: keyword argument `b` not assigned
Stacktrace:
[...]

추상형

추상형은 인스턴스화할 수 없는 형을 선언하며, 형 그래프의 노드로만 사용되어 관련된 구체적 형의 집합을 설명합니다: 그 구체적 형들은 이들의 자손입니다. 추상형은 줄리아의 형 시스템을 단순한 객체 구현의 집합 이상으로 만드는 개념적 계층을 형성합니다. 예를 들어:

abstract type Number end
abstract type Real <: Number end

Number에는 슈퍼타입이 없고, 반면에 Real는 Number의 추상 하위형입니다.

원시 타입

원시 타입은 데이터가 비트 시리즈로만 구성된 구체적인 타입을 선언합니다. 원시 타입의 고전적인 예로는 정수와 부동 소수점 값이 있습니다. 몇 가지 예제 내장 원시 타입 선언:

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

이름 뒤의 숫자는 타입이 요구하는 저장소의 비트 수를 나타냅니다. 현재 8비트의 배수인 크기만 지원됩니다. Bool 선언은 원시 타입이 선택적으로 어떤 슈퍼타입의 서브타입으로 선언될 수 있는 방법을 보여줍니다.

where

where 키워드는 UnionAll 타입을 생성하며, 이는 어떤 변수의 모든 값에 대해 다른 타입의 반복된 합집합으로 생각할 수 있습니다. 예를 들어 Vector{T} where T<:Real은 요소 타입이 어떤 종류의 Real 숫자인 모든 Vector를 포함합니다.

변수 바인드는 생략할 경우 기본적으로 Any로 설정됩니다:

Vector{T} where T    # `where T<:Any`의 약어

변수는 하한을 가질 수도 있습니다:

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

중첩된 where 표현식에 대한 간결한 구문도 있습니다. 예를 들어, 다음과 같은 표현식:

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

는 다음과 같이 줄일 수 있습니다:

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

이 형태는 메서드 시그니처에서 자주 발견됩니다.

이 형태에서는 변수가 바깥쪽부터 나열된다는 점에 유의하세요. 이는 타입이 T{p1, p2, ...} 구문을 사용하여 매개변수 값에 "적용"될 때 변수들이 치환되는 순서와 일치합니다.

...

"splat" 연산자 ...는 인수의 시퀀스를 나타냅니다. ...는 함수 정의에서 사용되어 함수가 임의의 수의 인수를 수용할 수 있음을 나타냅니다. ...는 또한 함수에 인수 시퀀스를 적용하는 데 사용할 수 있습니다.

예제

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

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

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

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

;

;는 많은 C 계열 언어에서와 마찬가지로 Julia에서 이전 문장의 끝을 구분하는 역할을 합니다.

;는 줄 끝에 필요하지 않지만, 한 줄에서 문장을 구분하거나 문장을 하나의 표현식으로 결합하는 데 사용할 수 있습니다.

REPL에서 줄 끝에 ;를 추가하면 해당 표현식의 결과 출력이 억제됩니다.

함수 선언에서, 그리고 선택적으로 호출에서, ;는 일반 인수를 키워드와 구분합니다.

배열 리터럴에서 세미콜론으로 구분된 인수는 그 내용을 함께 연결합니다. 단일 ;로 만들어진 구분자는 수직으로 연결(즉, 첫 번째 차원에 따라)하고, ;;는 수평으로 연결(두 번째 차원), ;;;는 세 번째 차원에 따라 연결하는 등의 방식으로 작동합니다. 이러한 구분자는 대괄호의 마지막 위치에서도 사용되어 길이가 1인 후행 차원을 추가할 수 있습니다.

괄호 안의 첫 번째 위치에 있는 ;는 명명된 튜플을 구성하는 데 사용할 수 있습니다. 할당의 왼쪽에서 동일한 (; ...) 구문은 속성 구조 분해를 허용합니다.

표준 REPL에서 빈 줄에 ;를 입력하면 셸 모드로 전환됩니다.

예제

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

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

julia> foo();

julia> bar()
"Hello, Mars!"

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

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

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

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

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

julia> nt = (; x=1) # ; 또는 후행 쉼표 없이 이 경우 x에 할당됩니다.
(x = 1,)

julia> key = :a; c = 3;

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

julia> (; b, x) = nt2; # 속성 구조 분해를 사용하여 변수 b와 x를 설정합니다.

julia> b, x
(2, 1)

julia> ; # ;를 입력하면 프롬프트가 (제자리에서) shell>로 변경됩니다.
shell> echo hello
hello

=

=는 할당 연산자입니다.

• 변수 a와 표현식 b에 대해, a = b는 a가 b의 값을 참조하도록 만듭니다.
• 함수 f(x)에 대해, f(x) = x는 새로운 함수 상수 f를 정의하거나, f가 이미 정의되어 있는 경우 f에 새로운 메서드를 추가합니다; 이 사용법은 function f(x); x; end와 동등합니다.
• a[i] = v는 setindex!(a,v,i)를 호출합니다.
• a.b = c는 setproperty!(a,:b,c)를 호출합니다.
• 함수 호출 내에서, f(a=b)는 b를 키워드 인수 a의 값으로 전달합니다.
• 쉼표가 있는 괄호 안에서, (a=1,)는 NamedTuple를 생성합니다.

예제

a를 b에 할당하는 것은 b의 복사본을 생성하지 않습니다; 대신 copy 또는 deepcopy를 사용하십시오.

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

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

함수에 전달된 컬렉션도 복사되지 않습니다. 함수는 인수들이 참조하는 객체의 내용을 수정(변형)할 수 있습니다. (이런 기능을 가진 함수의 이름은 관례적으로 '!'로 끝납니다.)

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

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

할당은 반복 가능한 객체에서 값을 가져와 여러 변수에 병렬로 작동할 수 있습니다:

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

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

julia> a, b
(1, 2)

할당은 여러 변수에 연속적으로 작동할 수 있으며, 가장 오른쪽 표현식의 값을 반환합니다:

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

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

범위를 벗어난 인덱스에서의 할당은 컬렉션을 확장하지 않습니다. 컬렉션이 Vector인 경우, 대신 push! 또는 append!로 확장할 수 있습니다.

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

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

[]를 할당하는 것은 컬렉션에서 요소를 제거하지 않습니다; 대신 filter!를 사용하십시오.

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

julia> filter!(x -> x > 1, a) # 제자리에서 수행되므로 a = a[a .> 1]보다 더 효율적입니다.
2-element Array{Int64, 1}:
 2
 3

a ? b : c

조건부의 짧은 형태; "만약 a라면 b를 평가하고, 그렇지 않으면 c를 평가하라"고 읽습니다. 삼항 연산자로도 알려져 있습니다.

이 구문은 if a; b else c end와 동등하지만, 종종 더 큰 표현식의 일부로 사용되는 값 b 또는 c를 강조하기 위해 사용되며, b 또는 c를 평가하는 데 따른 부작용보다는 강조됩니다.

자세한 내용은 제어 흐름 매뉴얼 섹션을 참조하십시오.

예제

julia> x = 1; y = 2;

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

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

Main

Main은 최상위 모듈이며, Julia는 Main을 현재 모듈로 설정하여 시작합니다. 프롬프트에서 정의된 변수는 Main에 들어가고, varinfo는 Main의 변수를 나열합니다.

julia> @__MODULE__
Main

Core

Core는 언어에 "내장"된 것으로 간주되는 모든 식별자를 포함하는 모듈입니다. 즉, 핵심 언어의 일부이며 라이브러리가 아닙니다. 모든 모듈은 암묵적으로 using Core를 지정합니다. 이러한 정의 없이는 아무것도 할 수 없기 때문입니다.

Base

줄리아의 기본 라이브러리. Base는 기본 기능( base/의 내용)을 포함하는 모듈입니다. 모든 모듈은 암묵적으로 using Base를 포함하고 있으며, 이는 대다수의 경우에 필요합니다.

Base.Broadcast

브로드캐스팅 구현을 포함하는 모듈입니다.

문서

Docs 모듈은 Julia 객체에 대한 문서 메타데이터를 설정하고 검색하는 데 사용할 수 있는 @doc 매크로를 제공합니다.

자세한 내용은 문서화 매뉴얼 섹션을 참조하십시오.

이터레이터와 함께 작업하는 방법.

libc, C 표준 라이브러리에 대한 인터페이스.

메타프로그래밍을 위한 편리한 함수.

스택 트레이스를 수집하고 조작하는 도구. 주로 오류를 생성하는 데 사용됩니다.

하드웨어 및 운영 체제에 대한 정보를 검색하는 방법을 제공합니다.

멀티스레딩 지원.

Base.GC

가비지 수집 유틸리티가 포함된 모듈입니다.

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

x와 y가 동일한지 여부를 결정합니다. 즉, 어떤 프로그램도 이들을 구별할 수 없다는 의미입니다. 먼저 x와 y의 타입이 비교됩니다. 타입이 동일하면, 가변 객체는 메모리 주소로 비교되고, 불변 객체(예: 숫자)는 비트 수준에서 내용으로 비교됩니다. 이 함수는 때때로 "egal"이라고도 불립니다. 항상 Bool 값을 반환합니다.

예제

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

julia> a == b
true

julia> a === b
false

julia> a === a
true

isa(x, type) -> Bool

주어진 type의 x가 있는지 확인합니다. 또한 중위 연산자로 사용할 수 있습니다. 예: x isa type.

예제

julia> isa(1, Int)
true

julia> isa(1, Matrix)
false

julia> isa(1, Char)
false

julia> isa(1, Number)
true

julia> 1 isa Number
true

isequal(x, y) -> Bool

==와 유사하지만 부동 소수점 숫자와 결측값 처리에서 다릅니다. isequal은 모든 부동 소수점 NaN 값을 서로 같다고 간주하고, -0.0을 0.0과 다르다고 간주하며, missing을 missing과 같다고 간주합니다. 항상 Bool 값을 반환합니다.

isequal은 동치 관계입니다 - 반사적(===는 isequal을 의미함), 대칭적(isequal(a, b)는 isequal(b, a)를 의미함) 및 추이적(isequal(a, b)와 isequal(b, c)는 isequal(a, c)를 의미함)입니다.

구현

isequal의 기본 구현은 ==를 호출하므로, 부동 소수점 값을 포함하지 않는 타입은 일반적으로 ==만 정의하면 됩니다.

isequal은 해시 테이블(Dict)에서 사용되는 비교 함수입니다. isequal(x,y)는 hash(x) == hash(y)를 의미해야 합니다.

이는 일반적으로 사용자 정의 == 또는 isequal 메서드가 존재하는 타입이 해당하는 hash 메서드를 구현해야 함을 의미합니다(그리고 그 반대도 마찬가지입니다). 컬렉션은 일반적으로 모든 내용에 대해 isequal을 재귀적으로 호출하여 isequal을 구현합니다.

또한, isequal은 isless와 연결되어 있으며, 이들은 함께 고정된 총 순서를 정의하는 데 작용합니다. 여기서 isequal(x, y), isless(x, y), 또는 isless(y, x) 중 정확히 하나는 true여야 하며(다른 두 개는 false여야 함) 합니다.

스칼라 타입은 일반적으로 ==와 별도로 isequal을 구현할 필요가 없지만, 더 효율적인 구현이 가능한 부동 소수점 숫자를 나타내는 경우에는 예외입니다(기본 제공되는 일반적인 대체 구현을 기반으로 isnan, signbit, 및 == 사용).

예제

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

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

julia> 0.0 == -0.0
true

julia> isequal(0.0, -0.0)
false

julia> missing == missing
missing

julia> isequal(missing, missing)
true

isequal(x)

x와 isequal를 사용하여 인수를 비교하는 함수를 만듭니다. 즉, y -> isequal(y, x)와 동등한 함수입니다.

반환된 함수는 Base.Fix2{typeof(isequal)} 유형이며, 이는 특수화된 메서드를 구현하는 데 사용할 수 있습니다.

isless(x, y)

x가 y보다 작은지 테스트합니다. 이는 고정된 전체 순서에 따라 정의됩니다 ( isequal와 함께 정의됨). isless는 모든 유형의 쌍 (x, y)에 대해 정의되지 않습니다. 그러나 정의된 경우, 다음을 만족해야 합니다:

• isless(x, y)가 정의되면, isless(y, x)와 isequal(x, y)도 정의되며, 이 세 가지 중 정확히 하나가 true를 반환해야 합니다.
• isless에 의해 정의된 관계는 전이적입니다. 즉, isless(x, y) && isless(y, z)이면 isless(x, z)를 의미합니다.

일반적으로 순서가 없는 값, 예를 들어 NaN은 일반 값 뒤에 정렬됩니다. missing 값은 마지막에 정렬됩니다.

이것은 sort!에서 사용되는 기본 비교입니다.

구현

전체 순서가 있는 비숫자 유형은 이 함수를 구현해야 합니다. 숫자 유형은 NaN과 같은 특수 값이 있는 경우에만 구현해야 합니다. 부분 순서가 있는 유형은 <를 구현해야 합니다. 정렬 및 관련 함수에서 사용할 수 있는 대체 정렬 방법을 정의하는 방법에 대한 문서는 Alternate Orderings를 참조하십시오.

예제

julia> isless(1, 3)
true

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

isunordered(x)

x가 <에 따라 정렬할 수 없는 값인 경우 true를 반환합니다. 예를 들어 NaN 또는 missing과 같은 값입니다.

이 술어로 true로 평가되는 값은 isless와 같은 다른 정렬에 대해서는 정렬할 수 있을 수 있습니다.

ifelse(condition::Bool, x, y)

condition이 true이면 x를 반환하고, 그렇지 않으면 y를 반환합니다. 이는 ? 또는 if와 다르게 일반 함수이므로 모든 인수가 먼저 평가됩니다. 경우에 따라 if 문 대신 ifelse를 사용하면 생성된 코드에서 분기를 제거하고 긴 루프에서 더 높은 성능을 제공할 수 있습니다.

예제

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

typeassert(x, type)

x isa type가 아닐 경우 TypeError를 발생시킵니다. 구문 x::type은 이 함수를 호출합니다.

예제

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

typeof(x)

x의 구체적인 타입을 가져옵니다.

자세한 내용은 eltype를 참조하세요.

예제

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

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

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

tuple(xs...)

주어진 객체의 튜플을 생성합니다.

자세한 내용은 Tuple, ntuple, NamedTuple를 참조하세요.

예제

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

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

julia> Tuple(Real[1, 2, pi])  # 컬렉션을 사용합니다
(1, 2, π)

ntuple(f, n::Integer)

길이 n의 튜플을 생성하며, 각 요소는 f(i)로 계산됩니다. 여기서 i는 요소의 인덱스입니다.

예제

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

ntuple(f, ::Val{N})

길이 N의 튜플을 생성하며, 각 요소는 f(i)로 계산됩니다. 여기서 i는 요소의 인덱스입니다. Val(N) 인수를 사용하면, 이 버전의 ntuple이 길이를 정수로 받는 버전보다 더 효율적인 코드를 생성할 수 있습니다. 그러나 N이 컴파일 시간에 결정될 수 없는 경우에는 ntuple(f, Val(N))보다 ntuple(f, N)이 더 바람직합니다.

예제

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

objectid(x) -> UInt

객체의 정체성에 기반하여 x에 대한 해시 값을 가져옵니다.

x === y이면 objectid(x) == objectid(y)이고, 일반적으로 x !== y일 때 objectid(x) != objectid(y)입니다.

또한 hash, IdDict를 참조하세요.

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

정수 해시 코드를 계산하여 isequal(x,y)가 hash(x)==hash(y)를 의미하도록 합니다. 선택적 두 번째 인수 h는 결과와 혼합할 또 다른 해시 코드입니다.

새로운 유형은 일반적으로 내용의 해시를 서로(및 h와) 혼합하기 위해 2-인수 hash 메서드를 재귀적으로 호출하여 2-인수 형식을 구현해야 합니다. 일반적으로 hash를 구현하는 모든 유형은 위에서 언급한 속성을 보장하기 위해 자신의 == (따라서 isequal)도 구현해야 합니다.

해시 값은 새로운 Julia 프로세스가 시작될 때 변경될 수 있습니다.

julia> a = hash(10)
0x95ea2955abd45275

julia> hash(10, a) # 다른 해시 함수의 출력을 두 번째 인수로만 사용
0xd42bad54a8575b16

또한 참조: objectid, Dict, Set.

finalizer(f, x)

함수 f(x)를 등록하여 x에 대한 프로그램 접근 가능한 참조가 없을 때 호출되도록 하고, x를 반환합니다. x의 타입은 mutable struct이어야 하며, 그렇지 않으면 함수가 예외를 발생시킵니다.

f는 작업 전환을 유발해서는 안 되며, 이는 println과 같은 대부분의 I/O 작업을 제외합니다. 디버깅 목적으로 @async 매크로(파이널라이저 외부에서 컨텍스트 전환을 연기하기 위해 사용) 또는 C에서 I/O 함수를 직접 호출하기 위한 ccall을 사용하는 것이 도움이 될 수 있습니다.

f의 실행에 대한 보장된 세계 나이는 없다는 점에 유의하십시오. f는 파이널라이저가 등록된 세계 나이 또는 이후의 어떤 세계 나이에서 호출될 수 있습니다.

예제

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

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

파이널라이저는 객체 생성 시 등록될 수 있습니다. 다음 예제에서는 파이널라이저가 새로 생성된 가변 구조체 x를 반환하는 것에 암묵적으로 의존하고 있음을 주목하십시오.

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

finalize(x)

객체 x에 대해 등록된 파이널라이저를 즉시 실행합니다.

copy(x)

x의 얕은 복사본을 만듭니다: 외부 구조는 복사되지만 모든 내부 값은 복사되지 않습니다. 예를 들어, 배열을 복사하면 원본과 동일한 요소를 가진 새 배열이 생성됩니다.

또한 copy!, copyto!, deepcopy를 참조하세요.

deepcopy(x)

x의 깊은 복사본을 생성합니다: 모든 것이 재귀적으로 복사되어 완전히 독립적인 객체가 생성됩니다. 예를 들어, 배열을 깊은 복사하면 그 배열이 포함하고 있는 모든 객체의 깊은 복사본이 생성되고 일관된 관계 구조를 가진 새로운 배열이 생성됩니다(예: 원래 배열의 첫 번째 두 요소가 동일한 객체인 경우, 새 배열의 첫 번째 두 요소도 동일한 deepcopy된 객체가 됩니다). 객체에 대해 deepcopy를 호출하는 것은 일반적으로 직렬화한 다음 역직렬화하는 것과 동일한 효과를 가져야 합니다.

일반적으로 필요하지는 않지만, 사용자 정의 유형은 deepcopy_internal(x::T, dict::IdDict)라는 함수의 특수화된 버전을 정의하여 기본 deepcopy 동작을 재정의할 수 있습니다(이 함수는 다른 용도로 사용해서는 안 됨). 여기서 T는 특수화할 유형이고, dict는 재귀 내에서 지금까지 복사된 객체를 추적합니다. 정의 내에서 deepcopy_internal을 deepcopy 대신 사용해야 하며, 반환하기 전에 dict 변수를 적절하게 업데이트해야 합니다.

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

구문 a.b는 getproperty(a, :b)를 호출합니다. 구문 @atomic order a.b는 getproperty(a, :b, :order)를 호출하고, 구문 @atomic a.b는 getproperty(a, :b, :sequentially_consistent)를 호출합니다.

예제

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

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

julia> obj = MyType(1);

julia> obj.special
2

julia> obj.x
1

getproperty는 필요할 때만 오버로드해야 하며, obj.f 구문의 동작이 비정상적일 경우 혼란스러울 수 있습니다. 또한 메서드를 사용하는 것이 종종 더 바람직하다는 점에 유의하세요. 더 많은 정보는 이 스타일 가이드 문서를 참조하세요: 직접 필드 접근보다 내보낸 메서드를 선호.

또한 getfield, propertynames 및 setproperty!를 참조하세요.

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

구문 a.b = c는 setproperty!(a, :b, c)를 호출합니다. 구문 @atomic order a.b = c는 setproperty!(a, :b, c, :order)를 호출하고, 구문 @atomic a.b = c는 setproperty!(a, :b, c, :sequentially_consistent)를 호출합니다.

또한 setfield!, propertynames 및 getproperty를 참조하십시오.

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

x.f의 값을 expected에서 desired로 교환하는 비교 및 교환 작업을 수행합니다. 함수 호출 형식 대신 @atomicreplace x.f expected => desired 구문을 사용할 수 있습니다.

또한 replacefield!, setproperty!, setpropertyonce!를 참조하십시오.

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

구문 @atomic a.b, _ = c, a.b는 (c, swapproperty!(a, :b, c, :sequentially_consistent))를 반환하며, 양쪽 모두에 공통된 getproperty 표현식이 있어야 합니다.

또한 swapfield! 및 setproperty!를 참조하십시오.

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

구문 @atomic op(x.f, v) (및 그에 해당하는 @atomic x.f op v)는 modifyproperty!(x, :f, op, v, :sequentially_consistent)를 반환하며, 여기서 첫 번째 인자는 getproperty 표현식이어야 하고 원자적으로 수정됩니다.

op(getproperty(x, f), v)의 호출은 기본적으로 객체 x의 필드 f에 저장할 수 있는 값을 반환해야 합니다. 특히, setproperty!의 기본 동작과 달리, convert 함수는 자동으로 호출되지 않습니다.

또한 modifyfield! 및 setproperty!를 참조하십시오.

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

x.f에 대해 비교 및 교환 작업을 수행하여 이전에 설정되지 않은 경우 value로 설정합니다. 함수 호출 형식 대신 @atomiconce x.f = value 구문을 사용할 수 있습니다.

또한 setfieldonce!, setproperty!, replaceproperty!를 참조하십시오.

propertynames(x, private=false)

객체 x의 속성(x.property)의 튜플 또는 벡터를 가져옵니다. 이는 일반적으로 fieldnames(typeof(x))와 동일하지만, getproperty를 오버로드하는 타입은 일반적으로 propertynames도 오버로드하여 해당 타입의 인스턴스 속성을 가져와야 합니다.

propertynames(x)는 x의 문서화된 인터페이스의 일부인 "공개" 속성 이름만 반환할 수 있습니다. 내부 사용을 위한 "비공식" 속성 이름도 반환하려면 선택적 두 번째 인수로 true를 전달하십시오. x.에 대한 REPL 탭 완성은 private=false 속성만 표시합니다.

참고: hasproperty, hasfield.

hasproperty(x, s::Symbol)

객체 x가 s를 자신의 속성 중 하나로 가지고 있는지 여부를 나타내는 불리언을 반환합니다.

참고: propertynames, hasfield.

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

구성 요소 value에서 이름이나 위치로 필드를 추출합니다. 선택적으로, 작업을 위한 순서를 정의할 수 있습니다. 필드가 @atomic으로 선언된 경우, 해당 위치에 대한 저장소와 호환되도록 사양을 강력히 권장합니다. 그렇지 않으면 @atomic으로 선언되지 않은 경우, 지정된 경우 이 매개변수는 :not_atomic이어야 합니다. 또한 getproperty 및 fieldnames를 참조하십시오.

예제

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

julia> getfield(a, :num)
1

julia> a.num
1

julia> getfield(a, 1)
1

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

value의 명명된 필드에 x를 할당합니다. value는 변경 가능해야 하며, x는 fieldtype(typeof(value), name)의 하위 유형이어야 합니다. 또한 이 작업에 대한 순서를 지정할 수 있습니다. 필드가 @atomic으로 선언된 경우, 이 사양은 필수입니다. 그렇지 않으면 @atomic으로 선언되지 않은 경우, 지정된 경우 :not_atomic이어야 합니다. setproperty!도 참조하십시오.

예제

julia> mutable struct MyMutableStruct
           field::Int
       end

julia> a = MyMutableStruct(1);

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

julia> getfield(a, :field)
2

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

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

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

함수를 op 적용한 후 필드를 가져오고 설정하는 작업을 원자적으로 수행합니다.

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

하드웨어에서 지원하는 경우(예: 원자적 증가), 적절한 하드웨어 명령어로 최적화될 수 있으며, 그렇지 않으면 루프를 사용합니다.

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

주어진 값으로 필드를 가져오고 조건부로 설정하는 작업을 원자적으로 수행합니다.

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

하드웨어에서 지원하는 경우, 적절한 하드웨어 명령어로 최적화될 수 있으며, 그렇지 않으면 루프를 사용합니다.

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

필드를 동시에 가져오고 설정하는 작업을 원자적으로 수행합니다:

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

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

주어진 값을 필드에 설정하는 작업을 원자적으로 수행하며, 이전에 설정되지 않은 경우에만 수행합니다.

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

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

전역 변수 또는 객체 필드가 정의되어 있는지 테스트합니다. 인수는 모듈과 기호 또는 복합 객체와 필드 이름(기호로) 또는 인덱스가 될 수 있습니다. 선택적으로, 작업에 대한 순서를 정의할 수 있습니다. 필드가 @atomic으로 선언된 경우, 해당 위치에 대한 저장소와 호환되도록 사양이 강력히 권장됩니다. 그렇지 않으면 @atomic으로 선언되지 않은 경우, 이 매개변수는 지정된 경우 :not_atomic이어야 합니다.

배열 요소가 정의되어 있는지 테스트하려면 isassigned를 대신 사용하십시오.

또한 @isdefined를 참조하십시오.

예제

julia> isdefined(Base, :sum)
true

julia> isdefined(Base, :NonExistentMethod)
false

julia> a = 1//2;

julia> isdefined(a, 2)
true

julia> isdefined(a, 3)
false

julia> isdefined(a, :num)
true

julia> isdefined(a, :numerator)
false

@isdefined s -> Bool

변수 s가 현재 범위에서 정의되어 있는지 테스트합니다.

필드 속성에 대한 isdefined와 배열 인덱스에 대한 isassigned 또는 다른 매핑에 대한 haskey를 참조하세요.

예제

julia> @isdefined newvar
false

julia> newvar = 1
1

julia> @isdefined newvar
true

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

julia> f()
false
true

convert(T, x)

x를 타입 T의 값으로 변환합니다.

T가 Integer 타입인 경우, x가 T로 표현할 수 없는 경우에는 InexactError가 발생합니다. 예를 들어, x가 정수 값이 아니거나 T가 지원하는 범위를 벗어나는 경우입니다.

예제

julia> convert(Int, 3.0)
3

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

T가 AbstractFloat 타입인 경우, T로 표현할 수 있는 x에 가장 가까운 값을 반환합니다. Inf는 가장 가까운 값을 결정하는 데 있어 floatmax(T)보다 하나 더 큰 ulp로 처리됩니다.

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125

T가 컬렉션 타입이고 x가 컬렉션인 경우, convert(T, x)의 결과는 x의 전체 또는 일부를 별칭할 수 있습니다.

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

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

julia> y === x
true

또한 참조: round, trunc, oftype, reinterpret.

promote(xs...)

모든 인수를 공통 유형으로 변환하고, 모두 (튜플로) 반환합니다. 변환할 수 있는 인수가 없으면 오류가 발생합니다.

참고: promote_type, promote_rule.

예제

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

julia> promote_type(Int8, Float16, Float32)
Float32

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

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

julia> promote_type(Int, String)
Any

oftype(x, y)

y를 x의 타입으로 변환합니다. 즉, convert(typeof(x), y)입니다.

예제

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0

widen(x)

만약 x가 타입이라면, 산술 연산 +와 -가 x 타입이 가질 수 있는 값의 조합에 대해 오버플로우나 정밀도 손실이 발생하지 않도록 보장되는 "더 큰" 타입을 반환합니다.

128비트 미만의 고정 크기 정수 타입에 대해, widen은 비트 수가 두 배인 타입을 반환합니다.

만약 x가 값이라면, widen(typeof(x))로 변환됩니다.

예시

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

항등 함수. 인수를 반환합니다.

참고: one, oneunit, 및 LinearAlgebra의 I.

예제

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

WeakRef(x)

w = WeakRef(x)는 Julia 값 x에 대한 약한 참조를 생성합니다: w가 x에 대한 참조를 포함하고 있지만, x가 가비지 컬렉션되는 것을 방지하지는 않습니다. w.value는 x가 아직 가비지 컬렉션되지 않았다면 x이거나, x가 가비지 컬렉션되었다면 nothing입니다.

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

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

julia> GC.gc()

julia> w           # `x`를 통해 참조가 유지됩니다.
WeakRef("a string")

julia> x = nothing # 참조를 지웁니다.

julia> GC.gc()

julia> w
WeakRef(nothing)

supertype(T::DataType)

DataType T의 슈퍼타입을 반환합니다.

예시

julia> supertype(Int32)
Signed

Core.Type{T}

Core.Type는 모든 타입 객체를 인스턴스로 가지는 추상 타입입니다. 단일톤 타입 Core.Type{T}의 유일한 인스턴스는 객체 T입니다.

예제

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

julia> isa(Float64, Type)
true

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

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

DataType <: Type{T}

DataType는 이름이 있는 명시적으로 선언된 타입, 명시적으로 선언된 슈퍼타입, 그리고 선택적으로 매개변수를 나타냅니다. 시스템의 모든 구체적인 값은 어떤 DataType의 인스턴스입니다.

예시

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType

<:(T1, T2)

서브타입 연산자: T1 유형의 모든 값이 T2 유형이기도 할 경우에만 true를 반환합니다.

예시

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

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

>:(T1, T2)

슈퍼타입 연산자, T2 <: T1과 동등합니다.

typejoin(T, S, ...)

타입 T와 S의 가장 가까운 공통 조상을 반환합니다. 즉, 두 타입이 모두 상속하는 가장 좁은 타입입니다. 추가적인 varargs에 대해 재귀적으로 호출합니다.

예시

julia> typejoin(Int, Float64)
Real

julia> typejoin(Int, Float64, ComplexF32)
Number

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

T와 S의 교차점을 포함하는 타입을 계산합니다. 일반적으로 이는 가장 작은 그러한 타입이거나 그에 가까운 타입이 될 것입니다.

정확한 동작이 보장되는 특별한 경우: T <: S일 때, typeintersect(S, T) == T == typeintersect(T, S)입니다.

promote_type(type1, type2, ...)

프로모션은 혼합된 타입의 값을 단일 공통 타입으로 변환하는 것을 의미합니다. promote_type은 서로 다른 타입의 인수를 받을 때 Julia에서 기본 프로모션 동작을 나타냅니다. promote_type은 일반적으로 과도하게 넓히지 않으면서 두 입력 타입 중 대부분의 값을 근사할 수 있는 타입을 반환하려고 합니다. 일부 손실은 허용됩니다. 예를 들어, promote_type(Int64, Float64)는 Float64를 반환하지만, 엄밀히 말하면 모든 Int64 값이 정확하게 Float64 값으로 표현될 수는 없습니다.

참고: promote, promote_typejoin, promote_rule.

예제

julia> promote_type(Int64, Float64)
Float64

julia> promote_type(Int32, Int64)
Int64

julia> promote_type(Float32, BigInt)
BigFloat

julia> promote_type(Int16, Float16)
Float16

julia> promote_type(Int64, Float16)
Float16

julia> promote_type(Int8, UInt16)
UInt16

!!! 경고 "이것을 직접 오버로드하지 마세요" 자신의 타입에 대한 프로모션을 오버로드하려면 promote_rule를 오버로드해야 합니다. promote_type은 내부적으로 타입을 결정하기 위해 promote_rule을 호출합니다. promote_type을 직접 오버로드하면 모호성 오류가 발생할 수 있습니다.

promote_rule(type1, type2)

type1과 type2의 값이 주어졌을 때 promote가 어떤 타입을 사용해야 하는지를 지정합니다. 이 함수는 직접 호출해서는 안 되며, 적절한 새로운 타입에 대한 정의가 추가되어야 합니다.

promote_typejoin(T, S)

T와 S를 모두 포함하는 타입을 계산합니다. 이는 두 타입의 부모일 수도 있고, 적절한 경우 Union일 수도 있습니다. typejoin으로 대체됩니다.

대신 promote, promote_type를 참조하세요.

예제

julia> Base.promote_typejoin(Int, Float64)
Real

julia> Base.promote_type(Int, Float64)
Float64

isdispatchtuple(T)

타입 T가 튜플 "리프 타입"인지 확인합니다. 즉, 이는 디스패치에서 타입 시그니처로 나타날 수 있으며 호출에서 나타날 수 있는 하위 타입(또는 상위 타입)이 없습니다. 만약 T가 타입이 아니라면 false를 반환합니다.

ismutable(v) -> Bool

값 v가 변경 가능하면 true를 반환합니다. 불변성에 대한 논의는 Mutable Composite Types를 참조하십시오. 이 함수는 값에 대해 작동하므로, DataType을 제공하면 해당 유형의 값이 변경 가능하다고 알려줍니다.

또한 isbits, isstructtype를 참조하십시오.

예제

julia> ismutable(1)
false

julia> ismutable([1,2])
true

isimmutable(v) -> Bool

값 v가 불변이면 true를 반환합니다. 불변성에 대한 논의는 Mutable Composite Types를 참조하세요. 이 함수는 값에 대해 작동하므로, 타입을 제공하면 DataType의 값이 가변적이라고 알려줍니다.

예제

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

ismutabletype(T) -> Bool

타입 T가 가변 타입으로 선언되었는지 여부를 결정합니다(즉, mutable struct 키워드를 사용하여). 만약 T가 타입이 아니라면 false를 반환합니다.

isabstracttype(T)

타입 T가 추상 타입으로 선언되었는지 (즉, abstract type 구문을 사용하여) 확인합니다. 이는 isconcretetype(T)의 부정이 아님에 유의하십시오. 만약 T가 타입이 아니라면 false를 반환합니다.

예시

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

isprimitivetype(T) -> Bool

타입 T가 원시 타입으로 선언되었는지 여부를 결정합니다(즉, primitive type 구문을 사용하여). 만약 T가 타입이 아니라면 false를 반환합니다.

Base.issingletontype(T)

타입 T가 정확히 하나의 가능한 인스턴스를 가지고 있는지 확인합니다. 예를 들어, 다른 싱글톤 값 외에 필드가 없는 구조체 타입입니다. 만약 T가 구체적인 타입이 아니라면 false를 반환합니다.

isstructtype(T) -> Bool

타입 T가 구조체 타입으로 선언되었는지 (즉, struct 또는 mutable struct 키워드를 사용하여) 확인합니다. 만약 T가 타입이 아니라면 false를 반환합니다.

nameof(t::DataType) -> Symbol

주어진 (잠재적으로 UnionAll로 감싸진) DataType의 이름을 부모 모듈 없이 기호로 가져옵니다.

예제

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

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

fieldnames(x::DataType)

DataType의 필드 이름을 포함하는 튜플을 가져옵니다.

또한 propertynames, hasfield를 참조하세요.

예제

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

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

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

DataType의 필드 i의 이름을 가져옵니다.

예제

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

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

합성 데이터 타입 T에서 필드(이름 또는 인덱스로 지정)의 선언된 타입을 결정합니다.

예제

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

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

fieldtypes(T::Type)

복합 데이터 타입 T의 모든 필드에 대한 선언된 타입을 튜플로 반환합니다.

예제

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

julia> fieldtypes(Foo)
(Int64, String)

fieldcount(t::Type)

주어진 타입의 인스턴스가 가질 필드의 수를 가져옵니다. 이 타입이 너무 추상적이어서 이를 결정할 수 없는 경우 오류가 발생합니다.

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

T가 자신의 필드 중 하나로 name을 가지고 있는지 여부를 나타내는 불리언을 반환합니다.

자세한 내용은 fieldnames, fieldcount, hasproperty를 참조하세요.

예제

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false

nfields(x) -> Int

주어진 객체의 필드 수를 가져옵니다.

예제

julia> a = 1//2;

julia> nfields(a)
2

julia> b = 1
1

julia> nfields(b)
0

julia> ex = ErrorException("I've done a bad thing");

julia> nfields(ex)
1

이 예제에서 a는 두 개의 필드를 가진 Rational입니다. b는 필드가 전혀 없는 원시 비트 타입인 Int입니다. ex는 하나의 필드를 가진 ErrorException입니다.

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

주어진 모듈 m에서 전역 변수가 const로 선언되었는지 여부를 결정합니다.

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

주어진 타입 t에서 필드 s가 const로 선언되었는지 여부를 결정합니다.

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

주어진 타입 t에서 필드 s가 @atomic으로 선언되었는지 여부를 결정합니다.

sizeof(T::DataType)
sizeof(obj)

주어진 DataType T의 표준 이진 표현의 크기(바이트 단위)입니다. 또는 DataType이 아닌 경우 객체 obj의 크기(바이트 단위)입니다.

자세한 내용은 Base.summarysize를 참조하세요.

예제

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

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

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

julia> sizeof(StructWithPadding) # 패딩으로 인해 필드의 `sizeof` 합계가 아님
16

julia> sizeof(Int64) + sizeof(Bool) # 위와 다름
9

DataType T에 특정 크기가 없는 경우 오류가 발생합니다.

julia> sizeof(AbstractArray)
ERROR: Abstract type AbstractArray does not have a definite size.
Stacktrace:
[...]

isconcretetype(T)

타입 T가 구체적인 타입인지 여부를 결정합니다. 즉, 직접적인 인스턴스(값 x가 typeof(x) === T인 경우)를 가질 수 있음을 의미합니다. isabstracttype(T)의 부정이 아님에 유의하십시오. T가 타입이 아닌 경우 false를 반환합니다.

참고: isbits, isabstracttype, issingletontype.

예제

julia> isconcretetype(Complex)
false

julia> isconcretetype(Complex{Float32})
true

julia> isconcretetype(Vector{Complex})
true

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

julia> isconcretetype(Union{})
false

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

isbits(x)

x가 isbitstype 유형의 인스턴스인 경우 true를 반환합니다.

isbitstype(T)

타입 T가 "일반 데이터" 타입인 경우 true를 반환합니다. 이는 불변이며 다른 값에 대한 참조가 없고, 오직 primitive 타입과 다른 isbitstype 타입만 포함된다는 의미입니다. 전형적인 예로는 UInt8, Float64, 및 Complex{Float64}와 같은 숫자 타입이 있습니다. 이 타입 카테고리는 타입 매개변수로 유효하며, isdefined / isassigned 상태를 추적하지 않을 수 있고, C와 호환되는 정의된 레이아웃을 가지고 있기 때문에 중요합니다. 만약 T가 타입이 아니라면 false를 반환합니다.

또한 isbits, isprimitivetype, ismutable를 참조하세요.

예제

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

fieldoffset(type, i)

타입의 필드 i의 바이트 오프셋으로 데이터 시작에 상대적입니다. 예를 들어, 구조체에 대한 정보를 요약하기 위해 다음과 같이 사용할 수 있습니다:

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

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

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

이 유형의 인스턴스에 대한 메모리 할당 최소 정렬입니다. isconcretetype에 대해 호출할 수 있지만, Memory의 경우 전체 객체가 아닌 요소의 정렬을 제공합니다.

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

이 타입의 인스턴스 필드가 메모리에 패딩 비트 없이 포장되어 있는지 여부를 반환합니다(패딩 비트는 구조체 필드에 적용될 때 동등성 테스트에 고유하게 영향을 미치지 않는 비트로 정의됨). isconcretetype에 대해 호출할 수 있습니다.

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

이 타입의 인스턴스가 gc-관리 메모리에 대한 참조를 포함할 수 있는지 여부를 반환합니다. isconcretetype에 대해 호출할 수 있습니다.

typemin(T)

주어진 (실수) 숫자 데이터 타입 T로 표현할 수 있는 가장 낮은 값입니다.

참고: floatmin, typemax, eps.

예제

julia> typemin(Int8)
-128

julia> typemin(UInt32)
0x00000000

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

julia> nextfloat(-Inf32)  # 가장 작은 유한한 Float32 부동 소수점 수
-3.4028235f38

typemax(T)

주어진 (실수) 숫자 DataType이 표현할 수 있는 가장 높은 값입니다.

참고: floatmax, typemin, eps.

예제

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> typemax(Float32)
Inf32

julia> floatmax(Float32)  # 가장 큰 유한한 Float32 부동 소수점 숫자
3.4028235f38

floatmin(T = Float64)

부동 소수점 타입 T로 표현 가능한 가장 작은 양의 정상 숫자를 반환합니다.

예제

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

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308

floatmax(T = Float64)

부동 소수점 타입 T로 표현할 수 있는 가장 큰 유한 수를 반환합니다.

참고: typemax, floatmin, eps.

예제

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

julia> typemax(Float64)
Inf

maxintfloat(T=Float64)

주어진 부동 소수점 유형 T(기본값은 Float64)에서 정확하게 표현되는 가장 큰 연속 정수 값의 부동 소수점 숫자입니다.

즉, maxintfloat는 n+1이 유형 T에서 정확하게 표현되지 않는 가장 작은 양의 정수 값의 부동 소수점 숫자 n을 반환합니다.

Integer 유형의 값이 필요할 경우, Integer(maxintfloat(T))를 사용하십시오.

maxintfloat(T, S)

주어진 부동 소수점 유형 T에서 표현할 수 있는 가장 큰 연속 정수로, 정수 유형 S로 표현할 수 있는 최대 정수를 초과하지 않습니다. 즉, maxintfloat(T)와 typemax(S) 중 최소값입니다.

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

부동 소수점 유형 T의 머신 엡실론을 반환합니다(T = Float64가 기본값). 이는 typeof(one(T))로 표현할 수 있는 다음으로 큰 값과 1 사이의 간격으로 정의되며, eps(one(T))와 동일합니다. (eps(T)는 T의 상대 오차에 대한 경계이므로, one과 같은 "무차원" 양입니다.)

예제

julia> eps()
2.220446049250313e-16

julia> eps(Float32)
1.1920929f-7

julia> 1.0 + eps()
1.0000000000000002

julia> 1.0 + eps()/2
1.0

eps(x::AbstractFloat)

x의 마지막 자리 단위 (ulp)를 반환합니다. 이는 x에서 연속적으로 표현 가능한 부동 소수점 값 사이의 거리입니다. 대부분의 경우, x의 양쪽 거리 차이가 다르면 두 값 중 더 큰 값을 취합니다. 즉,

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

이 규칙의 예외는 가장 작은 및 가장 큰 유한 값들(예: Float64에 대한 nextfloat(-Inf) 및 prevfloat(Inf))로, 이들은 더 작은 값으로 반올림됩니다.

이 동작의 이유는 eps가 부동 소수점 반올림 오류의 경계를 설정하기 때문입니다. 기본 RoundNearest 반올림 모드에서, 만약 $y$가 실수이고 $x$가 $y$에 가장 가까운 부동 소수점 수라면,

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

또한: nextfloat, issubnormal, floatmax.

예제

julia> eps(1.0)
2.220446049250313e-16

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

julia> eps(2.0)
4.440892098500626e-16

julia> x = prevfloat(Inf)      # 가장 큰 유한 Float64
1.7976931348623157e308

julia> x + eps(x)/2            # 반올림하여 올림
Inf

julia> x + prevfloat(eps(x)/2) # 반올림하여 내림
1.7976931348623157e308

instances(T::Type)

주어진 타입의 모든 인스턴스 컬렉션을 반환합니다. 주로 열거형 타입에 사용됩니다(참조: @enum).

예제

julia> @enum Color red blue green

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

Any::DataType

Any는 모든 유형의 합집합입니다. 그것은 모든 x에 대해 isa(x, Any) == true라는 정의 속성을 가지고 있습니다. 따라서 Any는 가능한 값의 전체 우주를 설명합니다. 예를 들어 Integer는 Int, Int8 및 기타 정수 유형을 포함하는 Any의 하위 집합입니다.

Union{Types...}

Union 타입은 그 인수 타입의 모든 인스턴스를 포함하는 추상 타입입니다. 이는 T <: Union{T,S} 및 S <: Union{T,S}를 의미합니다.

다른 추상 타입과 마찬가지로, 모든 인수가 비추상적일지라도 인스턴스화할 수 없습니다.

예제

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

julia> 1 isa IntOrString # Int의 인스턴스는 유니온에 포함됩니다.
true

julia> "Hello!" isa IntOrString # String도 포함됩니다.
true

julia> 1.0 isa IntOrString # Float64는 Int도 AbstractString도 아니기 때문에 포함되지 않습니다.
false

추가 도움말

대부분의 다른 매개변수 타입과 달리, 유니온은 그 매개변수에 대해 공변적입니다. 예를 들어, Union{Real, String}은 Union{Number, AbstractString}의 하위 타입입니다.

빈 유니온 Union{}는 Julia의 바닥 타입입니다.

Union{}

Union{}, 빈 Union 타입은 값이 없는 타입입니다. 즉, x가 어떤 것이든 isa(x, Union{}) == false라는 정의 속성을 가집니다. Base.Bottom은 그 별칭으로 정의되며 Union{}의 타입은 Core.TypeofBottom입니다.

예제

julia> isa(nothing, Union{})
false

UnionAll

타입 매개변수의 모든 값에 대한 타입의 합집합입니다. UnionAll은 일부 매개변수의 값이 알려지지 않은 매개변수 타입을 설명하는 데 사용됩니다. UnionAll Types 섹션을 참조하십시오.

예제

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Tuple{Types...}

튜플은 서로 다른 유형의 값을 보유할 수 있는 고정 길이 컨테이너이지만 수정할 수는 없습니다(불변). 값은 인덱싱을 통해 접근할 수 있습니다. 튜플 리터럴은 쉼표와 괄호로 작성됩니다:

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

julia> (1,)
(1,)

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

julia> x[2]
"hello"

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

길이가 1인 튜플은 반드시 쉼표와 함께 작성해야 합니다, (1,), 왜냐하면 (1)은 단순히 괄호로 묶인 값이기 때문입니다. ()는 빈(길이 0) 튜플을 나타냅니다.

튜플은 생성자로 Tuple 유형을 사용하여 반복자에서 생성할 수 있습니다:

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

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

튜플 유형은 매개변수에서 공변적입니다: Tuple{Int}는 Tuple{Any}의 하위 유형입니다. 따라서 Tuple{Any}는 추상 유형으로 간주되며, 튜플 유형은 매개변수가 구체적일 때만 구체적입니다. 튜플은 필드 이름이 없으며, 필드는 인덱스를 통해서만 접근할 수 있습니다. 튜플 유형은 매개변수를 임의의 개수 가질 수 있습니다.

튜플 유형에 대한 매뉴얼 섹션을 참조하십시오.

또한 Vararg, NTuple, ntuple, tuple, NamedTuple를 참조하십시오.

NTuple{N, T}

길이가 N인 튜플의 타입을 나타내는 간결한 방법으로, 모든 요소는 타입 T입니다.

예시

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

또한 ntuple를 참조하세요.

NamedTuple

NamedTuple은 이름에서 알 수 있듯이 이름이 있는 Tuple입니다. 즉, 각 항목이 고유한 이름을 가지는 튜플과 유사한 값의 모음입니다. 이름은 Symbol으로 표현됩니다. Tuple과 마찬가지로 NamedTuple은 불변입니다. 즉, 생성 후에는 이름이나 값을 제자리에서 수정할 수 없습니다.

이름이 있는 튜플은 키가 있는 튜플 리터럴로 생성할 수 있습니다. 예를 들어 (a=1, b=2)와 같이 생성하거나, 여는 괄호 뒤에 세미콜론이 있는 튜플 리터럴로 생성할 수 있습니다. 예를 들어 (; a=1, b=2) (이 형식은 아래에 설명된 대로 프로그래밍적으로 생성된 이름도 허용합니다) 또는 생성자로 NamedTuple 유형을 사용할 수 있습니다. 예를 들어 NamedTuple{(:a, :b)}((1,2))와 같이 생성할 수 있습니다.

이름이 있는 튜플에서 이름과 연결된 값을 접근하는 것은 필드 접근 구문을 사용하여 수행할 수 있습니다. 예를 들어 x.a 또는 getindex를 사용하여 x[:a] 또는 x[(:a, :b)]와 같이 접근할 수 있습니다. 이름의 튜플은 keys를 사용하여 얻을 수 있으며, 값의 튜플은 values를 사용하여 얻을 수 있습니다.

@NamedTuple 매크로는 NamedTuple 유형을 편리하게 선언하는 데 사용할 수 있습니다.

예제

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

julia> x.a
1

julia> x[:a]
1

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

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

julia> values(x)
(1, 2)

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

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

키워드 인수를 프로그래밍적으로 정의하는 방식과 유사하게, 이름이 있는 튜플은 세미콜론 뒤에 name::Symbol => value 쌍을 제공하여 생성할 수 있습니다. 이와 name=value 구문은 혼합할 수 있습니다:

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

이름-값 쌍은 이름이 있는 튜플을 스플래팅하거나 각 기호를 첫 번째 값으로 가지는 두 값의 컬렉션을 생성하는 반복자를 사용하여 제공할 수도 있습니다:

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

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

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

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

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

julia> (; nt1..., nt2..., b=20) # 최종 b는 nt1의 값을 덮어씁니다
(a = 1, b = 20, c = 3, d = 4)

julia> (; zip(keys, values)...) # zip은 (:a, 1)과 같은 튜플을 생성합니다
(a = 1, b = 2, c = 3)

키워드 인수와 마찬가지로, 식별자와 점 표현식은 이름을 암시합니다:

julia> x = 0
0

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

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

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

이 매크로는 NamedTuple 타입을 선언하는 더 편리한 구문을 제공합니다. 주어진 키와 타입을 가진 NamedTuple 타입을 반환하며, 이는 NamedTuple{(:key1, :key2, ...), Tuple{Type1,Type2,...}}와 동등합니다. ::Type 선언이 생략되면 Any로 간주됩니다. begin ... end 형식은 선언을 여러 줄에 걸쳐 나눌 수 있게 해주며(구조체 선언과 유사), 그 외에는 동등합니다. NamedTuple 매크로는 NamedTuple 타입을 출력할 때 예를 들어 REPL에서 사용됩니다.

예를 들어, 튜플 (a=3.1, b="hello")는 타입 NamedTuple{(:a, :b), Tuple{Float64, String}}를 가지며, 이는 다음과 같이 @NamedTuple을 통해 선언할 수 있습니다:

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

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

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

이 매크로는 @NamedTuple와 동일한 구문에서 키워드 인수의 타입 표현을 구성하는 편리한 방법을 제공합니다. 예를 들어, func([positional arguments]; kw1=1.0, kw2="2")와 같은 함수 호출이 있을 때, 이 매크로를 사용하여 키워드 인수의 내부 타입 표현을 @Kwargs{kw1::Float64, kw2::String}으로 구성할 수 있습니다. 매크로 구문은 스택 추적 보기에서 인쇄될 때 키워드 메서드의 시그니처 타입을 단순화하도록 특별히 설계되었습니다.

julia> @Kwargs{init::Int} # 키워드 인수의 내부 표현
Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}

julia> sum("julia"; init=1)
ERROR: MethodError: no method matching +(::Char, ::Char)
함수 `+`는 존재하지만, 이 조합의 인수 타입에 대해 정의된 메서드는 없습니다.

가장 가까운 후보는:
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:585
  +(::Integer, ::AbstractChar)
   @ Base char.jl:247
  +(::T, ::Integer) where T<:AbstractChar
   @ Base char.jl:237

스택 추적:
  [1] add_sum(x::Char, y::Char)
    @ Base ./reduce.jl:24
  [2] BottomRF
    @ Base ./reduce.jl:86 [인라인]
  [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 [인라인]
  [5] mapfoldl_impl(f::typeof(identity), op::typeof(Base.add_sum), nt::Int64, itr::String)
    @ Base ./reduce.jl:44 [인라인]
  [6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64)
    @ Base ./reduce.jl:175 [인라인]
  [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:307 [인라인]
  [8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:535 [인라인]
  [9] sum(a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:564 [인라인]
 [10] 최상위 스코프
    @ REPL[12]:1

Val(c)

Val{c}()를 반환합니다. 이 객체는 런타임 데이터가 포함되어 있지 않습니다. 이러한 유형은 c 값을 통해 함수 간에 정보를 전달하는 데 사용할 수 있으며, c는 isbits 값 또는 Symbol이어야 합니다. 이 구조의 의도는 런타임에 상수의 값을 테스트하지 않고도 상수에 직접적으로 분기할 수 있도록 하는 것입니다.

예제

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

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

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

Vararg{T,N}

튜플 타입 Tuple의 마지막 매개변수는 특별한 값 Vararg일 수 있으며, 이는 임의의 수의 후행 요소를 나타냅니다. Vararg{T,N}은 정확히 N개의 T 타입 요소에 해당합니다. 마지막으로 Vararg{T}는 0개 이상의 T 타입 요소에 해당합니다. Vararg 튜플 타입은 가변 인수 메서드에서 허용되는 인수를 나타내는 데 사용됩니다(매뉴얼의 Varargs Functions 섹션 참조).

또한 NTuple를 참조하십시오.

예제

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

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

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

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

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

아무것도 없음

필드가 없는 타입으로, nothing의 타입입니다.

참고: isnothing, Some, Missing.

isnothing(x)

x === nothing이면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

또한 something, Base.notnothing, ismissing를 참조하세요.

notnothing(x)

x === nothing인 경우 오류를 발생시키고, 그렇지 않으면 x를 반환합니다.

Some{T}

Union{Some{T}, Nothing}에서 값의 부재(nothing)와 nothing 값의 존재(즉, Some(nothing))를 구분하는 데 사용되는 래퍼 타입입니다.

something를 사용하여 Some 객체에 의해 래핑된 값에 접근하세요.

something(x...)

인수 중 nothing과 같지 않은 첫 번째 값을 반환합니다. 그렇지 않으면 오류를 발생시킵니다. Some 유형의 인수는 언랩됩니다.

또한 coalesce, skipmissing, @something를 참조하십시오.

예제

julia> something(nothing, 1)
1

julia> something(Some(1), nothing)
1

julia> something(Some(nothing), 2) === nothing
true

julia> something(missing, nothing)
missing

julia> something(nothing, nothing)
ERROR: ArgumentError: No value arguments present

@something(x...)

something의 단축 회로 버전입니다.

예제

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

julia> a = 1;

julia> a = @something a f(2) f(3) error("Unable to find default for `a`")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("Unable to find default for `b`")
f(2)
f(3)
ERROR: Unable to find default for `b`
[...]

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

julia> b === nothing
true

Enum{T<:Integer}

@enum으로 정의된 모든 열거형의 추상 슈퍼타입입니다.

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

EnumName이라는 이름의 Enum{BaseType} 하위 유형을 생성하고, 선택적으로 할당된 값 x와 y를 가진 value1 및 value2의 열거형 멤버 값을 정의합니다. EnumName은 다른 유형과 마찬가지로 사용될 수 있으며, 열거형 멤버 값은 일반 값으로 사용될 수 있습니다. 예를 들어:

예시

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

julia> f(x::Fruit) = "I'm a Fruit with value: $(Int(x))"
f (generic function with 1 method)

julia> f(apple)
"I'm a Fruit with value: 1"

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

값은 begin 블록 안에서도 지정할 수 있습니다. 예를 들어:

@enum EnumName begin
    value1
    value2
end

기본값은 Int32인 BaseType은 Integer의 원시 하위 유형이어야 합니다. 멤버 값은 열거형 유형과 BaseType 간에 변환될 수 있습니다. read와 write는 이러한 변환을 자동으로 수행합니다. 비기본 BaseType으로 열거형이 생성된 경우, Integer(value1)은 BaseType 유형의 정수 value1을 반환합니다.

열거형의 모든 인스턴스를 나열하려면 instances를 사용합니다. 예를 들어:

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

열거형 인스턴스에서 기호를 구성하는 것도 가능합니다:

julia> Symbol(apple)
:apple

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

구문 분석된 줄리아 코드(AST)에서 복합 표현을 나타내는 유형입니다. 각 표현은 어떤 종류의 표현인지 식별하는 head Symbol(예: 호출, for 루프, 조건문 등)과 하위 표현(예: 호출의 인수)으로 구성됩니다. 하위 표현은 args라는 Vector{Any} 필드에 저장됩니다.

메타프로그래밍 장과 개발자 문서 줄리아 ASTs를 참조하세요.

예제

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

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

기호

구문 분석된 줄리아 코드 (AST)에서 식별자를 나타내는 데 사용되는 객체의 유형입니다. 또한 종종 엔터티를 식별하기 위한 이름이나 레이블로 사용됩니다 (예: 사전 키로). Symbol은 : 인용 연산자를 사용하여 입력할 수 있습니다:

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

Symbol은 문자열이나 다른 값을 사용하여 생성자 Symbol(x...)를 호출하여 생성할 수도 있습니다.

Symbol은 불변이며, 동일한 이름을 가진 모든 Symbol에 대해 동일한 객체를 재사용하는 방식으로 구현됩니다.

문자열과 달리, Symbol은 문자를 반복하는 것을 지원하지 않는 "원자" 또는 "스칼라" 엔터티입니다.

Symbol(x...) -> Symbol

인수의 문자열 표현을 함께 연결하여 Symbol를 생성합니다.

예제

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

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

모듈

모듈은 별도의 전역 변수 작업 공간입니다. 자세한 내용은 module 및 모듈에 대한 매뉴얼 섹션을 참조하십시오.

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

지정된 이름으로 모듈을 반환합니다. baremodule은 Module(:ModuleName, false)에 해당합니다.

이름이 전혀 없는 빈 모듈은 Module(:ModuleName, false, false)로 생성할 수 있습니다. 이 모듈은 Base 또는 Core를 가져오지 않으며 자신에 대한 참조를 포함하지 않습니다.

함수

모든 함수의 추상 유형입니다.

예제

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin) (함수 sin의 단일 유형, Function의 하위 유형)

julia> ans <: Function
true

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

주어진 제네릭 함수가 주어진 Tuple의 인수 유형과 일치하는 메서드를 가지고 있는지 확인합니다. 이때 world로 주어진 세계의 나이의 상한이 적용됩니다.

키워드 인수 이름의 튜플 kwnames가 제공되면, 이는 또한 f의 메서드가 t와 일치하는지와 주어진 키워드 인수 이름을 가지고 있는지 확인합니다. 일치하는 메서드가 가변 개수의 키워드 인수를 허용하는 경우, 예를 들어 kwargs...와 같이, kwnames에 주어진 이름은 유효한 것으로 간주됩니다. 그렇지 않으면 제공된 이름은 메서드의 키워드 인수의 부분 집합이어야 합니다.

자세한 내용은 applicable를 참조하십시오.

예제

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

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

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

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

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

julia> hasmethod(g, Tuple{}, (:a, :b, :c, :d))  # g는 임의의 kwargs를 허용합니다
true

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

주어진 일반 함수가 주어진 인수에 적용 가능한 메서드를 가지고 있는지 여부를 결정합니다.

자세한 내용은 hasmethod를 참조하십시오.

예제

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

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true

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

두 메서드 m1과 m2가 어떤 호출 서명에 대해 모호할 수 있는지 여부를 결정합니다. 이 테스트는 동일한 함수의 다른 메서드의 맥락에서 수행됩니다. 독립적으로 m1과 m2는 모호할 수 있지만, 모호성을 해결하는 세 번째 메서드가 정의되어 있다면, 이 함수는 false를 반환합니다. 또는 독립적으로 m1과 m2가 정렬될 수 있지만, 세 번째 메서드가 이들과 함께 정렬될 수 없다면, 이들은 함께 모호성을 초래할 수 있습니다.

매개변수 유형의 경우, ambiguous_bottom 키워드 인자는 Union{}가 유형 매개변수의 모호한 교차점으로 간주되는지 여부를 제어합니다. true일 때는 모호한 것으로 간주되고, false일 때는 그렇지 않습니다.

예제

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

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

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

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

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

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

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

주어진 제네릭 함수 f에 대해 지정된 타입 argtypes와 지정된 인수 args에 대해 일치하는 메서드를 호출하고 키워드 인수 kwargs를 전달합니다. 인수 args는 argtypes에 지정된 타입과 일치해야 하며, 즉 자동으로 변환되지 않습니다. 이 메서드는 가장 구체적인 일치 메서드가 아닌 다른 메서드를 호출할 수 있게 해주며, 이는 더 구체적인 메서드의 구현의 일부로서 더 일반적인 정의의 동작이 명시적으로 필요할 때 유용합니다.

작성하지 않은 함수에 대해 invoke를 사용할 때는 주의해야 합니다. 주어진 argtypes에 대해 어떤 정의가 사용되는지는 구현 세부 사항이며, 함수가 특정 argtypes로 호출하는 것이 공개 API의 일부라고 명시적으로 언급하지 않는 한 그렇습니다. 예를 들어, 아래 예제에서 f1과 f2 간의 변화는 일반적인 (비 invoke) 호출로는 호출자에게 보이지 않기 때문에 일반적으로 호환 가능한 것으로 간주됩니다. 그러나 invoke를 사용하면 변화가 보입니다.

예제

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

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

julia> f(2)
5

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

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

julia> f1(1)
Integer

julia> f2(1)
Integer

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

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

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

invoke를 호출하는 편리한 방법을 제공하며, @invoke f(arg1::T1, arg2::T2; kwargs...)를 invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...)로 확장합니다. 인수의 타입 주석이 생략되면, 해당 인수의 Core.Typeof으로 대체됩니다. 인수가 타입이 지정되지 않았거나 명시적으로 Any로 지정된 메서드를 호출하려면, 인수에 ::Any로 주석을 달아야 합니다.

다음 구문도 지원합니다:

• @invoke (x::X).f는 invoke(getproperty, Tuple{X,Symbol}, x, :f)로 확장됩니다.
• @invoke (x::X).f = v::V는 invoke(setproperty!, Tuple{X,Symbol,V}, x, :f, v)로 확장됩니다.
• @invoke (xs::Xs)[i::I]는 invoke(getindex, Tuple{Xs,I}, xs, i)로 확장됩니다.
• @invoke (xs::Xs)[i::I] = v::V는 invoke(setindex!, Tuple{Xs,V,I}, xs, v, i)로 확장됩니다.

예제

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

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

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

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

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

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

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

f(args...; kwargs...)를 호출하지만, f의 가장 최근 메서드가 실행되도록 보장합니다. 이는 오래 실행되는 이벤트 루프나 구식 버전의 함수 f를 호출할 수 있는 콜백 함수와 같은 특수한 상황에서 유용합니다. (단점은 invokelatest가 f를 직접 호출하는 것보다 다소 느리며, 결과의 타입을 컴파일러가 추론할 수 없다는 것입니다.)

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

invokelatest를 호출하는 편리한 방법을 제공합니다. @invokelatest f(args...; kwargs...)는 단순히 Base.invokelatest(f, args...; kwargs...)로 확장됩니다.

다음 구문도 지원합니다:

• @invokelatest x.f는 Base.invokelatest(getproperty, x, :f)로 확장됩니다.
• @invokelatest x.f = v는 Base.invokelatest(setproperty!, x, :f, v)로 확장됩니다.
• @invokelatest xs[i]는 Base.invokelatest(getindex, xs, i)로 확장됩니다.
• @invokelatest xs[i] = v는 Base.invokelatest(setindex!, xs, v, i)로 확장됩니다.

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

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

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

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

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

new, or new{A,B,...}

내부 생성자에게 제공되는 특수 함수로, 해당 유형의 새 객체를 생성합니다. 형식 new{A,B,...}는 매개변수 유형에 대한 매개변수 값들을 명시적으로 지정합니다. 자세한 내용은 내부 생성자 메서드 매뉴얼 섹션을 참조하십시오.

|>(x, f)

함수 f를 인수 x에 적용하는 중위 연산자입니다. 이를 통해 f(g(x))를 x |> g |> f로 쓸 수 있습니다. 익명 함수와 함께 사용할 때는 의도한 체인을 얻기 위해 정의 주위에 괄호가 일반적으로 필요합니다.

예제

julia> 4 |> inv
0.25

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

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

f ∘ g

함수 합성: 즉, (f ∘ g)(args...; kwargs...)는 f(g(args...; kwargs...))를 의미합니다. ∘ 기호는 Julia REPL(및 적절히 구성된 대부분의 편집기)에서 \circ<tab>를 입력하여 입력할 수 있습니다.

함수 합성은 접두사 형식에서도 작동합니다: ∘(f, g)는 f ∘ g와 동일합니다. 접두사 형식은 여러 함수의 합성을 지원합니다: ∘(f, g, h) = f ∘ g ∘ h 및 iterable 함수 모음을 합성하기 위한 ∘(fs...)를 지원합니다. ∘의 마지막 인수는 먼저 실행됩니다.

예제

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

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

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

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

자세한 내용은 ComposedFunction, !f::Function를 참조하세요.

ComposedFunction{Outer,Inner} <: Function

두 개의 호출 가능한 객체 outer::Outer와 inner::Inner의 조합을 나타냅니다. 즉,

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

ComposedFunction의 인스턴스를 구성하는 선호되는 방법은 조합 연산자 ∘를 사용하는 것입니다:

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

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

조합된 조각들은 ComposedFunction의 필드에 저장되며 다음과 같이 검색할 수 있습니다:

julia> composition = sin ∘ cos
sin ∘ cos

julia> composition.outer === sin
true

julia> composition.inner === cos
true

자세한 내용은 ∘를 참조하세요.

splat(f)

동일한 의미는

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

즉, 주어진 함수를 원래 함수에 스플랫하는 하나의 인수를 받는 새로운 함수를 반환합니다. 이는 다중 인수 함수를 단일 인수를 기대하는 컨텍스트에 전달하기 위한 어댑터로 유용하지만, 그 단일 인수로 튜플을 전달합니다.

예제

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

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

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

Fix1(f, x)

두 개의 인수를 가지는 함수 f의 부분 적용 버전을 나타내는 타입으로, 첫 번째 인수가 값 "x"로 고정됩니다. 다시 말해, Fix1(f, x)는 y->f(x, y)와 유사하게 동작합니다.

또한 Fix2를 참조하세요.

Fix2(f, x)

두 개의 인수를 가지는 함수 f의 부분 적용 버전을 나타내는 타입으로, 두 번째 인수는 값 "x"로 고정됩니다. 다시 말해, Fix2(f, x)는 y->f(y, x)와 유사하게 동작합니다.

Core.eval(m::Module, expr)

주어진 모듈에서 표현식을 평가하고 결과를 반환합니다.

eval(expr)

포함된 모듈의 전역 범위에서 표현식을 평가합니다. 모든 Module( baremodule로 정의된 것을 제외하고)은 해당 모듈에서 표현식을 평가하는 1-인수 정의의 eval을 가지고 있습니다.

@eval [mod,] ex

eval을 사용하여 값이 주입된 표현식을 평가합니다. 두 개의 인수가 제공되면 첫 번째 인수는 평가할 모듈입니다.

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

파일을 익명 모듈에 로드하고 include를 사용하여 모든 표현식을 평가한 후 마지막 표현식의 값을 반환합니다. 선택적 args 인수는 스크립트의 입력 인수(즉, 전역 ARGS 변수)를 설정하는 데 사용할 수 있습니다. 정의(예: 메서드, 전역 변수)는 익명 모듈에서 평가되며 현재 모듈에 영향을 미치지 않습니다.

예제

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

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

julia> x
2

julia> rm("testfile.jl")

esc(e)

매크로에서 반환된 Expr의 맥락에서만 유효합니다. 매크로 위생 패스가 내장 변수를 gensym 변수로 변환하는 것을 방지합니다. 더 많은 세부정보와 예제는 매뉴얼의 메타프로그래밍 장의 매크로 섹션을 참조하십시오.

@inbounds(blk)

표현식 내에서 배열 경계 검사를 제거합니다.

아래 예제에서는 배열 A의 요소 i를 참조하기 위한 범위 내 검사가 생략되어 성능이 향상됩니다.

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

!!! 경고 @inbounds를 사용하면 경계 밖의 인덱스에 대해 잘못된 결과/충돌/손상이 발생할 수 있습니다. 사용자는 이를 수동으로 확인할 책임이 있습니다. 모든 접근이 경계 내에 있다는 것이 지역적으로 사용 가능한 정보로부터 확실할 때만 @inbounds를 사용하십시오. 특히, 위와 같은 함수에서 eachindex(A) 대신 1:length(A)를 사용하는 것은 안전하게 경계 내에 있지 않습니다 왜냐하면 A의 첫 번째 인덱스가 AbstractArray를 서브타입으로 하는 모든 사용자 정의 유형에 대해 항상 1이 아닐 수 있기 때문입니다.

@boundscheck(blk)

표현식 blk를 경계 검사 블록으로 주석 처리하여 @inbounds에 의해 생략될 수 있도록 합니다.

예제

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

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

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

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

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

@propagate_inbounds

컴파일러에게 호출자의 inbounds 컨텍스트를 유지하면서 함수를 인라인하도록 지시합니다.

@inline

컴파일러에게 이 함수가 인라인으로 처리될 가치가 있음을 힌트합니다.

작은 함수는 일반적으로 @inline 주석이 필요하지 않으며, 컴파일러가 자동으로 처리합니다. 더 큰 함수에 @inline을 사용하면 컴파일러에게 인라인으로 처리하도록 추가적인 자극을 줄 수 있습니다.

@inline은 함수 정의 바로 앞이나 함수 본문 내에서 적용할 수 있습니다.

# 긴 정의에 주석 추가
@inline function longdef(x)
    ...
end

# 짧은 정의에 주석 추가
@inline shortdef(x) = ...

# `do` 블록이 생성하는 익명 함수에 주석 추가
f() do
    @inline
    ...
end

@inline block

block 내의 호출이 인라인으로 처리될 가치가 있음을 컴파일러에게 힌트합니다.

# 컴파일러는 `f`를 인라인으로 처리하려고 시도할 것입니다.
@inline f(...)

# 컴파일러는 `f`, `g` 및 `+`를 인라인으로 처리하려고 시도할 것입니다.
@inline f(...) + g(...)

@noinline function explicit_noinline(args...)
    # 본문
end

let
    @inline explicit_noinline(args...) # 인라인으로 처리될 것입니다.
end

@noinline let a0, b0 = ...
    a = @inline f(a0)  # 컴파일러는 이 호출을 인라인으로 처리하려고 시도할 것입니다.
    b = f(b0)          # 컴파일러는 이 호출을 인라인으로 처리하지 않을 것입니다.
    return a, b
end

@noinline

컴파일러에게 함수를 인라인하지 말라는 힌트를 제공합니다.

작은 함수는 일반적으로 자동으로 인라인됩니다. 작은 함수에 @noinline을 사용하면 자동 인라인을 방지할 수 있습니다.

@noinline은 함수 정의 바로 앞이나 함수 본문 내에서 적용할 수 있습니다.

# 긴 정의 주석 달기
@noinline function longdef(x)
    ...
end

# 짧은 정의 주석 달기
@noinline shortdef(x) = ...

# `do` 블록이 생성하는 익명 함수 주석 달기
f() do
    @noinline
    ...
end

@noinline block

컴파일러에게 block 내의 호출을 인라인하지 말라는 힌트를 제공합니다.

# 컴파일러는 `f`를 인라인하지 않으려고 할 것입니다.
@noinline f(...)

# 컴파일러는 `f`, `g` 및 `+`를 인라인하지 않으려고 할 것입니다.
@noinline f(...) + g(...)

@inline function explicit_inline(args...)
    # 본문
end

let
    @noinline explicit_inline(args...) # 인라인되지 않을 것입니다.
end

@inline let a0, b0 = ...
    a = @noinline f(a0)  # 컴파일러는 이 호출을 인라인하지 않으려고 할 것입니다.
    b = f(b0)            # 컴파일러는 이 호출을 인라인하려고 할 것입니다.
    return a, b
end

@nospecialize

함수 인수 이름에 적용되면, 컴파일러에게 해당 인수의 다양한 유형에 대해 메서드 구현이 특수화되지 않고, 대신 해당 인수에 대해 선언된 유형을 사용해야 함을 힌트합니다. 이는 형식 인수 목록 내의 인수나 함수 본문 내에서 적용될 수 있습니다. 인수에 적용될 때, 매크로는 전체 인수 표현을 감싸야 하며, 예를 들어 @nospecialize(x::Real) 또는 @nospecialize(i::Integer...)와 같이 인수 이름만 감싸는 것이 아니라 전체를 감싸야 합니다. 함수 본문에서 사용될 때, 매크로는 문장 위치에 있어야 하며, 어떤 코드보다 먼저 나타나야 합니다.

인수 없이 사용될 경우, 이는 부모 범위의 모든 인수에 적용됩니다. 로컬 범위에서는 이는 포함된 함수의 모든 인수를 의미합니다. 글로벌(최상위) 범위에서는 이는 현재 모듈에서 이후에 정의된 모든 메서드를 의미합니다.

특수화는 @specialize를 사용하여 기본값으로 재설정할 수 있습니다.

function example_function(@nospecialize x)
    ...
end

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

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

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

예제

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

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

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

여기서 @nospecialize 주석은 다음과 동등한 결과를 생성합니다.

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

이는 g에 대해 하나의 네이티브 코드 버전만 생성되도록 보장하며, 이는 모든 AbstractArray에 대해 일반적입니다. 그러나 특정 반환 유형은 여전히 g와 f 모두에 대해 추론되며, 이는 여전히 f와 g의 호출자를 최적화하는 데 사용됩니다.

@specialize

인수에 대한 특수화 힌트를 기본값으로 재설정합니다. 자세한 내용은 @nospecialize를 참조하십시오.

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

컴파일러에게 @nospecialize된 인수의 선언된 유형을 사용하여 f를 추론하도록 지시합니다. 이는 추론 중에 컴파일러가 생성하는 특수화의 수를 제한하는 데 사용할 수 있습니다.

예제

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

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

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

이 예제에서 f는 A의 각 특정 유형에 대해 추론되지만, g는 선언된 인수 유형 A::AbstractArray로 한 번만 추론됩니다. 이는 컴파일러가 그것에 대한 과도한 추론 시간을 보지 않을 가능성이 높다는 것을 의미합니다. @nospecializeinfer 없이 f([1.0])는 g의 반환 유형을 Float64로 추론하게 되며, 이는 특수화된 코드 생성을 금지했음에도 불구하고 g(::Vector{Float64})에 대해 추론이 실행되었음을 나타냅니다.

Base.@constprop 설정 [ex]

주석이 달린 함수에 대한 절차 간 상수 전파 모드를 제어합니다.

두 가지 설정이 지원됩니다:

• Base.@constprop :aggressive [ex]: 상수 전파를 공격적으로 적용합니다. 반환 유형이 인수의 값에 따라 달라지는 메서드의 경우, 추가 컴파일 시간의 대가로 향상된 추론 결과를 얻을 수 있습니다.
• Base.@constprop :none [ex]: 상수 전파를 비활성화합니다. 이는 Julia가 그렇지 않으면 상수 전파에 적합하다고 판단할 수 있는 함수의 컴파일 시간을 줄일 수 있습니다. 일반적인 경우는 Bool 또는 Symbol 값의 인수 또는 키워드 인수를 가진 함수입니다.

Base.@constprop는 함수 정의 바로 앞이나 함수 본문 내에서 적용할 수 있습니다.

# 장황한 정의 주석 달기
Base.@constprop :aggressive function longdef(x)
    ...
end

# 간단한 정의 주석 달기
Base.@constprop :aggressive shortdef(x) = ...

# `do` 블록이 생성하는 익명 함수 주석 달기
f() do
    Base.@constprop :aggressive
    ...
end

gensym([tag])

다른 변수 이름(같은 모듈 내)과 충돌하지 않는 기호를 생성합니다.

@gensym

변수에 대한 gensym 기호를 생성합니다. 예를 들어, @gensym x y는 x = gensym("x"); y = gensym("y")로 변환됩니다.

var

구문 var"#example#"는 Symbol("#example#")라는 이름의 변수를 참조하며, #example#는 유효한 Julia 식별자 이름이 아닙니다.

이는 유효한 식별자 구성에 대한 규칙이 다른 프로그래밍 언어와의 상호 운용성에 유용할 수 있습니다. 예를 들어, R 변수 draw.segments를 참조하려면 Julia 코드에서 var"draw.segments"를 사용할 수 있습니다.

이 구문은 매크로 위생을 거쳤거나 일반적으로 구문 분석할 수 없는 변수 이름을 포함하는 Julia 소스 코드를 show하는 데에도 사용됩니다.

이 구문은 파서 지원이 필요하므로 일반 문자열 매크로 @var_str로 구현되는 것이 아니라 파서에 의해 직접 확장됩니다.

@goto name

@goto name는 @label name 위치의 문으로 무조건 점프합니다.

@label과 @goto는 서로 다른 최상위 문으로 점프를 생성할 수 없습니다. 시도할 경우 오류가 발생합니다. 여전히 @goto를 사용하려면 @label과 @goto를 블록으로 감싸야 합니다.

@label name

name이라는 기호 레이블로 문장을 레이블 지정합니다. 이 레이블은 @goto name으로 무조건 점프의 끝점을 표시합니다.

@simd

@simd for 루프에서 반복되는 객체는 일차원 범위여야 합니다. @simd를 사용함으로써 루프의 여러 속성을 주장하는 것입니다:

• 반복을 임의의 순서나 겹치는 순서로 실행하는 것이 안전하며, 축소 변수에 대한 특별한 고려가 필요합니다.
• 축소 변수에 대한 부동 소수점 연산은 재배치되거나 축약될 수 있으며, 이는 @simd 없이와는 다른 결과를 초래할 수 있습니다.

많은 경우, Julia는 @simd 없이도 내부 for 루프를 자동으로 벡터화할 수 있습니다. @simd를 사용하면 컴파일러가 더 많은 상황에서 가능하도록 약간의 여유를 제공합니다. 어떤 경우든, 내부 루프는 벡터화를 허용하기 위해 다음과 같은 속성을 가져야 합니다:

• 루프는 가장 안쪽 루프여야 합니다.
• 루프 본문은 직선 코드여야 합니다. 따라서, 모든 배열 접근에 대해 현재 @inbounds가 필요합니다. 컴파일러는 때때로 짧은 &&, ||, 및 ?: 표현식을 모든 피연산자를 무조건적으로 평가하는 것이 안전할 경우 직선 코드로 변환할 수 있습니다. 안전하다면 루프에서 ?: 대신 ifelse 함수를 사용하는 것을 고려하세요.
• 접근은 보폭 패턴을 가져야 하며 "모으기" (무작위 인덱스 읽기)나 "흩뿌리기" (무작위 인덱스 쓰기)가 될 수 없습니다.
• 보폭은 단위 보폭이어야 합니다.

• 루프에 의해 전달되는 메모리 의존성이 존재하지 않습니다.
• 어떤 반복도 이전 반복이 진행되기를 기다리지 않습니다.

@polly

컴파일러에게 함수에 폴리헤드럴 최적화기 Polly를 적용하라고 지시합니다.

@generated f

@generated는 생성될 함수를 주석 처리하는 데 사용됩니다. 생성된 함수의 본문에서는 인수의 타입만 읽을 수 있으며(값은 읽을 수 없음), 함수는 호출될 때 평가되는 인용된 표현식을 반환합니다. @generated 매크로는 전역 범위를 변경하거나 변경 가능한 요소에 의존하는 함수에는 사용해서는 안 됩니다.

자세한 내용은 메타프로그래밍을 참조하세요.

예제

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

julia> bar(4)
16

julia> bar("baz")
"baz"

Base.@assume_effects 설정... [ex]

컴파일러의 효과 모델링을 재정의합니다. 이 매크로는 여러 맥락에서 사용할 수 있습니다:

1. 메서드 정의 직전에, 적용된 메서드의 전체 효과 모델링을 재정의합니다.
2. 인수가 없는 함수 본문 내에서, 포함된 메서드의 전체 효과 모델링을 재정의합니다.
3. 코드 블록에 적용하여, 적용된 코드 블록의 로컬 효과 모델링을 재정의합니다.

예제

julia> Base.@assume_effects :terminates_locally function fact(x)
           # 사용 1:
           # 이 :terminates_locally는 `fact`가 상수 접기(constant-folding)될 수 있도록 허용합니다.
           res = 1
           0 ≤ x < 20 || error("잘못된 팩토리얼")
           while x > 1
               res *= x
               x -= 1
           end
           return res
       end
fact (generic function with 1 method)

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

julia> code_typed() do
           map((2,3,4)) do x
               # 사용 2:
               # 이 :terminates_locally는 이 익명 함수가 상수 접기될 수 있도록 허용합니다.
               Base.@assume_effects :terminates_locally
               res = 1
               0 ≤ x < 20 || error("잘못된 팩토리얼")
               while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

julia> code_typed() do
           map((2,3,4)) do x
               res = 1
               0 ≤ x < 20 || error("잘못된 팩토리얼")
               # 사용 3:
               # 이 :terminates_locally 주석이 있으면 컴파일러가
               # 이 `while` 블록 내에서 `:terminates` 효과를 오염시키지 않도록 하여
               # 부모 익명 함수가 상수 접기될 수 있도록 허용합니다.
               Base.@assume_effects :terminates_locally while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

일반적으로 각 setting 값은 함수의 동작에 대한 주장을 하며, 컴파일러가 이 동작이 실제로 참인지 증명할 필요는 없습니다. 이러한 주장은 모든 세계 연령에 대해 이루어집니다. 따라서 나중에 가정이 무효화될 수 있는 일반 함수를 사용하는 것을 제한하는 것이 좋습니다(이는 정의되지 않은 동작을 초래할 수 있습니다).

다음 setting이 지원됩니다.

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

확장 도움말

:consistent

:consistent 설정은 동등(===)한 입력에 대해 다음을 주장합니다:

• 종료 방식(반환 값, 예외, 비종료)은 항상 동일합니다.
• 메서드가 반환하는 경우 결과는 항상 동등합니다.

:effect_free

:effect_free 설정은 메서드가 외부에서 의미적으로 가시적인 부작용이 없음을 주장합니다. 다음은 외부에서 의미적으로 가시적인 부작용의 불완전한 목록입니다:

• 전역 변수의 값 변경.
• 힙의 변형(예: 배열 또는 가변 값), 아래에 언급된 경우를 제외하고
• 메서드 테이블 변경(예: eval 호출을 통해)
• 파일/네트워크 등 I/O
• 작업 전환

그러나 다음은 명시적으로 의미적으로 가시적이지 않으며, 관찰 가능할 수 있습니다:

• 메모리 할당(가변 및 불변 모두)
• 경과 시간
• 가비지 수집
• 메서드의 수명보다 짧은 객체의 힙 변형(즉, 메서드 내에서 할당되고 탈출하지 않음).
• 반환된 값(외부에서 가시적이지만 부작용이 아님)

여기서의 경험 법칙은 외부에서 가시적인 부작용은 함수가 실행되지 않았을 경우 프로그램의 나머지 실행에 영향을 미치는 모든 것입니다.

:nothrow

:nothrow 설정은 이 메서드가 예외를 던지지 않음을 주장합니다(즉, 항상 값을 반환하거나 결코 반환하지 않음).

:terminates_globally

:terminates_globally 설정은 이 메서드가 결국 종료됨(정상적으로 또는 비정상적으로)을 주장합니다. 즉, 무한 루프에 빠지지 않습니다.

:terminates_locally

:terminates_locally 설정은 :terminates_globally와 유사하지만, 주석이 달린 메서드 내의 구문적 제어 흐름에만 적용됩니다. 따라서 이는 메서드가 종료되지 않는 다른 메서드를 호출할 가능성을 허용하는 훨씬 약한(따라서 더 안전한) 주장입니다.

:notaskstate

:notaskstate 설정은 메서드가 로컬 작업 상태(작업 로컬 저장소, RNG 상태 등)를 사용하거나 수정하지 않음을 주장하며, 따라서 관찰 가능한 결과 없이 작업 간에 안전하게 이동할 수 있습니다.

:inaccessiblememonly

:inaccessiblememonly 설정은 메서드가 외부에서 접근 가능한 가변 메모리에 접근하거나 수정하지 않음을 주장합니다. 이는 메서드가 반환 전 다른 메서드나 최상위 실행에서 접근할 수 없는 새로 할당된 객체의 가변 메모리에 접근하거나 수정할 수 있지만, 전역 상태나 인수로 전달된 가변 메모리에 접근하거나 수정할 수 없음을 의미합니다.

:noub

:noub 설정은 메서드가 정의되지 않은 동작을 실행하지 않음을 주장합니다(모든 입력에 대해). 정의되지 않은 동작은 기술적으로 메서드가 다른 효과 주장을 위반하게 만들 수 있지만(:consistent 또는 :effect_free와 같은), 우리는 이를 모델링하지 않으며 정의되지 않은 동작이 없다고 가정합니다.

:nortcall

:nortcall 설정은 메서드가 Core.Compiler.return_type를 호출하지 않으며, 이 메서드가 호출할 수 있는 다른 모든 메서드도 Core.Compiler.return_type를 호출하지 않음을 주장합니다.

:foldable

이 설정은 컴파일 시간에 호출을 상수 접기(constant fold)하기 위해 컴파일러가 보장해야 하는 효과 집합에 대한 편리한 단축키입니다. 현재 다음 setting과 동등합니다:

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

:removable

이 설정은 컴파일 시간에 결과가 사용되지 않는 호출을 삭제하기 위해 컴파일러가 보장해야 하는 효과 집합에 대한 편리한 단축키입니다. 현재 다음 setting과 동등합니다:

• :effect_free
• :nothrow
• :terminates_globally

:total

이 setting은 가능한 최대 효과 집합입니다. 현재 다음 다른 setting을 포함합니다:

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

부정된 효과

효과 이름은 !로 접두어를 붙여 이전 메타 효과에서 효과를 제거해야 함을 나타낼 수 있습니다. 예를 들어, :total !:nothrow는 호출이 일반적으로 전체적이지만, 예외를 던질 수 있음을 나타냅니다.

@deprecate old new [export_old=true]

메서드 old를 사용 중단하고 대체 호출 new를 지정하며, 이 과정에서 지정된 시그니처로 새로운 메서드 old를 정의합니다.

old가 내보내지 않도록 하려면 export_old를 false로 설정합니다.

자세한 내용은 Base.depwarn()를 참조하세요.

예제

julia> @deprecate old(x) new(x)
old (generic function with 1 method)

julia> @deprecate old(x) new(x) false
old (generic function with 1 method)

명시적인 타입 주석 없이 @deprecate를 호출하면 Any 타입의 위치 인수와 키워드 인수를 허용하는 사용 중단된 메서드가 정의됩니다.

특정 시그니처로 사용 중단을 제한하려면 old의 인수를 주석으로 달아야 합니다. 예를 들어,

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

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

julia> @deprecate old(x::Int) new(x);

julia> methods(old)
# 1 method for generic function "old" from Main:
 [1] old(x::Int64)
     @ deprecated.jl:94

이는 new(x::Int)을 반영하는 old(x::Int)라는 메서드를 정의하고 사용 중단하지만, old(x::Float64) 메서드는 정의하거나 사용 중단하지 않습니다.

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

msg를 비추천 경고로 출력합니다. 기호 funcsym은 호출 함수의 이름이어야 하며, 이는 각 호출 위치에 대해 비추천 경고가 처음 한 번만 출력되도록 보장하는 데 사용됩니다. force=true로 설정하면 Julia가 --depwarn=no(기본값)로 시작되었더라도 경고가 항상 표시되도록 강제합니다.

자세한 내용은 @deprecate를 참조하세요.

예제

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

    1 + 1
end

누락

필드가 없는 타입으로, 그 단일 인스턴스 missing는 누락된 값을 나타내는 데 사용됩니다.

참고: skipmissing, nonmissingtype, Nothing.

missing

타입 Missing의 단일 인스턴스로, 누락된 값을 나타냅니다.

참고: NaN, skipmissing, nonmissingtype.

coalesce(x...)

인수 중에서 missing과 같지 않은 첫 번째 값을 반환합니다. 만약 그런 값이 없다면 missing을 반환합니다.

또한 skipmissing, something, @coalesce도 참조하세요.

예제

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # `nothing`을 반환합니다.

julia> coalesce(missing, missing)
missing

@coalesce(x...)

단축 평가 버전의 coalesce.

예제

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

julia> a = 1;

julia> a = @coalesce a f(2) f(3) error("`a`는 여전히 누락되었습니다")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b`는 여전히 누락되었습니다")
f(2)
f(3)
ERROR: `b`는 여전히 누락되었습니다
[...]

ismissing(x)

x가 missing인지 여부를 나타냅니다.

참고: skipmissing, isnothing, isnan.

skipmissing(itr)

itr의 요소를 반복하면서 missing 값을 건너뛰는 반복기를 반환합니다. 반환된 객체는 itr의 인덱스를 사용하여 인덱싱할 수 있으며, 후자가 인덱스 가능할 경우에 해당합니다. 누락된 값에 해당하는 인덱스는 유효하지 않으며, keys 및 eachindex에 의해 건너뛰어지고, 이를 사용하려고 할 때 MissingException이 발생합니다.

collect를 사용하여 itr에서 비-missing 값을 포함하는 Array를 얻을 수 있습니다. itr이 다차원 배열인 경우에도 결과는 항상 Vector가 되며, 입력의 차원을 유지하면서 누락된 값을 제거하는 것은 불가능합니다.

또한 coalesce, ismissing, something도 참조하십시오.

예제

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

julia> sum(x)
3

julia> x[1]
1

julia> x[2]
ERROR: MissingException: the value at index (2,) is missing
[...]

julia> argmax(x)
3

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

julia> collect(skipmissing([1, missing, 2]))
2-element Vector{Int64}:
 1
 2

julia> collect(skipmissing([1 missing; 2 missing]))
2-element Vector{Int64}:
 1
 2

nonmissingtype(T::Type)

T가 Missing을 포함하는 타입의 유니온인 경우, Missing이 제거된 새로운 타입을 반환합니다.

예시

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

julia> nonmissingtype(Any)
Any

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

백틱으로 구성된 명령 객체를 실행합니다(매뉴얼의 외부 프로그램 실행하기 섹션을 참조). wait가 true일 때 프로세스가 비정상적으로 종료되거나 다른 문제가 발생하면 오류를 발생시킵니다.

args...를 사용하면 명령에 파일 설명자를 전달할 수 있으며, 일반 유닉스 파일 설명자와 같은 순서로 정렬됩니다(예: stdin, stdout, stderr, FD(3), FD(4)...).

wait가 false인 경우 프로세스는 비동기적으로 실행됩니다. 나중에 반환된 프로세스 객체에서 success를 호출하여 프로세스를 기다리고 종료 상태를 확인할 수 있습니다.

wait가 false인 경우 프로세스의 I/O 스트림은 devnull로 향합니다. wait가 true인 경우 I/O 스트림은 부모 프로세스와 공유됩니다. I/O 리디렉션을 제어하려면 pipeline를 사용하세요.

devnull

스트림 리디렉션에서 사용되어 여기에 기록된 모든 데이터를 버립니다. 본질적으로 Unix의 /dev/null 또는 Windows의 NUL과 동등합니다. 사용법:

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

success(command)

백틱으로 구성된 명령 객체를 실행하고(매뉴얼의 외부 프로그램 실행 섹션 참조), 성공 여부(코드 0으로 종료됨)를 알려줍니다. 프로세스를 시작할 수 없는 경우 예외가 발생합니다.

process_running(p::Process)

프로세스가 현재 실행 중인지 확인합니다.

process_exited(p::Process)

프로세스가 종료되었는지 확인합니다.

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

프로세스에 신호를 보냅니다. 기본값은 프로세스를 종료하는 것입니다. 프로세스가 이미 종료된 경우 성공적으로 반환되지만, 프로세스를 종료하는 데 실패한 경우(예: 권한 부족) 오류를 발생시킵니다.

Sys.set_process_title(title::AbstractString)

프로세스 제목을 설정합니다. 일부 운영 체제에서는 아무 작업도 수행하지 않습니다.

Sys.get_process_title()

프로세스 제목을 가져옵니다. 일부 시스템에서는 항상 빈 문자열을 반환합니다.

ignorestatus(command)

명령어 객체를 표시하여 결과 코드가 0이 아닐 경우 실행 시 오류를 발생시키지 않도록 합니다.

detach(command)

명령 객체를 표시하여 새로운 프로세스 그룹에서 실행되도록 하여 줄리아 프로세스보다 오래 살아남을 수 있게 하고, Ctrl-C 인터럽트가 전달되지 않도록 합니다.

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

새로운 Cmd 객체를 생성하여 외부 프로그램과 인수를 나타내며, 선택적 키워드 인수의 설정을 변경합니다:

• ignorestatus::Bool: true인 경우(기본값은 false), Cmd는 반환 코드가 0이 아닐 경우 오류를 발생시키지 않습니다.
• detach::Bool: true인 경우(기본값은 false), Cmd는 새로운 프로세스 그룹에서 실행되어 julia 프로세스보다 오래 살아남을 수 있으며, Ctrl-C가 전달되지 않습니다.
• windows_verbatim::Bool: true인 경우(기본값은 false), Windows에서 Cmd는 인수에 대한 인용이나 이스케이프 없이 프로세스에 명령줄 문자열을 보냅니다. (Windows에서는 인수가 프로그램에 단일 "명령줄" 문자열로 전송되며, 프로그램은 이를 인수로 구문 분석하는 책임이 있습니다. 기본적으로 빈 인수와 공백 또는 탭이 포함된 인수는 명령줄에서 큰따옴표 "로 인용되며, \ 또는 "는 백슬래시로 앞에 붙습니다. windows_verbatim=true는 비표준 방식으로 명령줄을 구문 분석하는 프로그램을 실행하는 데 유용합니다.) 비-Windows 시스템에는 영향을 미치지 않습니다.
• windows_hide::Bool: true인 경우(기본값은 false), Windows에서 Cmd가 실행될 때 새로운 콘솔 창이 표시되지 않습니다. 이미 콘솔이 열려 있거나 비-Windows 시스템에서는 영향을 미치지 않습니다.
• env: Cmd를 실행할 때 사용할 환경 변수를 설정합니다. env는 문자열을 문자열에 매핑하는 사전, "var=val" 형식의 문자열 배열, "var"=>val 쌍의 배열 또는 튜플일 수 있습니다. 기존 환경을 수정(대체가 아닌)하려면 env를 copy(ENV)로 초기화한 다음 원하는 대로 env["var"]=val을 설정합니다. 모든 요소를 대체하지 않고 Cmd 객체 내의 환경 블록에 추가하려면 addenv()를 사용하여 업데이트된 환경을 가진 Cmd 객체를 반환합니다.
• dir::AbstractString: 명령을 위한 작업 디렉토리를 지정합니다(현재 디렉토리 대신).

지정되지 않은 키워드에 대해서는 cmd의 현재 설정이 사용됩니다.

Cmd(exec) 생성자는 exec의 복사본을 생성하지 않는다는 점에 유의하십시오. exec에 대한 이후 변경 사항은 Cmd 객체에 반영됩니다.

Cmd 객체를 생성하는 가장 일반적인 방법은 명령 리터럴(백틱)을 사용하는 것입니다. 예를 들어:

`ls -l`

이것은 Cmd 생성자에 전달되어 설정을 수정할 수 있습니다. 예를 들어:

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

setenv(command::Cmd, env; dir)

주어진 command를 실행할 때 사용할 환경 변수를 설정합니다. env는 문자열을 문자열에 매핑하는 사전, "var=val" 형식의 문자열 배열, 또는 하나 이상의 "var"=>val 쌍 인수일 수 있습니다. 기존 환경을 수정(대신 교체)하려면 copy(ENV)를 통해 env를 생성한 다음 원하는 대로 env["var"]=val을 설정하거나 addenv를 사용하십시오.

dir 키워드 인수는 명령의 작업 디렉토리를 지정하는 데 사용할 수 있습니다. dir은 기본적으로 command에 대해 현재 설정된 dir(지정되지 않은 경우 현재 작업 디렉토리)을 사용합니다.

또한 Cmd, addenv, ENV, pwd를 참조하십시오.

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

주어진 Cmd 객체에 새로운 환경 매핑을 병합하여 새로운 Cmd 객체를 반환합니다. 중복된 키는 대체됩니다. command에 이미 설정된 환경 값이 없으면, inherit가 true인 경우 addenv() 호출 시점의 현재 환경을 상속받습니다. 값이 nothing인 키는 환경에서 삭제됩니다.

또한 Cmd, setenv, ENV를 참조하세요.

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

f를 임시로 수정된 환경에서 실행합니다( setenv와 같이 교체되지 않음) "var"=>val 인수 kv가 0개 이상입니다. withenv는 일반적으로 withenv(kv...) do ... end 구문을 통해 사용됩니다. nothing 값을 사용하여 환경 변수를 임시로 해제할 수 있습니다(설정된 경우). withenv가 반환되면 원래 환경이 복원됩니다.

!!! 경고 환경을 변경하는 것은 스레드 안전하지 않습니다. 부모 프로세스와 다른 환경에서 외부 명령을 실행하려면 withenv보다 addenv를 사용하는 것이 좋습니다.

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

command의 CPU 친화성을 CPU ID 목록(1 기반) cpus로 설정합니다. cpus = nothing을 전달하면 original_command에 CPU 친화성이 설정되어 있는 경우 이를 해제합니다.

이 함수는 Linux와 Windows에서만 지원됩니다. macOS에서는 libuv가 친화성 설정을 지원하지 않기 때문에 지원되지 않습니다.

예제

Linux에서는 taskset 명령줄 프로그램을 사용하여 setcpuaffinity가 어떻게 작동하는지 확인할 수 있습니다.

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

마스크 값 13은 첫 번째, 두 번째 및 다섯 번째 비트(가장 덜 중요한 위치에서 계산)가 켜져 있음을 반영합니다:

julia> 0b010011
0x13

pipeline(from, to, ...)

데이터 소스에서 목적지로 파이프라인을 생성합니다. 소스와 목적지는 명령, I/O 스트림, 문자열 또는 다른 pipeline 호출의 결과일 수 있습니다. 최소한 하나의 인자는 명령이어야 합니다. 문자열은 파일 이름을 나타냅니다. 두 개 이상의 인자로 호출될 때, 왼쪽에서 오른쪽으로 연결됩니다. 예를 들어, pipeline(a,b,c)는 pipeline(pipeline(a,b),c)와 동일합니다. 이는 다단계 파이프라인을 지정하는 더 간결한 방법을 제공합니다.

예제:

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

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

주어진 command로부터 I/O를 리디렉션합니다. 키워드 인자는 어떤 명령의 스트림이 리디렉션되어야 하는지를 지정합니다. append는 파일 출력이 파일에 추가되는지를 제어합니다. 이는 2-인자 pipeline 함수의 더 일반적인 버전입니다. pipeline(from, to)는 from이 명령일 때 pipeline(from, stdout=to)와 동등하며, from이 다른 종류의 데이터 소스일 때는 pipeline(to, stdin=from)과 동등합니다.

예제:

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

gethostname() -> String

로컬 머신의 호스트 이름을 가져옵니다.

getpid() -> Int32

줄리아의 프로세스 ID를 가져옵니다.

getpid(process) -> Int32

자식 프로세스 ID를 가져옵니다. 프로세스가 여전히 존재하는 경우에만 가능합니다.

time() -> Float64

에포크 이후 초 단위로 시스템 시간을 가져오며, 상당히 높은 (일반적으로 마이크로초) 해상도를 제공합니다.

time_ns() -> UInt64

시간을 나노초 단위로 가져옵니다. 0에 해당하는 시간은 정의되지 않으며, 5.8년마다 랩핑됩니다.

@time expr
@time "description" expr

표현식을 실행하고, 실행하는 데 걸린 시간, 할당 수, 실행으로 인해 할당된 총 바이트 수를 인쇄한 후 표현식의 값을 반환하는 매크로입니다. 가비지 수집(gc), 새로운 코드 컴파일 또는 무효화된 코드 재컴파일에 소요된 시간은 백분율로 표시됩니다. ReentrantLock 대기와 같은 잠금 충돌은 카운트로 표시됩니다.

선택적으로 시간 보고서 전에 인쇄할 설명 문자열을 제공할 수 있습니다.

일부 경우 시스템은 @time 표현식 내부를 살펴보고 최상위 표현식 실행이 시작되기 전에 호출된 코드의 일부를 컴파일합니다. 그럴 경우 일부 컴파일 시간은 계산되지 않습니다. 이 시간을 포함하려면 @time @eval ...을 실행할 수 있습니다.

또한 @showtime, @timev, @timed, @elapsed, @allocated, 및 @allocations를 참조하십시오.

julia> x = rand(10,10);

julia> @time x * x;
  0.606588 seconds (2.19 M allocations: 116.555 MiB, 3.75% gc time, 99.94% compilation time)

julia> @time x * x;
  0.000009 seconds (1 allocation: 896 bytes)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 seconds (8 allocations: 336 bytes)
2

julia> @time "A one second sleep" sleep(1)
A one second sleep: 1.005750 seconds (5 allocations: 144 bytes)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 seconds (5 allocations: 144 bytes)
2: 1.001263 seconds (5 allocations: 144 bytes)
3: 1.003676 seconds (5 allocations: 144 bytes)

@showtime expr

@time와 비슷하지만 참조를 위해 평가되는 표현식도 출력합니다.

또한 @time를 참조하세요.

julia> @showtime sleep(1)
sleep(1): 1.002164 seconds (4 allocations: 128 bytes)

@timev expr
@timev "description" expr

이것은 @time 매크로의 자세한 버전입니다. 먼저 @time과 동일한 정보를 출력한 다음, 비제로 메모리 할당 카운터를 출력하고, 마지막으로 표현식의 값을 반환합니다.

선택적으로 시간 보고서 전에 출력할 설명 문자열을 제공할 수 있습니다.

또한 @time, @timed, @elapsed, @allocated, 및 @allocations를 참조하십시오.

julia> x = rand(10,10);

julia> @timev x * x;
  0.546770 seconds (2.20 M allocations: 116.632 MiB, 4.23% gc time, 99.94% compilation time)
elapsed time (ns): 546769547
gc time (ns):      23115606
bytes allocated:   122297811
pool allocs:       2197930
non-pool GC allocs:1327
malloc() calls:    36
realloc() calls:   5
GC pauses:         3

julia> @timev x * x;
  0.000010 seconds (1 allocation: 896 bytes)
elapsed time (ns): 9848
bytes allocated:   896
pool allocs:       1

@timed

표현식을 실행하고, 표현식의 값, 경과 시간(초), 총 할당된 바이트, 가비지 수집 시간, 다양한 메모리 할당 카운터가 포함된 객체, 컴파일 시간(초) 및 재컴파일 시간(초)을 반환하는 매크로입니다. ReentrantLock 이 대기해야 했던 모든 잠금 충돌은 카운트로 표시됩니다.

경우에 따라 시스템은 @timed 표현식 내부를 살펴보고 최상위 표현식의 실행이 시작되기 전에 호출된 코드의 일부를 컴파일합니다. 그럴 경우 일부 컴파일 시간은 계산되지 않습니다. 이 시간을 포함하려면 @timed @eval ...을 실행할 수 있습니다.

또한 @time, @timev, @elapsed, @allocated, @allocations, 및 @lock_conflicts도 참조하십시오.

julia> stats = @timed rand(10^6);

julia> stats.time
0.006634834

julia> stats.bytes
8000256

julia> stats.gctime
0.0055765

julia> propertynames(stats.gcstats)
(:allocd, :malloc, :realloc, :poolalloc, :bigalloc, :freecall, :total_time, :pause, :full_sweep)

julia> stats.gcstats.total_time
5576500

julia> stats.compile_time
0.0

julia> stats.recompile_time
0.0

@elapsed

표현식을 평가하고 결과 값을 무시하며 실행하는 데 걸린 시간을 부동 소수점 숫자로 반환하는 매크로입니다.

경우에 따라 시스템은 @elapsed 표현식 내부를 살펴보고 최상위 표현식의 실행이 시작되기 전에 호출된 코드의 일부를 컴파일합니다. 그럴 경우 일부 컴파일 시간은 계산되지 않습니다. 이 시간을 포함하려면 @elapsed @eval ...을 실행할 수 있습니다.

또한 @time, @timev, @timed, @allocated, 및 @allocations를 참조하십시오.

julia> @elapsed sleep(0.3)
0.301391426

@allocated

표현식을 평가하고 결과 값을 버린 다음, 표현식 평가 중에 할당된 총 바이트 수를 반환하는 매크로입니다.

또한 @allocations, @time, @timev, @timed, 및 @elapsed를 참조하십시오.

julia> @allocated rand(10^6)
8000080

@allocations

표현식을 평가하고 결과 값을 버린 다음, 표현식 평가 중에 발생한 총 할당 수를 반환하는 매크로입니다.

또한 @allocated, @time, @timev, @timed, 및 @elapsed를 참조하십시오.

julia> @allocations rand(10^6)
2

@lock_conflicts

표현식을 평가하고 결과 값을 버린 다음, 평가 중에 잠금 시도가 ReentrantLock에서 대기하게 된 잠금 충돌의 총 수를 반환하는 매크로입니다.

또한 @time, @timev 및 @timed를 참조하십시오.

julia> @lock_conflicts begin
    l = ReentrantLock()
    Threads.@threads for i in 1:Threads.nthreads()
        lock(l) do
        sleep(1)
        end
    end
end
5

EnvDict() -> EnvDict

이 유형의 싱글톤은 환경 변수에 대한 해시 테이블 인터페이스를 제공합니다.

ENV

단일 인스턴스 EnvDict에 대한 참조로, 시스템 환경 변수에 대한 사전 인터페이스를 제공합니다.

(Windows에서는 시스템 환경 변수가 대소문자를 구분하지 않으며, ENV는 표시, 반복 및 복사를 위해 모든 키를 대문자로 변환합니다. 이식 가능한 코드는 대소문자로 변수를 구분할 수 있는 능력에 의존해서는 안 되며, 겉보기에는 소문자인 변수를 설정하면 대문자 ENV 키가 생성될 수 있음을 주의해야 합니다.)

!!! 경고 환경을 변경하는 것은 스레드 안전하지 않습니다.

예제

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

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

julia> ENV["JULIA_EDITOR"]
"vim"

또한 참조: withenv, addenv.

Sys.STDLIB::String

stdlib 패키지가 포함된 디렉토리의 전체 경로를 포함하는 문자열입니다.

Sys.isunix([os])

운영 체제가 Unix와 유사한 인터페이스를 제공하는지 테스트하는 술어입니다. 운영 체제 변동 처리에서 문서를 참조하세요.

Sys.isapple([os])

OS가 Apple Macintosh OS X 또는 Darwin의 파생물인지 테스트하는 조건자입니다. 운영 체제 변동 처리에서 문서를 참조하십시오.

Sys.islinux([os])

OS가 Linux의 파생인지 테스트하는 술어입니다. 운영 체제 변동 처리에서 문서를 참조하세요.

Sys.isbsd([os])

OS가 BSD의 파생인지 테스트하는 술어입니다. 운영 체제 변동 처리에서 문서를 참조하세요.

Sys.isfreebsd([os])

FreeBSD 파생 OS인지 테스트하는 술어입니다. 운영 체제 변동 처리에서 문서를 참조하세요.

Sys.isopenbsd([os])

OpenBSD 파생판인지 테스트하는 프레디케이트. 운영 체제 변동 처리에서 문서를 참조하십시오.

Sys.isnetbsd([os])

NetBSD 파생 OS인지 테스트하는 프레디케이트. 운영 체제 변동 처리 문서를 참조하세요.

Sys.isdragonfly([os])

운영 체제가 DragonFly BSD의 파생물인지 테스트하는 술어입니다. 운영 체제 변동 처리에서 문서를 참조하십시오.

Sys.iswindows([os])

Microsoft Windows NT의 파생 OS인지 테스트하는 조건자입니다. 운영 체제 변동 처리에서 문서를 참조하세요.

Sys.windows_version()

Windows NT 커널의 버전 번호를 VersionNumber 형식으로 반환합니다. 즉, v"major.minor.build" 형식이며, Windows에서 실행되지 않는 경우 v"0.0.0"을 반환합니다.

Sys.free_memory()

RAM에서 바이트 단위로 총 무료 메모리를 가져옵니다.

Sys.total_memory()

RAM의 총 메모리(현재 사용 중인 메모리 포함)를 바이트 단위로 가져옵니다. 이 양은 Linux 제어 그룹에 의해 제한될 수 있습니다. 제한되지 않은 양은 Sys.total_physical_memory()를 참조하십시오.

Sys.free_physical_memory()

시스템의 자유 메모리를 바이트 단위로 가져옵니다. 전체 양이 현재 프로세스에 사용 가능하지 않을 수 있습니다. 실제로 사용 가능한 양은 Sys.free_memory()를 사용하십시오.

Sys.total_physical_memory()

RAM의 총 메모리(현재 사용 중인 메모리 포함)를 바이트 단위로 가져옵니다. 전체 양이 현재 프로세스에 사용 가능하지 않을 수 있습니다. Sys.total_memory()를 참조하세요.

Sys.uptime()

현재 시스템 가동 시간을 초 단위로 가져옵니다.

Sys.isjsvm([os])

Julia가 웹 브라우저의 WebAssembly JavaScript 임베딩을 포함하여 JavaScript VM (JSVM)에서 실행되고 있는지 테스트하는 프레디케이트입니다.

Sys.loadavg()

로드 평균을 가져옵니다. 참조: https://en.wikipedia.org/wiki/Load_(computing).

isexecutable(path::String)

주어진 path에 실행 권한이 있으면 true를 반환합니다.

또한 ispath, isreadable, iswritable를 참조하세요.

isreadable(path::String)

주어진 path에 대한 접근 권한이 현재 사용자에 의해 읽기가 허용되면 true를 반환합니다.

또한 ispath, isexecutable, iswritable를 참조하세요.

isreadable(io) -> Bool

지정된 IO 객체가 읽을 수 없는 경우 false를 반환합니다.

예시

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)

주어진 path에 대한 접근 권한이 현재 사용자에 의해 쓰기가 허용되면 true를 반환합니다.

또한 ispath, isexecutable, isreadable를 참조하세요.

iswritable(io) -> Bool

지정된 IO 객체가 쓸 수 없는 경우 false를 반환합니다.

예제

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           iswritable(io)
       end
true

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")

Sys.username() -> String

현재 사용자의 사용자 이름을 반환합니다. 사용자 이름을 확인할 수 없거나 비어 있는 경우 이 함수는 오류를 발생시킵니다.

환경 변수를 통해 재정의할 수 있는 사용자 이름을 검색하려면, 예를 들어 USER, 다음을 사용하는 것이 좋습니다.

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

또한 homedir를 참조하십시오.

@static

구문 분석 시간에 표현식을 부분적으로 평가합니다.

예를 들어, @static Sys.iswindows() ? foo : bar는 Sys.iswindows()를 평가하고 표현식에 foo 또는 bar를 삽입합니다. 이는 다른 플랫폼에서 유효하지 않은 구조가 있을 때 유용합니다. 예를 들어, 존재하지 않는 함수에 대한 ccall과 같은 경우입니다. @static if Sys.isapple() foo end 및 @static foo <&&,||> bar도 유효한 구문입니다.

VersionNumber

버전 번호 유형으로, 시맨틱 버전 관리(semver)의 사양을 따르며, 주요, 부, 패치 숫자 값으로 구성되고, 그 뒤에 사전 릴리스 및 빌드 알파벳 주석이 옵니다.

VersionNumber 객체는 모든 표준 비교 연산자(==, <, <= 등)와 비교할 수 있으며, 결과는 semver 규칙을 따릅니다.

VersionNumber는 다음과 같은 공개 필드를 가지고 있습니다:

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

또한 @v_str를 참조하여 semver 형식의 리터럴 문자열로부터 VersionNumber 객체를 효율적으로 생성하고, VERSION를 통해 Julia 자체의 VersionNumber를 확인하며, 매뉴얼의 버전 번호 리터럴도 참고하세요.

예제

julia> a = VersionNumber(1, 2, 3)
v"1.2.3"

julia> a >= v"1.2"
true

julia> b = VersionNumber("2.0.1-rc1")
v"2.0.1-rc1"

julia> b >= v"2.0.1"
false

@v_str

문자열을 VersionNumber로 구문 분석하는 데 사용되는 문자열 매크로입니다.

예제

julia> v"1.2.3"
v"1.2.3"

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

error(message::AbstractString)

주어진 메시지로 ErrorException을 발생시킵니다.

error(msg...)

string(msg...)로 구성된 메시지와 함께 ErrorException을 발생시킵니다.

throw(e)

객체를 예외로 던집니다.

참고: rethrow, error.

rethrow()

현재 예외를 catch 블록 내에서 다시 던집니다. 다시 던져진 예외는 잡히지 않은 것처럼 계속 전파됩니다.

backtrace()

현재 프로그램 지점에 대한 백트레이스 객체를 가져옵니다.

catch_backtrace()

현재 예외의 백트레이스를 가져와 catch 블록 내에서 사용할 수 있습니다.

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

현재 처리 중인 예외의 스택을 가져옵니다. 중첩된 catch 블록이 있는 경우, 현재 예외가 여러 개일 수 있으며, 이 경우 가장 최근에 발생한 예외가 스택의 마지막에 위치합니다. 스택은 ExceptionStack으로 반환되며, 이는 이름이 있는 튜플 (exception,backtrace)의 AbstractVector입니다. backtrace가 false인 경우, 각 쌍의 백트레이스는 nothing으로 설정됩니다.

명시적으로 task를 전달하면 임의의 작업에서 현재 예외 스택을 반환합니다. 이는 처리되지 않은 예외로 인해 실패한 작업을 검사하는 데 유용합니다.

@assert cond [text]

cond가 false인 경우 AssertionError를 발생시킵니다. 이는 주로 디버깅을 돕기 위해 사용자가 확인할 수 있는 조건인 주장을 작성하기 위한 선호되는 구문입니다. 선택적 메시지 text는 주장 실패 시 표시됩니다.

!!! 경고 assert는 일부 최적화 수준에서 비활성화될 수 있습니다. 따라서 assert는 디버깅 도구로만 사용해야 하며 인증 검증(예: 비밀번호 확인 또는 배열 경계 확인)에는 사용되지 않아야 합니다. 코드는 함수의 올바른 동작을 위해 cond 실행의 부작용에 의존해서는 안 됩니다.

예제

julia> @assert iseven(3) "3은 홀수입니다!"
ERROR: AssertionError: 3은 홀수입니다!

julia> @assert isodd(3) "짝수란 대체 무엇인가요?"

Experimental.register_error_hint(handler, exceptiontype)

사용자가 오류를 우회할 수 있는 잠재적인 방법을 제안할 수 있는 "힌트" 함수 handler(io, exception)를 등록합니다. handler는 exception을 검사하여 힌트에 적합한 조건이 충족되는지 확인하고, 그렇다면 io에 출력을 생성해야 합니다. 패키지는 __init__ 함수 내에서 register_error_hint를 호출해야 합니다.

특정 예외 유형에 대해 handler는 추가 인수를 수락해야 합니다:

• MethodError: handler(io, exc::MethodError, argtypes, kwargs)를 제공하여 결합된 인수를 위치 인수와 키워드 인수로 분리합니다.

힌트를 발행할 때 출력은 일반적으로 \n으로 시작해야 합니다.

사용자 정의 예외 유형을 정의하는 경우, showerror 메서드는 Experimental.show_error_hints를 호출하여 힌트를 지원할 수 있습니다.

예제

julia> module Hinter

       only_int(x::Int)      = 1
       any_number(x::Number) = 2

       function __init__()
           Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
               if exc.f == only_int
                    # 색상은 필요하지 않으며, 이는 가능하다는 것을 보여주기 위한 것입니다.
                    print(io, "\nDid you mean to call ")
                    printstyled(io, "`any_number`?", color=:cyan)
               end
           end
       end

       end

그런 다음 Hinter.only_int를 Int가 아닌 것에 호출하면(따라서 MethodError를 발생시킴) 힌트를 발행합니다:

julia> Hinter.only_int(1.0)
ERROR: MethodError: no method matching only_int(::Float64)
The function `only_int` exists, but no method is defined for this combination of argument types.
Did you mean to call `any_number`?
Closest candidates are:
    ...

Experimental.show_error_hints(io, ex, args...)

특정 예외 유형 typeof(ex)에 대해 Experimental.register_error_hint에서 모든 핸들러를 호출합니다. args는 해당 유형의 핸들러에서 예상되는 다른 인수를 포함해야 합니다.

ArgumentError(msg)

함수에 전달된 인수가 유효하지 않습니다. msg는 설명적인 오류 메시지입니다.

AssertionError([msg])

주장된 조건이 true로 평가되지 않았습니다. 선택적 인수 msg는 설명적인 오류 문자열입니다.

예제

julia> @assert false "this is not true"
ERROR: AssertionError: this is not true

AssertionError는 일반적으로 @assert에서 발생합니다. ```

BoundsError([a],[i])

배열 a에 대한 인덱싱 작업이 인덱스 i에서 범위를 벗어난 요소에 접근하려고 시도했습니다.

예제

julia> A = fill(1.0, 7);

julia> A[8]
ERROR: BoundsError: attempt to access 7-element Vector{Float64} at index [8]


julia> B = fill(1.0, (2,3));

julia> B[2, 4]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [2, 4]


julia> B[9]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [9]

CompositeException

Task[@ref]에 의해 발생한 예외의 Vector를 래핑하여 예외의 연속에 대한 정보를 포함합니다. 예를 들어, 여러 작업자가 여러 작업을 실행하고 여러 작업자가 실패하는 경우, 결과적인 CompositeException은 각 작업자에서 예외가 발생한 위치와 이유를 나타내는 정보의 "묶음"을 포함합니다.

DimensionMismatch([msg])

호출된 객체들이 일치하는 차원을 가지고 있지 않습니다. 선택적 인수 msg는 설명적인 오류 문자열입니다.

DivideError()

정수 나눗셈이 0의 분모 값으로 시도되었습니다.

예제

julia> 2/0
Inf

julia> div(2, 0)
ERROR: DivideError: integer division error
Stacktrace:
[...]

DomainError(val)
DomainError(val, msg)

함수나 생성자에 대한 인수 val이 유효한 범위를 벗어났습니다.

예제

julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrt는 음의 실수 인수로 호출되었지만 복소수 인수로 호출될 때만 복소수 결과를 반환합니다. sqrt(Complex(x))를 시도해 보세요.
Stacktrace:
[...]

EOFError()

파일이나 스트림에서 읽을 수 있는 데이터가 더 이상 없습니다.

ErrorException(msg)

일반적인 오류 유형입니다. .msg 필드에 있는 오류 메시지는 더 구체적인 세부정보를 제공할 수 있습니다.

예시

julia> ex = ErrorException("I've done a bad thing");

julia> ex.msg
"I've done a bad thing"

InexactError(name::Symbol, T, val)

val을(type T로) 정확하게 변환할 수 없습니다. 함수 name의 메서드에서 발생했습니다.

예제

julia> convert(Float64, 1+2im)
ERROR: InexactError: Float64(1 + 2im)
Stacktrace:
[...]

InterruptException()

프로세스가 터미널 인터럽트 (CTRL+C)에 의해 중지되었습니다.

-i (대화형) 옵션 없이 시작된 Julia 스크립트에서는 기본적으로 InterruptException이 발생하지 않음을 유의하십시오. 스크립트에서 Base.exit_on_sigint(false)를 호출하면 REPL의 동작을 복구할 수 있습니다. 또는 Julia 스크립트를 다음과 같이 시작할 수 있습니다.

julia -e "include(popfirst!(ARGS))" script.jl

이렇게 하면 실행 중에 CTRL+C에 의해 InterruptException이 발생하게 됩니다.

KeyError(key)

AbstractDict(Dict) 또는 Set과 같은 객체에 대한 인덱싱 작업이 존재하지 않는 요소에 접근하거나 삭제하려고 시도했습니다.

LoadError(file::AbstractString, line::Int, error)

파일을 include, require, 또는 using 하는 동안 오류가 발생했습니다. 오류 세부정보는 .error 필드에서 확인할 수 있어야 합니다.

MethodError(f, args)

필요한 타입 시그니처를 가진 메서드가 주어진 일반 함수에 존재하지 않습니다. 또는 고유한 가장 구체적인 메서드가 없습니다.

MissingException(msg)

missing 값이 지원되지 않는 상황에서 발견될 때 발생하는 예외입니다. msg 필드의 오류 메시지는 더 구체적인 세부정보를 제공할 수 있습니다.

OutOfMemoryError()

작업이 시스템이나 가비지 컬렉터가 제대로 처리할 수 있는 것보다 너무 많은 메모리를 할당했습니다.

ReadOnlyMemoryError()

작업이 읽기 전용인 메모리에 쓰기를 시도했습니다.

OverflowError(msg)

표현식의 결과가 지정된 유형에 대해 너무 커서 래핑이 발생합니다.

ProcessFailedException

프로세스의 문제 있는 종료 상태를 나타냅니다. 명령이나 파이프라인을 실행할 때, 비제로 종료 코드가 반환되었음을 나타내기 위해 이 예외가 발생합니다 (즉, 호출된 프로세스가 실패했음을 의미합니다).

TaskFailedException

이 예외는 작업 t가 실패할 때 wait(t) 호출에 의해 발생합니다. TaskFailedException은 실패한 작업 t를 감쌉니다.

StackOverflowError()

함수 호출이 호출 스택의 크기를 초과했습니다. 이는 일반적으로 호출이 무한히 재귀될 때 발생합니다.

SystemError(prefix::AbstractString, [errno::Int32])

시스템 호출이 오류 코드(전역 변수 errno에 있음)와 함께 실패했습니다.

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

타입 단언 실패 또는 잘못된 인수 유형으로 내장 함수를 호출하는 경우입니다.

UndefKeywordError(var::Symbol)

필요한 키워드 인수 var가 함수 호출에서 할당되지 않았습니다.

예제

julia> function my_func(;my_arg)
           return my_arg + 1
       end
my_func (generic function with 1 method)

julia> my_func()
ERROR: UndefKeywordError: keyword argument `my_arg` not assigned
Stacktrace:
 [1] my_func() at ./REPL[1]:2
 [2] top-level scope at REPL[2]:1

UndefRefError()

주어진 객체에 대해 항목이나 필드가 정의되지 않았습니다.

예제

julia> struct MyType
           a::Vector{Int}
           MyType() = new()
       end

julia> A = MyType()
MyType(#undef)

julia> A.a
ERROR: UndefRefError: access to undefined reference
Stacktrace:
[...]

UndefVarError(var::Symbol, [scope])

현재 범위에 기호가 정의되어 있지 않습니다.

예제

julia> a
ERROR: UndefVarError: `a` not defined in `Main`

julia> a = 1;

julia> a
1

StringIndexError(str, i)

유효하지 않은 인덱스 i에서 str에 접근하려고 할 때 오류가 발생했습니다.

InitError(mod::Symbol, error)

모듈의 __init__ 함수를 실행할 때 오류가 발생했습니다. 실제로 발생한 오류는 .error 필드에서 확인할 수 있습니다.

retry(f;  delays=ExponentialBackOff(), check=nothing) -> Function

익명 함수를 반환하여 함수 f를 호출합니다. 예외가 발생하면 check가 true를 반환할 때마다 delays에 지정된 초 수만큼 대기한 후 f가 반복적으로 호출됩니다. check는 delays의 현재 상태와 Exception을 입력으로 받아야 합니다.

예제

retry(f, delays=fill(5.0, 3))
retry(f, delays=rand(5:10, 2))
retry(f, delays=Base.ExponentialBackOff(n=3, first_delay=5, max_delay=1000))
retry(http_get, check=(s,e)->e.status == "503")(url)
retry(read, check=(s,e)->isa(e, IOError))(io, 128; all=false)