I/O and Network

stdout::IO

표준 출력 스트림을 참조하는 전역 변수입니다.

stderr::IO

표준 오류 스트림을 참조하는 전역 변수입니다.

stdin::IO

표준 입력 스트림을 참조하는 전역 변수입니다.

read(filename::AbstractString)

파일의 전체 내용을 Vector{UInt8}로 읽습니다.

read(filename::AbstractString, String)

파일의 전체 내용을 문자열로 읽습니다.

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

파일을 열고 그 내용을 읽습니다. args는 read에 전달됩니다: 이는 open(io->read(io, args...), filename)과 동일합니다.

write(filename::AbstractString, content)

content의 표준 이진 표현을 파일에 씁니다. 파일이 아직 존재하지 않으면 생성되며, 존재하는 경우에는 덮어씁니다.

파일에 기록된 바이트 수를 반환합니다.

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

함수 f를 open(args...; kwargs...)의 결과에 적용하고 완료 후 결과 파일 디스크립터를 닫습니다.

예시

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

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

julia> rm("myfile.txt")

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

파일을 다섯 개의 불리언 키워드 인수로 지정된 모드로 엽니다:

키워드가 전달되지 않으면 기본적으로 파일을 읽기 전용으로 엽니다. 열린 파일에 접근하기 위한 스트림을 반환합니다.

lock 키워드 인수는 안전한 다중 스레드 접근을 위해 작업이 잠길지 여부를 제어합니다.

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

문자열 기반 모드 지정자가 사용되는 open의 대체 구문. mode의 값은 fopen(3) 또는 Perl open의 값에 해당하며, 다음 부울 그룹을 설정하는 것과 동일합니다:

lock 키워드 인자는 안전한 다중 스레드 접근을 위해 작업이 잠길지 여부를 제어합니다.

예제

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

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

julia> close(io);

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

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

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

julia> close(io)

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

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

julia> close(io)

julia> rm("myfile.txt")

open(fd::OS_HANDLE) -> IO

원시 파일 설명자를 가져와서 Julia 인식 IO 유형으로 감싸고 fd 핸들의 소유권을 가져옵니다. 원래 핸들의 소유권 캡처를 피하기 위해 open(Libc.dup(fd))를 호출하십시오.

!!! 경고 시스템의 다른 부분에서 이미 소유하고 있는 핸들에 대해 이 함수를 호출하지 마십시오.

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

command를 비동기적으로 실행합니다. open(command, stdio; read, write)와 비슷하지만 키워드 인수 대신 모드 문자열을 통해 읽기 및 쓰기 플래그를 지정합니다. 가능한 모드 문자열은 다음과 같습니다:

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

command을 비동기적으로 실행하고 process::IO 객체를 반환합니다. read가 true이면 프로세스에서 읽는 내용은 프로세스의 표준 출력에서 오며, stdio는 선택적으로 프로세스의 표준 입력 스트림을 지정합니다. write가 true이면 쓰기는 프로세스의 표준 입력으로 가고, stdio는 선택적으로 프로세스의 표준 출력 스트림을 지정합니다. 프로세스의 표준 오류 스트림은 현재 전역 stderr에 연결됩니다.

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

open(command, args...; kwargs...)와 유사하지만, 결과 프로세스 스트림에서 f(stream)을 호출한 다음 입력 스트림을 닫고 프로세스가 완료될 때까지 기다립니다. 성공 시 f가 반환한 값을 반환합니다. 프로세스가 실패하거나 프로세스가 stdout에 무엇이든 출력하려고 시도하면 오류를 발생시킵니다.

IOStream

OS 파일 설명자를 감싸는 버퍼링된 IO 스트림입니다. 주로 open으로 반환된 파일을 나타내는 데 사용됩니다.

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

메모리 내 I/O 스트림을 생성하며, 선택적으로 기존 배열에서 작동할 수 있습니다.

선택적 키워드 인수를 받을 수 있습니다:

• read, write, append: 버퍼에 대한 작업을 제한합니다; 자세한 내용은 open을 참조하십시오.
• truncate: 버퍼 크기를 0 길이로 잘라냅니다.
• maxsize: 버퍼가 성장할 수 없는 크기를 지정합니다.
• sizehint: 버퍼의 용량을 제안합니다 (data는 sizehint!(data, size)를 구현해야 합니다).

data가 주어지지 않으면, 버퍼는 기본적으로 읽기 및 쓰기가 가능합니다.

예제

julia> io = IOBuffer();

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

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

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

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

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

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

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

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

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

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

IOBuffer(string::String)

주어진 문자열에 기반한 읽기 전용 IOBuffer를 생성합니다.

예제

julia> io = IOBuffer("Haho");

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

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

take!(b::IOBuffer)

IOBuffer의 내용을 배열로 가져옵니다. 이후 IOBuffer는 초기 상태로 재설정됩니다.

예제

julia> io = IOBuffer();

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

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

Pipe()

초기화되지 않은 Pipe 객체를 생성합니다. 이는 여러 프로세스 간의 IO 통신을 위해 특별히 설계되었습니다.

파이프의 적절한 끝은 프로세스 생성에 객체가 사용될 경우 자동으로 초기화됩니다. 이는 프로세스 파이프라인에서 참조를 쉽게 얻는 데 유용할 수 있습니다. 예를 들어:

julia> err = Pipe()

# 이 후 `err`는 초기화되며, `err` 파이프에서 `foo`의
# stderr를 읽거나 `err`를 다른 파이프라인에 전달할 수 있습니다.
julia> run(pipeline(pipeline(`foo`, stderr=err), `cat`), wait=false)

# 이제 파이프의 쓰기 절반을 파괴하여 읽기 절반이 EOF를 받도록 합니다.
julia> closewrite(err)

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

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

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

pipe를 초기화하고 in 엔드포인트를 out 엔드포인트에 연결합니다. 키워드 인수 reader_supports_async/writer_supports_async는 Windows의 OVERLAPPED 및 POSIX 시스템의 O_NONBLOCK에 해당합니다. 외부 프로그램(예: run으로 실행된 명령의 출력)에서 사용되지 않는 한 true여야 합니다.

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

정수 파일 설명자에서 IOStream 객체를 생성합니다. own이 true인 경우, 이 객체를 닫으면 기본 설명자가 닫힙니다. 기본적으로 IOStream은 가비지 컬렉션될 때 닫힙니다. name을 사용하면 설명자를 이름이 있는 파일과 연결할 수 있습니다.

flush(stream)

주어진 스트림에 현재 버퍼링된 모든 쓰기를 커밋합니다.

close(stream)

I/O 스트림을 닫습니다. 먼저 flush를 수행합니다.

closewrite(stream)

전체 이중 방향 I/O 스트림의 쓰기 절반을 종료합니다. 먼저 flush를 수행합니다. 다른 쪽에 더 이상 기본 파일에 데이터가 쓰이지 않을 것임을 알립니다. 이는 모든 IO 유형에서 지원되지 않습니다.

구현된 경우, closewrite는 차단될 read 또는 eof 호출이 EOF를 던지거나 각각 true를 반환하도록 합니다. 스트림이 이미 닫혀 있는 경우, 이는 항등적입니다.

예제

julia> io = Base.BufferStream(); # 이 작업은 결코 차단되지 않으므로 같은 작업에서 읽고 쓸 수 있습니다.

julia> write(io, "request");

julia> # 여기서 `read(io)`를 호출하면 영원히 차단됩니다.

julia> closewrite(io);

julia> read(io, String)
"request"

write(io::IO, x)

주어진 I/O 스트림 또는 파일에 값의 표준 이진 표현을 씁니다. 스트림에 기록된 바이트 수를 반환합니다. 텍스트 표현을 쓰려면 print를 참조하세요 (인코딩은 io에 따라 달라질 수 있습니다).

작성된 값의 바이트 순서는 호스트 시스템의 바이트 순서에 따라 다릅니다. 일관된 결과를 얻기 위해 쓰기/읽기 시 고정 바이트 순서로 변환하세요 (예: htol 및 ltoh 사용).

같은 write 호출로 여러 값을 쓸 수 있습니다. 즉, 다음은 동등합니다:

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

예제

일관된 직렬화:

julia> fname = tempname(); # 임의의 임시 파일 이름

julia> open(fname,"w") do f
           # 64비트 정수를 리틀 엔디안 바이트 순서로 기록합니다.
           write(f,htol(Int64(42)))
       end
8

julia> open(fname,"r") do f
           # 호스트 바이트 순서 및 호스트 정수 유형으로 변환합니다.
           Int(ltoh(read(f,Int64)))
       end
42

쓰기 호출 병합:

julia> io = IOBuffer();

julia> write(io, "JuliaLang는 GitHub 조직입니다.", " 많은 구성원이 있습니다.")
56

julia> String(take!(io))
"JuliaLang는 GitHub 조직입니다. 많은 구성원이 있습니다."

julia> write(io, "가끔 그 구성원들이") + write(io, " 문서를 작성합니다.")
44

julia> String(take!(io))
"가끔 그 구성원들이 문서를 작성합니다."

write 메서드가 없는 사용자 정의 평범한 데이터 유형은 Ref로 감싸서 쓸 수 있습니다:

julia> struct MyStruct; x::Float64; end

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

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

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

read(io::IO, T)

io에서 타입 T의 단일 값을 읽습니다. 표준 이진 표현으로.

Julia는 엔디안 변환을 자동으로 수행하지 않습니다. 이 목적을 위해 ntoh 또는 ltoh를 사용하십시오.

read(io::IO, String)

io의 전체 내용을 String으로 읽습니다 (자세한 내용은 readchomp 참조).

예제

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

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

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

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

read(filename::AbstractString)

파일의 전체 내용을 Vector{UInt8}로 읽습니다.

read(filename::AbstractString, String)

파일의 전체 내용을 문자열로 읽습니다.

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

파일을 열고 그 내용을 읽습니다. args는 read에 전달됩니다: 이는 open(io->read(io, args...), filename)과 동일합니다.

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

s에서 최대 nb 바이트를 읽고, 읽은 바이트의 Vector{UInt8}를 반환합니다.

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

s에서 최대 nb 바이트를 읽고, 읽은 바이트의 Vector{UInt8}를 반환합니다.

all이 true(기본값)인 경우, 이 함수는 오류나 파일 끝이 발생할 때까지 요청된 모든 바이트를 읽으려고 반복적으로 차단됩니다. all이 false인 경우, 최대 한 번의 read 호출이 수행되며, 반환되는 데이터의 양은 장치에 따라 다릅니다. 모든 스트림 유형이 all 옵션을 지원하는 것은 아닙니다.

read(command::Cmd)

command를 실행하고 결과 출력을 바이트 배열로 반환합니다.

read(command::Cmd, String)

command를 실행하고 결과 출력을 String으로 반환합니다.

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

I/O 스트림 또는 파일에서 이진 데이터를 읽어 array를 채웁니다.

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

최대 nb 바이트를 stream에서 b로 읽고, 읽은 바이트 수를 반환합니다. 필요할 경우 b의 크기가 증가하지만(즉, nb가 length(b)보다 크고 충분한 바이트를 읽을 수 있는 경우), 절대 감소하지는 않습니다.

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

최대 nb 바이트를 stream에서 b로 읽어들이며, 읽은 바이트 수를 반환합니다. 필요할 경우 b의 크기가 증가하지만(즉, nb가 length(b)보다 크고 충분한 바이트를 읽을 수 있는 경우) 감소하지는 않습니다.

all이 true(기본값)인 경우, 이 함수는 오류나 파일 끝이 발생할 때까지 요청된 모든 바이트를 읽으려고 반복적으로 차단됩니다. all이 false인 경우, 최대 한 번의 read 호출이 수행되며, 반환되는 데이터 양은 장치에 따라 다릅니다. 모든 스트림 유형이 all 옵션을 지원하는 것은 아닙니다.

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

IO 스트림 객체에서 ref로 nbytes를 복사합니다(포인터로 변환됨).

서브타입 T<:IO는 더 효율적인 구현을 제공하기 위해 다음 메서드 시그니처를 재정의하는 것이 권장됩니다: unsafe_read(s::T, p::Ptr{UInt8}, n::UInt)

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

ref에서 nbytes를 복사하여 IO 객체에 넣습니다(포인터로 변환됨).

하위 유형 T<:IO는 더 효율적인 구현을 제공하기 위해 다음 메서드 시그니처를 재정의하는 것이 권장됩니다: unsafe_write(s::T, p::Ptr{UInt8}, n::UInt)

readeach(io::IO, T)

read(io, T)를 생성하는 반복 가능한 객체를 반환합니다.

또한 skipchars, eachline, readuntil를 참조하세요.

예제

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

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

peek(stream[, T=UInt8])

스트림에서 현재 위치를 이동하지 않고 타입 T의 값을 읽고 반환합니다. 또한 startswith(stream, char_or_string)를 참조하십시오.

예제

julia> b = IOBuffer("julia");

julia> peek(b)
0x6a

julia> position(b)
0

julia> peek(b, Char)
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)

position(l::Lexer)

현재 위치를 반환합니다.

위치

스트림의 현재 위치를 가져옵니다.

예제

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

julia> seek(io, 5);

julia> position(io)
5

julia> skip(io, 10);

julia> position(io)
15

julia> seekend(io);

julia> position(io)
35

seek(s, pos)

주어진 위치로 스트림을 이동합니다.

예제

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

julia> seek(io, 5);

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

seekstart(s)

스트림을 시작 위치로 이동합니다.

예제

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

julia> seek(io, 5);

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

julia> seekstart(io);

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

seekend(s)

스트림을 끝으로 이동합니다.

skip(s, offset)

현재 위치를 기준으로 스트림을 이동합니다.

예제

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

julia> seek(io, 5);

julia> skip(io, 10);

julia> read(io, Char)
'G': ASCII/Unicode U+0047 (category Lu: Letter, uppercase)

mark(s::IO)

스트림 s의 현재 위치에 마크를 추가합니다. 마크된 위치를 반환합니다.

자세한 내용은 unmark, reset, ismarked를 참조하세요.

unmark(s::IO)

스트림 s에서 마크를 제거합니다. 스트림이 마크되었으면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

또한 mark, reset, ismarked를 참조하세요.

reset(s::IO)

스트림 s를 이전에 표시된 위치로 재설정하고, 표시를 제거합니다. 이전에 표시된 위치를 반환합니다. 스트림이 표시되지 않은 경우 오류를 발생시킵니다.

또한 mark, unmark, ismarked를 참조하세요.

ismarked(s::IO)

스트림 s가 마크되어 있으면 true를 반환합니다.

또한 mark, unmark, reset를 참조하세요.

eof(stream) -> Bool

I/O 스트림이 파일 끝에 도달했는지 테스트합니다. 스트림이 아직 소진되지 않았다면, 이 함수는 필요할 경우 더 많은 데이터를 기다리기 위해 블록됩니다. 그리고 나서 false를 반환합니다. 따라서 eof가 false를 반환한 후에는 항상 한 바이트를 읽는 것이 안전합니다. eof는 버퍼링된 데이터가 여전히 사용 가능할 때는 false를 반환하며, 연결의 원격 끝이 닫혀 있어도 마찬가지입니다.

예제

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

julia> eof(b)
false

julia> seekend(b);

julia> eof(b)
true

isreadonly(io) -> Bool

스트림이 읽기 전용인지 여부를 결정합니다.

예제

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

julia> isreadonly(io)
true

julia> io = IOBuffer();

julia> isreadonly(io)
false

iswritable(path::String)

주어진 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")

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

isexecutable(path::String)

주어진 path에 실행 권한이 있으면 true를 반환합니다.

또한 ispath, isreadable, iswritable를 참조하세요.

isopen(object) -> Bool

객체(예: 스트림 또는 타이머)가 아직 닫히지 않았는지 확인합니다. 객체가 닫히면 새로운 이벤트를 생성하지 않습니다. 그러나 닫힌 스트림은 여전히 버퍼에 읽을 데이터가 있을 수 있으므로, eof를 사용하여 데이터를 읽을 수 있는지 확인하십시오. FileWatching 패키지를 사용하여 스트림이 쓰기 가능하거나 읽기 가능할 때 알림을 받을 수 있습니다.

예제

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

julia> isopen(io)
true

julia> close(io)

julia> isopen(io)
false

fd(stream)

스트림 또는 파일을 지원하는 파일 설명자를 반환합니다. 이 함수는 비동기 스트림이 아닌 동기 File 및 IOStream에만 적용된다는 점에 유의하십시오.

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

stdin, stderr, stdout의 하위 집합을 리디렉션합니다. 각 인수는 IOStream, TTY, Pipe, 소켓 또는 devnull이어야 합니다.

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

stdin, stderr, stdout의 하위 집합을 리디렉션하고 f()를 호출한 후 각 스트림을 복원합니다.

각 스트림에 대한 가능한 값은 다음과 같습니다:

• nothing은 스트림이 리디렉션되지 않아야 함을 나타냅니다.
• path::AbstractString은 스트림을 path에 있는 파일로 리디렉션합니다.
• io는 IOStream, TTY, Pipe, 소켓 또는 devnull입니다.

예제

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

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

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

엣지 케이스

stdout과 stderr에 동일한 인수를 전달하는 것이 가능합니다:

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

그러나 동일한 파일의 두 개의 서로 다른 설명자를 전달하는 것은 지원되지 않습니다.

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

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

julia> redirect_stdio(f, stdout=io1, stderr=io2) # 지원되지 않음

또한 stdin 인수는 stdout 또는 stderr와 동일한 설명자가 될 수 없습니다.

julia> io = open(...)

julia> redirect_stdio(f, stdout=io, stdin=io) # 지원되지 않음

redirect_stdout([stream]) -> stream

모든 C 및 Julia 수준의 stdout 출력을 리디렉션할 파이프를 생성합니다. 파이프의 끝을 나타내는 스트림을 반환합니다. 이제 stdout에 작성된 데이터는 파이프의 rd 끝에서 읽을 수 있습니다.

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

redirect_stdout(f::Function, stream)

함수 f를 실행하면서 stdout를 stream으로 리디렉션합니다. 완료되면 stdout는 이전 설정으로 복원됩니다.

redirect_stderr([stream]) -> stream

stderr에 대한 redirect_stdout와 유사합니다.

또한 redirect_stdio를 참조하십시오.

redirect_stderr(f::Function, stream)

함수 f를 실행하면서 stderr를 stream으로 리디렉션합니다. 완료되면 stderr는 이전 설정으로 복원됩니다.

redirect_stdin([stream]) -> stream

redirect_stdout와 유사하지만 stdin에 대한 것입니다. 스트림의 방향이 반전된다는 점에 유의하세요.

또한 redirect_stdio를 참조하세요.

redirect_stdin(f::Function, stream)

함수 f를 실행하면서 stdin를 stream으로 리디렉션합니다. 완료되면 stdin는 이전 설정으로 복원됩니다.

readchomp(x)

x의 전체를 문자열로 읽고, 만약 있다면 단일 개행 문자를 제거합니다. chomp(read(x, String))와 동일합니다.

예제

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

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

julia> rm("my_file.txt");

truncate(file, n)

파일 또는 버퍼를 첫 번째 인수로 주어진 대로 정확히 n 바이트로 크기를 조정하며, 파일 또는 버퍼가 커질 경우 이전에 할당되지 않은 공간을 '\0'으로 채웁니다.

예제

julia> io = IOBuffer();

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

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

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

julia> io = IOBuffer();

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

julia> truncate(io, 40);

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

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

스트림 io를 진행시켜 다음에 읽을 문자가 predicate가 false를 반환하는 첫 번째 남은 문자로 설정됩니다. 키워드 인수 linecomment가 지정된 경우, 해당 문자부터 다음 줄의 시작까지의 모든 문자는 무시됩니다.

예제

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

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

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

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

io를 끝까지 읽고 줄 수를 셉니다. 파일을 지정하려면 파일 이름을 첫 번째 인수로 전달합니다. '\n' 이외의 EOL 마커는 두 번째 인수로 전달하여 지원됩니다. io의 마지막 비어 있지 않은 줄은 EOL로 끝나지 않더라도 계산되며, 이는 eachline 및 readlines에서 반환된 길이와 일치합니다.

String의 줄 수를 세려면 countlines(IOBuffer(str))를 사용할 수 있습니다.

예제

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

julia> countlines(io)
1

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

julia> countlines(io)
1

julia> eof(io) # 줄 수를 세면 파일 포인터가 이동합니다.
true

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

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

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

julia> countlines("my_file.txt")
1

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

julia> rm("my_file.txt")

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

읽기를 허용하고 추가하여 쓰기를 수행하는 IOBuffer입니다. 탐색 및 잘라내기는 지원되지 않습니다. 사용 가능한 생성자에 대해서는 IOBuffer를 참조하십시오. data가 주어지면 데이터 벡터에서 작동하는 PipeBuffer를 생성하며, 선택적으로 기본 Array가 성장할 수 없는 크기를 지정합니다.

readavailable(stream)

스트림에서 사용 가능한 버퍼링된 데이터를 읽습니다. 실제 I/O는 이미 데이터가 버퍼링되지 않은 경우에만 수행됩니다. 결과는 Vector{UInt8}입니다.

!!! 경고 반환되는 데이터의 양은 구현에 따라 다릅니다. 예를 들어 내부 버퍼 크기 선택에 따라 달라질 수 있습니다. 일반적으로 read와 같은 다른 함수를 대신 사용해야 합니다.

IOContext

IOContext는 show 메서드 간에 출력 구성 설정을 전달하는 메커니즘을 제공합니다.

간단히 말해, 이는 IO의 서브클래스인 불변 사전입니다. getindex와 같은 표준 사전 작업을 지원하며, I/O 스트림으로도 사용할 수 있습니다.

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

주어진 스트림을 감싸는 IOContext를 생성하고, 해당 스트림의 속성에 지정된 key=>value 쌍을 추가합니다 (note that io can itself be an IOContext).

• (key => value) in io를 사용하여 이 특정 조합이 속성 집합에 있는지 확인합니다.
• get(io, key, default)를 사용하여 특정 키에 대한 가장 최근 값을 검색합니다.

다음 속성은 일반적으로 사용됩니다:

• :compact: 값이 더 간결하게 출력되어야 함을 지정하는 Boolean입니다. 예를 들어, 숫자가 더 적은 자릿수로 출력되어야 합니다. 이는 배열 요소를 출력할 때 설정됩니다. :compact 출력에는 줄 바꿈이 포함되지 않아야 합니다.
• :limit: 컨테이너가 잘려야 함을 지정하는 Boolean입니다. 예를 들어, 대부분의 요소 대신 …를 표시합니다.
• :displaysize: 텍스트 출력을 위해 사용할 행과 열의 크기를 제공하는 Tuple{Int,Int}입니다. 이는 호출된 함수의 표시 크기를 재정의하는 데 사용할 수 있지만, 화면의 크기를 얻으려면 displaysize 함수를 사용해야 합니다.
• :typeinfo: 표시될 객체의 유형에 대해 이미 인쇄된 정보를 특성화하는 Type입니다. 이는 동일한 유형의 객체 모음을 표시할 때 주로 유용하여 중복된 유형 정보를 피할 수 있습니다 (예: [Float16(0)]는 "Float16[0.0]"으로 표시될 수 있으며, "Float16[Float16(0.0)]" 대신에 배열의 요소를 표시할 때 :typeinfo 속성은 Float16으로 설정됩니다).
• :color: ANSI 색상/이스케이프 코드가 지원/예상되는지를 지정하는 Boolean입니다. 기본적으로 이는 io가 호환 가능한 터미널인지와 julia가 시작될 때의 --color 명령줄 플래그에 의해 결정됩니다.

예제

julia> io = IOBuffer();

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

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

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

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

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

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

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

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

대체 IO를 감싸지만 context의 속성을 상속하는 IOContext를 생성합니다.

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

값 x의 텍스트 표현을 출력 스트림 io에 씁니다. 새로운 타입 T는 show(io::IO, x::T)를 오버로드해야 합니다. show에서 사용되는 표현은 일반적으로 줄리아 고유의 형식 및 타입 정보를 포함하며, 가능한 경우 파싱 가능한 줄리아 코드여야 합니다.

repr는 show의 출력을 문자열로 반환합니다.

타입 T의 객체에 대해 보다 자세한 사람이 읽을 수 있는 텍스트 출력을 원한다면, 추가로 show(io::IO, ::MIME"text/plain", ::T)를 정의하십시오. 이러한 메서드에서 io의 :compact IOContext 키(종종 get(io, :compact, false)::Bool로 확인됨)를 확인하는 것이 좋습니다. 일부 컨테이너는 :compact => true로 이 메서드를 호출하여 요소를 표시합니다.

또한 장식이 없는 표현을 작성하는 print도 참조하십시오.

예제

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

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

값에 대한 간단한 설명을 제공하는 스트림 io에 인쇄하거나 문자열 str을 반환합니다. 기본적으로 string(typeof(x))를 반환합니다. 예: Int64.

배열의 경우 크기 및 유형 정보의 문자열을 반환합니다. 예: 10-element Array{Int64,1}.

예제

julia> summary(1)
"Int64"

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

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

io에 (또는 io가 주어지지 않은 경우 기본 출력 스트림 stdout으로) 표준적인 (장식이 없는) 텍스트 표현을 씁니다. print에서 사용되는 표현은 최소한의 형식을 포함하며 Julia 특정 세부정보를 피하려고 합니다.

print는 show를 호출하는 것으로 대체되므로 대부분의 유형은 show만 정의하면 됩니다. 유형에 별도의 "일반" 표현이 있는 경우 print를 정의하십시오. 예를 들어, show는 문자열을 따옴표로 표시하고, print는 문자열을 따옴표 없이 표시합니다.

또한 println, string, printstyled를 참조하십시오.

예제

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

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

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

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

xs를 io에 출력한 후 줄 바꿈을 합니다 ( print 사용). io가 제공되지 않으면 기본 출력 스트림 stdout에 출력합니다.

색상 등을 추가하려면 printstyled를 참조하세요.

예제

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

julia> io = IOBuffer();

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

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

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

xs를 기호 또는 정수로 지정된 색상으로 인쇄하며, 선택적으로 굵게 인쇄합니다.

키워드 color는 :normal, :italic, :default, :bold, :black, :blink, :blue, :cyan, :green, :hidden, :light_black, :light_blue, :light_cyan, :light_green, :light_magenta, :light_red, :light_white, :light_yellow, :magenta, :nothing, :red, :reverse, :underline, :white, 또는 :yellow 또는 0에서 255 사이의 정수를 포함할 수 있습니다. 모든 터미널이 256색을 지원하는 것은 아닙니다.

키워드 bold=true, italic=true, underline=true, blink=true는 자명합니다. 키워드 reverse=true는 전경색과 배경색이 교환된 상태로 인쇄하며, hidden=true는 터미널에서 보이지 않지만 여전히 복사할 수 있어야 합니다. 이러한 속성은 어떤 조합으로도 사용할 수 있습니다.

또한 print, println, show를 참조하십시오.

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

주어진 함수를 I/O 스트림과 함께 호출하고 제공된 추가 인수를 사용합니다. 이 I/O 스트림에 작성된 모든 내용은 문자열로 반환됩니다. context는 속성이 사용될 IOContext일 수 있으며, 속성과 그 값을 지정하는 Pair일 수도 있고, 여러 속성과 그 값을 지정하는 Pair의 튜플일 수도 있습니다. sizehint는 버퍼의 용량(바이트 단위)을 제안합니다.

선택적 키워드 인수 context는 :key=>value 쌍, :key=>value 쌍의 튜플, 또는 f에 전달되는 I/O 스트림에 사용되는 속성이 있는 IO 또는 IOContext 객체로 설정할 수 있습니다. 선택적 sizehint는 문자열을 쓰는 데 사용되는 버퍼에 할당할 제안된 크기(바이트 단위)입니다.

예제

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

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

showerror(io, e)

예외 객체 e의 설명적인 표현을 보여줍니다. 이 메서드는 throw 호출 후 예외를 표시하는 데 사용됩니다.

예제

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

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

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

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

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

dump(x; maxdepth=8)

값의 표현의 모든 부분을 보여줍니다. 출력의 깊이는 maxdepth에서 잘립니다.

예제

julia> struct MyStruct
           x
           y
       end

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

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

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

@dump expr

주어진 표현식의 모든 부분을 나타냅니다. dump(:(expr))와 동등합니다.

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

주어진 I/O 스트림 또는 파일에서 한 줄의 텍스트를 읽습니다(기본값은 stdin). 파일에서 읽을 때, 텍스트는 UTF-8로 인코딩된 것으로 가정됩니다. 입력의 줄은 '\n' 또는 "\r\n" 또는 입력 스트림의 끝으로 끝납니다. keep이 false(기본값)인 경우, 이러한 후행 개행 문자는 반환되기 전에 줄에서 제거됩니다. keep이 true인 경우, 이들은 줄의 일부로 반환됩니다.

String을 반환합니다. 대신 다른 스트림에 제자리에서 쓰려면 copyline을 참조하십시오(이는 미리 할당된 IOBuffer가 될 수 있습니다).

보다 일반적인 구분 기호까지 읽으려면 readuntil을 참조하십시오.

예제

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

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

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

julia> rm("my_file.txt")

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

julia> your_name = readline()
Logan
"Logan"

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

주어진 구분자까지 I/O stream 또는 파일에서 문자열을 읽습니다. 구분자는 UInt8, AbstractChar, 문자열 또는 벡터일 수 있습니다. 키워드 인수 keep는 결과에 구분자가 포함되는지 여부를 제어합니다. 텍스트는 UTF-8로 인코딩된 것으로 가정됩니다.

delim이 AbstractChar 또는 문자열인 경우 String을 반환하고, 그렇지 않으면 Vector{typeof(delim)}를 반환합니다. 대신 다른 스트림(미리 할당된 IOBuffer일 수 있음)에 제자리에서 쓰려면 copyuntil도 참조하십시오.

예제

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

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

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

julia> rm("my_file.txt")

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

I/O 스트림 또는 파일의 모든 줄을 문자열 벡터로 읽습니다. 동작은 readline 함수를 동일한 인수로 반복적으로 호출하고 결과로 얻은 줄을 문자열 벡터로 저장하는 것과 동일합니다. 모든 줄을 한 번에 읽지 않고 반복하려면 eachline를 참조하십시오.

예제

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

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

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

julia> rm("my_file.txt")

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

I/O 스트림 또는 파일에서 각 줄을 생성하는 iterable EachLine 객체를 만듭니다. 반복 호출은 keep이 전달된 스트림 인수에서 readline를 반복적으로 호출하여 줄 끝의 개행 문자가 유지되는지 여부를 결정합니다. 파일 이름으로 호출되면, 반복의 시작 시 파일이 한 번 열리고 끝에서 닫힙니다. 반복이 중단되면, EachLine 객체가 가비지 컬렉션될 때 파일이 닫힙니다.

String의 각 줄을 반복하려면 eachline(IOBuffer(str))를 사용할 수 있습니다.

Iterators.reverse는 EachLine 객체에서 줄을 역순으로 읽는 데 사용할 수 있으며(파일, 버퍼 및 seek를 지원하는 기타 I/O 스트림에 대해), first 또는 last를 사용하여 각각 초기 또는 최종 줄을 추출할 수 있습니다.

예제

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

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

julia> rm("my_file.txt");

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

I/O 스트림 또는 파일에서 out 스트림으로 단일 텍스트 라인을 복사하고 out을 반환합니다.

파일에서 읽을 때, 텍스트는 UTF-8로 인코딩된 것으로 가정됩니다. 입력의 라인은 '\n' 또는 "\r\n" 또는 입력 스트림의 끝으로 끝납니다. keep이 false일 때(기본값), 이러한 후행 개행 문자는 반환되기 전에 라인에서 제거됩니다. keep이 true일 때, 이들은 라인의 일부로 반환됩니다.

readline와 유사하며, String을 반환합니다. 반면에 copyline은 문자열을 할당하지 않고 직접 out에 씁니다. (예를 들어, 미리 할당된 IOBuffer로 데이터를 읽는 데 사용할 수 있습니다.)

보다 일반적인 구분 기호까지 읽기 위해 copyuntil도 참조하십시오.

예제

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

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

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

julia> rm("my_file.txt")

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

주어진 구분자까지 I/O stream 또는 파일에서 문자열을 out 스트림으로 복사하고 out을 반환합니다. 구분자는 UInt8, AbstractChar, 문자열 또는 벡터일 수 있습니다. 키워드 인수 keep는 결과에 구분자가 포함되는지 여부를 제어합니다. 텍스트는 UTF-8로 인코딩된 것으로 가정됩니다.

readuntil와 유사하지만, copyuntil은 문자열을 할당하지 않고 직접 out에 씁니다. (예를 들어, 미리 할당된 IOBuffer로 데이터를 읽는 데 사용할 수 있습니다.)

예제

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

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

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

julia> rm("my_file.txt")

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

이 IO 객체에 출력을 렌더링하는 데 사용할 수 있는 화면의 명목 크기를 반환합니다. 입력이 제공되지 않으면 환경 변수 LINES와 COLUMNS가 읽힙니다. 이 값들이 설정되어 있지 않으면 기본 크기 (24, 80)이 반환됩니다.

예제

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

TTY 크기를 얻으려면,

julia> displaysize(stdout)
(34, 147)

AbstractDisplay

풍부한 디스플레이 출력 장치에 대한 추상 슈퍼타입입니다. TextDisplay는 이의 서브타입입니다.

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

x를 디스플레이 스택에서 가장 적합한 디스플레이를 사용하여 표시합니다. 일반적으로 x에 대해 지원되는 가장 풍부한 멀티미디어 출력을 사용하며, 기본 텍스트 stdout 출력을 대체로 사용합니다. display(d, x) 변형은 주어진 디스플레이 d에서만 x를 표시하려고 시도하며, d가 이 유형의 객체를 표시할 수 없는 경우 MethodError를 발생시킵니다.

일반적으로 display 출력이 stdout로 간주된다고 가정할 수 없습니다 (예: print(x) 또는 show(x)와는 다르게). 예를 들어, display(x)는 이미지가 있는 별도의 창을 열 수 있습니다. display(x)는 "현재 출력 장치에 대해 가능한 최상의 방법으로 x를 표시하라"는 의미입니다. stdout로 보장된 REPL과 같은 텍스트 출력을 원한다면 대신 show(stdout, "text/plain", x)를 사용하십시오.

mime 인수(예: "image/png"와 같은 MIME 유형 문자열)를 가진 두 가지 변형도 있으며, 요청된 MIME 유형 만 사용하여 x를 표시하려고 시도하며, 이 유형이 디스플레이 또는 x에 의해 지원되지 않는 경우 MethodError를 발생시킵니다. 이러한 변형을 사용하면 x::AbstractString(text/html 또는 application/postscript와 같은 텍스트 기반 저장을 위한 MIME 유형) 또는 x::Vector{UInt8}(이진 MIME 유형을 위한)으로 요청된 MIME 유형의 "원시" 데이터를 제공할 수도 있습니다.

유형의 인스턴스가 표시되는 방식을 사용자 정의하려면, 매뉴얼의 사용자 정의 예쁘게 출력하기 섹션에 설명된 대로 display가 아닌 show를 오버로드하십시오.

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

기본적으로 redisplay 함수는 단순히 display를 호출합니다. 그러나 일부 디스플레이 백엔드는 기존의 x 디스플레이를 수정하기 위해 redisplay를 재정의할 수 있습니다(있는 경우). redisplay를 사용하는 것은 또한 백엔드에 x가 여러 번 다시 표시될 수 있음을 암시하며, 백엔드는 (예: 다음 대화형 프롬프트까지) 표시를 연기할 수 있습니다.

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

주어진 mime 유형(문자열)이 현재 디스플레이 스택의 어떤 디스플레이에 의해 표시 가능한지, 또는 두 번째 변형에서 디스플레이 d에 의해 표시 가능한지를 나타내는 부울 값을 반환합니다.

show(io::IO, mime, x)

display 함수는 궁극적으로 객체 x를 주어진 I/O 스트림 io(보통 메모리 버퍼)에 주어진 mime 유형으로 쓰기 위해 show를 호출합니다. 사용자 정의 유형 T의 풍부한 멀티미디어 표현을 제공하기 위해서는 T에 대한 새로운 show 메서드를 정의하기만 하면 됩니다. 방법은 다음과 같습니다: show(io, ::MIME"mime", x::T) = ..., 여기서 mime은 MIME 유형 문자열이며 함수 본문은 write (또는 유사한 함수)를 호출하여 x의 해당 표현을 io에 씁니다. (MIME"" 표기법은 리터럴 문자열만 지원하므로, 더 유연한 방식으로 MIME 유형을 구성하려면 MIME{Symbol("")}을 사용하세요.)

예를 들어, MyImage 유형을 정의하고 이를 PNG 파일로 쓰는 방법을 알고 있다면, show(io, ::MIME"image/png", x::MyImage) = ... 함수를 정의하여 PNG를 지원하는 모든 AbstractDisplay(예: IJulia)에서 이미지를 표시할 수 있도록 할 수 있습니다. 항상 그렇듯이, 내장된 Julia 함수 show에 새로운 메서드를 추가하려면 import Base.show를 잊지 마세요.

기술적으로, MIME"mime" 매크로는 주어진 mime 문자열에 대한 단일 유형을 정의하여, 주어진 유형의 객체를 표시하는 방법을 결정하는 데 Julia의 분산 메커니즘을 활용할 수 있게 합니다.

기본 MIME 유형은 MIME"text/plain"입니다. text/plain 출력을 위한 대체 정의가 있으며, 이는 2개의 인수로 show를 호출하므로 항상 해당 경우에 대한 메서드를 추가할 필요는 없습니다. 그러나 유형이 사용자에게 읽기 쉬운 출력의 이점을 누린다면, show(::IO, ::MIME"text/plain", ::T)를 정의해야 합니다. 예를 들어, Day 유형은 text/plain MIME 유형에 대해 1 day를 출력으로 사용하며, Day(1)은 2-인수 show의 출력입니다.

예제

julia> struct Day
           n::Int
       end

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

julia> Day(1)
1 day

컨테이너 유형은 일반적으로 show(io, MIME"text/plain"(), x)를 호출하여 요소 x에 대해 3-인수 show를 구현하며, 첫 번째 인수로 전달된 IOContext에서 :compact => true가 설정됩니다.

showable(mime, x)

주어진 mime 유형으로 객체 x를 쓸 수 있는지 여부를 나타내는 부울 값을 반환합니다.

(기본적으로, 이는 typeof(x)에 대한 해당 show 메서드의 존재에 의해 자동으로 결정됩니다. 일부 유형은 사용자 정의 showable 메서드를 제공합니다. 예를 들어, 사용 가능한 MIME 형식이 x의 값에 따라 달라질 수 있습니다.)

예시

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

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

repr(mime, x; context=nothing)

요청된 mime 유형으로 x의 표현을 포함하는 AbstractString 또는 Vector{UInt8}를 반환합니다. 이는 show(io, mime, x)에서 작성된 대로 반환되며, 적절한 show가 없으면 MethodError를 발생시킵니다. 텍스트 표현이 있는 MIME 유형(예: "text/html" 또는 "application/postscript")의 경우 AbstractString이 반환되며, 이진 데이터는 Vector{UInt8}로 반환됩니다. (istextmime(mime) 함수는 주어진 mime 유형을 Julia가 텍스트로 처리하는지 여부를 반환합니다.)

선택적 키워드 인수 context는 :key=>value 쌍 또는 show에 전달된 I/O 스트림에 사용되는 속성을 가진 IO 또는 IOContext 객체로 설정할 수 있습니다.

특별한 경우로, x가 AbstractString(텍스트 MIME 유형의 경우) 또는 Vector{UInt8}(이진 MIME 유형의 경우)인 경우, repr 함수는 x가 이미 요청된 mime 형식에 있다고 가정하고 단순히 x를 반환합니다. 이 특별한 경우는 "text/plain" MIME 유형에는 적용되지 않습니다. 이는 원시 데이터를 display(m::MIME, x)에 전달할 수 있도록 유용합니다.

특히, repr("text/plain", x)는 일반적으로 인간 소비를 위해 설계된 x의 "예쁘게 인쇄된" 버전입니다. 대신 show(x)에 해당하는 문자열을 반환하려면 repr(x)를 참조하세요. 이는 x의 값이 Julia에 입력될 때 더 가까운 형태일 수 있습니다.

예제

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

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

MIME

표준 인터넷 데이터 형식을 나타내는 유형입니다. "MIME"은 "다목적 인터넷 메일 확장"을 의미하며, 이 표준은 원래 이메일 메시지에 대한 멀티미디어 첨부 파일을 설명하는 데 사용되었습니다.

MIME 객체는 show에 두 번째 인수로 전달되어 해당 형식으로 출력을 요청할 수 있습니다.

예제

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

@MIME_str

MIME 유형을 작성하기 위한 편리한 매크로로, 일반적으로 show에 메서드를 추가할 때 사용됩니다. 예를 들어, show(io::IO, ::MIME"text/html", x::MyType) = ... 구문을 사용하여 MyType의 HTML 표현을 작성하는 방법을 정의할 수 있습니다.

pushdisplay(d::AbstractDisplay)

전역 디스플레이 백엔드 스택의 맨 위에 새로운 디스플레이 d를 푸시합니다. display(x) 또는 display(mime, x)를 호출하면 스택에서 호환 가능한 맨 위의 백엔드(즉, MethodError를 발생시키지 않는 맨 위의 백엔드)에서 x가 표시됩니다.

popdisplay()
popdisplay(d::AbstractDisplay)

디스플레이 백엔드 스택에서 가장 위에 있는 백엔드를 제거하거나, 두 번째 변형에서 d의 가장 위에 있는 복사본을 제거합니다.

TextDisplay(io::IO)

TextDisplay <: AbstractDisplay를 반환하며, 이는 주어진 I/O 스트림에 텍스트 표현을 작성하여 모든 객체를 text/plain MIME 유형으로 표시합니다(기본값). (이것이 Julia REPL에서 객체가 출력되는 방식입니다.)

istextmime(m::MIME)

MIME 유형이 텍스트 데이터인지 여부를 결정합니다. MIME 유형은 텍스트 데이터로 알려진 특정 유형을 제외하고는 이진 데이터로 간주됩니다(가능한 유니코드 포함).

예제

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

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

bytesavailable(io)

이 스트림 또는 버퍼에서 읽기가 차단되기 전에 읽을 수 있는 바이트 수를 반환합니다.

예제

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

julia> bytesavailable(io)
34

ntoh(x)

값의 엔디안 방식을 네트워크 바이트 순서(빅 엔디안)에서 호스트에서 사용하는 방식으로 변환합니다.

hton(x)

호스트에서 사용하는 바이트 순서를 네트워크 바이트 순서(빅 엔디안)로 변환합니다.

ltoh(x)

값의 엔디안 형식을 리틀 엔디안에서 호스트에서 사용하는 형식으로 변환합니다.

htol(x)

호스트에서 사용하는 엔디안 형식에서 리틀 엔디안으로 값의 엔디안 형식을 변환합니다.

ENDIAN_BOM

32비트 바이트 순서 마크는 호스트 머신의 기본 바이트 순서를 나타냅니다. 리틀 엔디안 머신은 값 0x04030201을 포함합니다. 빅 엔디안 머신은 값 0x01020304을 포함합니다.