Strings

AbstractString 타입은 Julia의 모든 문자열 구현의 슈퍼타입입니다. 문자열은 AbstractChar 타입으로 표현된 Unicode 코드 포인트의 시퀀스를 인코딩한 것입니다. Julia는 문자열에 대해 몇 가지 가정을 합니다:

• 문자열은 고정 크기 "코드 유닛"으로 인코딩됩니다.

  • 코드 유닛은 codeunit(s, i)로 추출할 수 있습니다.
  • 첫 번째 코드 유닛의 인덱스는 1입니다.
  • 마지막 코드 유닛의 인덱스는 ncodeunits(s)입니다.
  • 1 ≤ i ≤ ncodeunits(s)인 모든 인덱스 i는 유효한 범위에 있습니다.

• 문자열 인덱싱은 이러한 코드 유닛을 기준으로 수행됩니다:

  • 문자는 유효한 문자열 인덱스 i로 s[i]를 통해 추출됩니다.
  • 문자열의 각 AbstractChar는 하나 이상의 코드 유닛으로 인코딩됩니다.
  • AbstractChar의 첫 번째 코드 유닛의 인덱스만 유효한 인덱스입니다.
  • AbstractChar의 인코딩은 그 앞이나 뒤에 무엇이 오는지와는 독립적입니다.
  • 문자열 인코딩은 자기 동기화됩니다 – 즉, isvalid(s, i)는 O(1)입니다.

코드 유닛, 문자 또는 부분 문자열을 문자열에서 추출하는 일부 문자열 함수는 범위를 벗어나거나 유효하지 않은 문자열 인덱스를 전달하면 오류를 발생시킵니다. 여기에는 codeunit(s, i)와 s[i]가 포함됩니다. 문자열 인덱스 산술을 수행하는 함수는 인덱싱에 대해 더 느슨한 접근 방식을 취하며, 범위 내에서는 가장 가까운 유효한 문자열 인덱스를 제공하거나, 범위를 벗어날 경우 문자열의 양쪽에 무한한 수의 문자가 패딩된 것처럼 동작합니다. 일반적으로 이러한 상상의 패딩 문자는 코드 유닛 길이가 1이지만, 문자열 타입은 구현에 맞게 다른 "상상의" 문자 크기를 선택할 수 있습니다 (예: 부분 문자열은 제공하는 기본 문자열에 대한 인덱스 산술을 통과시킬 수 있습니다). 느슨한 인덱싱 함수에는 인덱스 산술을 위한 함수인 thisind, nextind 및 prevind가 포함됩니다. 이 모델은 인덱스 산술이 범위를 벗어난 인덱스를 중간 값으로 사용할 수 있도록 하여, 문자를 검색하는 데 사용하지 않는 한, 엣지 케이스를 피하는 데 도움이 됩니다.

또한 codeunit, ncodeunits, thisind, nextind, prevind를 참조하십시오.

AbstractChar 타입은 Julia의 모든 문자 구현의 수퍼타입입니다. 문자는 유니코드 코드 포인트를 나타내며, codepoint 함수를 통해 정수로 변환하여 코드 포인트의 수치 값을 얻거나 동일한 정수로부터 생성할 수 있습니다. 이러한 수치 값은 문자가 < 및 ==와 같은 연산자로 비교되는 방식을 결정합니다. 새로운 T <: AbstractChar 타입은 최소한 codepoint(::T) 메서드와 T(::UInt32) 생성자를 정의해야 합니다.

주어진 AbstractChar 서브타입은 유니코드의 하위 집합만 표현할 수 있으며, 이 경우 지원되지 않는 UInt32 값으로부터의 변환은 오류를 발생시킬 수 있습니다. 반대로, 내장된 Char 타입은 유니코드를 포함하는 집합을 나타내며(유효하지 않은 바이트 스트림을 손실 없이 인코딩하기 위해), 이 경우 비유니코드 값을 UInt32로 변환하면 오류가 발생합니다. isvalid 함수는 주어진 AbstractChar 타입에서 어떤 코드 포인트가 표현 가능한지를 확인하는 데 사용할 수 있습니다.

내부적으로, AbstractChar 타입은 다양한 인코딩을 사용할 수 있습니다. codepoint(char)를 통한 변환은 항상 문자의 유니코드 값을 반환하기 때문에 이 인코딩을 드러내지 않습니다. print(io, c)는 모든 c::AbstractChar에 대해 io에 의해 결정된 인코딩(모든 내장 IO 타입에 대해 UTF-8)을 생성하며, 필요할 경우 Char로 변환합니다.

반면에 write(io, c)는 typeof(c)에 따라 인코딩을 발생시킬 수 있으며, read(io, typeof(c))는 write와 동일한 인코딩을 읽어야 합니다. 새로운 AbstractChar 타입은 write와 read의 자체 구현을 제공해야 합니다.

Char(c::Union{Number,AbstractChar})

Char는 Julia에서 문자의 기본 표현인 32비트 AbstractChar 타입입니다. Char는 'x'와 같은 문자 리터럴에 사용되는 타입이며, String의 요소 타입이기도 합니다.

String에 저장된 임의의 바이트 스트림을 손실 없이 표현하기 위해, Char 값은 유니코드 코드 포인트로 변환할 수 없는 정보를 저장할 수 있습니다 — 그러한 Char를 UInt32로 변환하면 오류가 발생합니다. isvalid(c::Char) 함수는 c가 유효한 유니코드 문자를 나타내는지 여부를 쿼리하는 데 사용할 수 있습니다.

codepoint(c::AbstractChar) -> Integer

문자 c에 해당하는 유니코드 코드 포인트(부호 없는 정수)를 반환합니다(또는 c가 유효한 문자를 나타내지 않는 경우 예외를 발생시킵니다). Char의 경우, 이는 UInt32 값이지만, 유니코드의 일부만 나타내는 AbstractChar 유형은 다른 크기의 정수를 반환할 수 있습니다(예: UInt8).

length(s::AbstractString) -> Int
length(s::AbstractString, i::Integer, j::Integer) -> Int

문자열 s의 인덱스 i에서 j까지의 문자 수를 반환합니다.

이는 i에서 j까지의 유효한 문자 인덱스인 코드 유닛 인덱스의 수로 계산됩니다. 단일 문자열 인수만 있는 경우, 전체 문자열의 문자 수를 계산합니다. i와 j 인수가 있는 경우, 문자열 s에서 유효한 인덱스인 i와 j 사이의 인덱스 수를 계산합니다. 범위 내 값 외에도, i는 범위를 벗어난 값 ncodeunits(s) + 1을 가질 수 있으며, j는 범위를 벗어난 값 0을 가질 수 있습니다.

또한 isvalid, ncodeunits, lastindex, thisind, nextind, prevind를 참조하십시오.

예제

julia> length("jμΛIα")
5

sizeof(str::AbstractString)

문자열 str의 크기(바이트 단위). str의 코드 유닛 수에 str의 코드 유닛 하나의 크기(바이트 단위)를 곱한 값과 같습니다.

예제

julia> sizeof("")
0

julia> sizeof("∀")
3

*(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString

문자열 및/또는 문자를 연결하여 String 또는 AnnotatedString (적절한 경우) 를 생성합니다. 이는 인수에 대해 string 또는 annotatedstring 함수를 호출하는 것과 동일합니다. 내장 문자열 유형의 연결은 항상 String 유형의 값을 생성하지만, 다른 문자열 유형은 적절한 경우 다른 유형의 문자열을 반환하도록 선택할 수 있습니다.

예제

julia> "Hello " * "world"
"Hello world"

julia> 'j' * "ulia"
"julia"

^(s::Union{AbstractString,AbstractChar}, n::Integer) -> AbstractString

문자열 또는 문자를 n 번 반복합니다. 이것은 repeat(s, n)으로도 작성할 수 있습니다.

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

예제

julia> "Test "^3
"Test Test Test "

string(n::Integer; base::Integer = 10, pad::Integer = 1)

정수 n을 주어진 base의 문자열로 변환하며, 선택적으로 패딩할 자릿수를 지정할 수 있습니다.

자세한 내용은 digits, bitstring, count_zeros를 참조하세요.

예제

julia> string(5, base = 13, pad = 4)
"0005"

julia> string(-13, base = 5, pad = 4)
"-0023"

string(xs...)

어떤 값으로부터 문자열을 생성하려면 print 함수를 사용하세요.

string은 일반적으로 직접 정의하지 않아야 합니다. 대신, print(io::IO, x::MyType) 메서드를 정의하세요. 특정 타입에 대해 string(x)가 매우 효율적이어야 하는 경우, string에 메서드를 추가하고 print(io::IO, x::MyType) = print(io, string(x))를 정의하여 함수들이 일관성을 유지하도록 하는 것이 좋습니다.

또한 참고하세요: String, repr, sprint, show.

예제

julia> string("a", 1, true)
"a1true"

repeat(s::AbstractString, r::Integer)

문자열을 r 번 반복합니다. 이는 s^r로 작성할 수 있습니다.

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

예제

julia> repeat("ha", 3)
"hahaha"

repeat(c::AbstractChar, r::Integer) -> String

문자를 r 번 반복합니다. 이는 c^r를 호출하여 동일하게 수행할 수 있습니다.

예제

julia> repeat('A', 3)
"AAA"

repr(x; context=nothing)

어떤 값으로부터 문자열을 생성하려면 show 함수를 사용하세요. repr에 메서드를 추가하지 말고 대신 show 메서드를 정의해야 합니다.

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

repr(x)는 일반적으로 x의 값이 Julia에서 입력되는 방식과 유사합니다. 또한 repr(MIME("text/plain"), x)를 참조하여 x의 "예쁘게 출력된" 버전을 반환할 수 있으며, 이는 x의 REPL 표시와 동등합니다.

예제

julia> repr(1)
"1"

julia> repr(zeros(3))
"[0.0, 0.0, 0.0]"

julia> repr(big(1/3))
"0.333333333333333314829616256247390992939472198486328125"

julia> repr(big(1/3), context=:compact => true)
"0.333333"

String(s::AbstractString)

기존 AbstractString에서 새로운 String을 생성합니다.

SubString(s::AbstractString, i::Integer, j::Integer=lastindex(s))
SubString(s::AbstractString, r::UnitRange{<:Integer})

getindex와 유사하지만, 복사본을 만드는 대신 범위 i:j 또는 r 내에서 부모 문자열 s에 대한 뷰를 반환합니다.

@views 매크로는 코드 블록 내의 모든 문자열 슬라이스 s[i:j]를 서브스트링 SubString(s, i, j)으로 변환합니다.

예제

julia> SubString("abc", 1, 2)
"ab"

julia> SubString("abc", 1:2)
"ab"

julia> SubString("abc", 2)
"bc"

LazyString <: AbstractString

문자열 보간의 지연 표현입니다. 이는 문자열이 실제 보간 및 문자열 구성이 불필요하거나 바람직하지 않은 상황에서 구성되어야 할 때 유용합니다(예: 함수의 오류 경로에서).

이 유형은 런타임에 생성하는 데 비용이 적도록 설계되었으며, 가능한 한 많은 작업을 매크로 또는 나중에 인쇄 작업으로 오프로드하려고 합니다.

예제

julia> n = 5; str = LazyString("n is ", n)
"n is 5"

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

확장 도움말

동시 프로그램을 위한 안전 속성

지연 문자열 자체는 여러 Julia 작업에서 인쇄되더라도 동시성 문제를 일으키지 않습니다. 그러나 캡처된 값에 대한 print 메서드가 동기화 없이 호출될 경우 동시성 문제가 발생할 수 있으며, 지연 문자열을 인쇄하는 것이 문제를 일으킬 수 있습니다. 또한, 캡처된 값에 대한 print 메서드는 여러 번 호출될 수 있지만, 정확히 하나의 결과만 반환됩니다.

lazy"str"

정규 문자열 보간법을 사용하여 LazyString를 생성합니다. 보간은 LazyString 생성 시점에 평가되지만, 문자열에 대한 첫 번째 접근이 있을 때까지 출력은 지연됩니다.

동시 프로그램에 대한 안전성 속성에 대한 LazyString 문서를 참조하십시오.

예제

julia> n = 5; str = lazy"n is $n"
"n is 5"

julia> typeof(str)
LazyString

transcode(T, src)

문자열 데이터를 유니코드 인코딩 간에 변환합니다. src는 String 또는 UTF-XX 코드 유닛의 Vector{UIntXX}로, 여기서 XX는 8, 16 또는 32입니다. T는 반환 값의 인코딩을 나타냅니다: String은 (UTF-8 인코딩된) String을 반환하고, UIntXX는 UTF-XX 데이터의 Vector{UIntXX}를 반환합니다. (별칭 Cwchar_t도 외부 C 라이브러리에서 사용되는 wchar_t* 문자열을 변환하는 데 사용할 수 있는 정수형입니다.)

transcode 함수는 입력 데이터가 대상 인코딩에서 합리적으로 표현될 수 있는 한 성공합니다. 유효하지 않은 유니코드 데이터에 대해서도 UTF-XX 인코딩 간의 변환은 항상 성공합니다.

현재 UTF-8로의 변환만 지원됩니다.

예제

julia> str = "αβγ"
"αβγ"

julia> transcode(UInt16, str)
3-element Vector{UInt16}:
 0x03b1
 0x03b2
 0x03b3

julia> transcode(String, transcode(UInt16, str))
"αβγ"

unsafe_string(p::Ptr{UInt8}, [length::Integer])

C 스타일(NUL로 종료된) 문자열의 주소에서 UTF-8로 인코딩된 문자열을 복사합니다. (포인터는 이후에 안전하게 해제할 수 있습니다.) length가 지정된 경우(바이트 단위의 데이터 길이), 문자열은 NUL로 종료될 필요가 없습니다.

이 함수는 p가 요청된 길이의 데이터에 대한 유효한 메모리 주소가 아닐 경우 충돌할 수 있기 때문에 "unsafe"로 표시됩니다.

ncodeunits(s::AbstractString) -> Int

문자열의 코드 유닛 수를 반환합니다. 이 문자열에 접근하기 위한 인덱스는 1 ≤ i ≤ ncodeunits(s)를 만족해야 합니다. 이러한 인덱스가 모두 유효한 것은 아니며, 문자 시작이 아닐 수도 있지만 codeunit(s,i)를 호출할 때 코드 유닛 값을 반환합니다.

예제

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

julia> ncodeunits('∫'), ncodeunits('e'), ncodeunits('ˣ')
(3, 1, 2)

또한 codeunit, checkbounds, sizeof, length, lastindex를 참조하세요.

codeunit(s::AbstractString) -> Type{<:Union{UInt8, UInt16, UInt32}}

주어진 문자열 객체의 코드 유닛 유형을 반환합니다. ASCII, Latin-1 또는 UTF-8 인코딩 문자열의 경우 UInt8이 됩니다. UCS-2 및 UTF-16의 경우 UInt16이 되고, UTF-32의 경우 UInt32가 됩니다. 코드 유닛 유형은 이 세 가지 유형으로 제한될 필요는 없지만, 이들 유닛 중 하나를 사용하지 않는 널리 사용되는 문자열 인코딩을 생각하기는 어렵습니다. codeunit(s)는 s가 비어 있지 않은 문자열일 때 typeof(codeunit(s,1))와 동일합니다.

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

codeunit(s::AbstractString, i::Integer) -> Union{UInt8, UInt16, UInt32}

문자열 s에서 인덱스 i에 있는 코드 유닛 값을 반환합니다. 다음과 같은 점에 유의하세요.

codeunit(s, i) :: codeunit(s)

즉, codeunit(s, i)가 반환하는 값은 codeunit(s)가 반환하는 타입입니다.

예제

julia> a = codeunit("Hello", 2)
0x65

julia> typeof(a)
UInt8

또한 ncodeunits, checkbounds를 참조하세요.

codeunits(s::AbstractString)

문자열의 코드 유닛을 포함하는 벡터와 유사한 객체를 얻습니다. 기본적으로 CodeUnits 래퍼를 반환하지만, 필요에 따라 새로운 문자열 유형에 대해 codeunits를 선택적으로 정의할 수 있습니다.

예제

julia> codeunits("Juλia")
6-element Base.CodeUnits{UInt8, String}:
 0x4a
 0x75
 0xce
 0xbb
 0x69
 0x61

ascii(s::AbstractString)

문자열을 String 유형으로 변환하고 ASCII 데이터만 포함되어 있는지 확인합니다. 그렇지 않은 경우 첫 번째 비ASCII 바이트의 위치를 나타내는 ArgumentError를 발생시킵니다.

비ASCII 문자를 필터링하거나 교체하기 위한 isascii 술어도 참조하십시오.

예제

julia> ascii("abcdeγfgh")
ERROR: ArgumentError: invalid ASCII at index 6 in "abcdeγfgh"
Stacktrace:
[...]

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags]) <: AbstractPattern

정규 표현식을 나타내는 타입입니다. Regex 객체는 match와 함께 문자열을 일치시키는 데 사용할 수 있습니다.

Regex 객체는 @r_str 문자열 매크로를 사용하여 생성할 수 있습니다. pattern 문자열을 보간해야 하는 경우 일반적으로 Regex(pattern[, flags]) 생성자를 사용합니다. 플래그에 대한 자세한 내용은 문자열 매크로의 문서를 참조하십시오.

@r_str -> Regex

정규 표현식을 구성합니다. 예를 들어 r"^[a-z]*$"와 같이 보간 및 이스케이프 해제 없이 구성합니다(따옴표 "는 여전히 이스케이프해야 함). 정규 표현식은 동작을 변경하기 위해 끝나는 따옴표 뒤에 나열된 하나 이상의 플래그를 허용합니다:

• i는 대소문자를 구분하지 않는 매칭을 활성화합니다.
• m은 ^ 및 $ 토큰이 전체 문자열이 아닌 개별 행의 시작과 끝을 매칭하도록 처리합니다.
• s는 . 수정자가 줄 바꿈을 매칭하도록 허용합니다.
• x는 "자유 간격 모드"를 활성화합니다: 정규 표현식 토큰 사이의 공백은 이스케이프된 \를 제외하고 무시되며, 정규 표현식의 #는 주석을 시작하는 것으로 간주되어 줄 끝까지 무시됩니다.
• a는 ASCII 모드를 활성화합니다(UTF 및 UCP 모드를 비활성화). 기본적으로 \B, \b, \D, \d, \S, \s, \W, \w 등은 유니코드 문자 속성을 기반으로 매칭됩니다. 이 옵션을 사용하면 이러한 시퀀스는 ASCII 문자만 매칭합니다. 여기에는 \u도 포함되며, 이는 지정된 문자 값을 단일 바이트로 직접 출력하고 UTF-8로 인코딩하려고 시도하지 않습니다. 중요하게도, 이 옵션은 매처와 대상을 단순 바이트로 취급하여 유효하지 않은 UTF-8 문자열에 대해 매칭할 수 있도록 하며(마치 ISO/IEC 8859-1 / Latin-1 바이트인 것처럼) 문자 인코딩이 아닌 바이트로 취급합니다. 이 경우, 이 옵션은 종종 s와 결합됩니다. 이 옵션은 패턴을 (UCP) 또는 (UTF)로 시작하여 더 세분화할 수 있습니다.

보간이 필요한 경우 Regex를 참조하십시오.

예시

julia> match(r"a+.*b+.*?d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
RegexMatch("angry,\nBad world")

이 정규 표현식은 처음 세 개의 플래그가 활성화되어 있습니다.

SubstitutionString(substr) <: AbstractString

주어진 문자열 substr을 SubstitutionString으로 저장하여 정규 표현식 치환에 사용합니다. 가장 일반적으로 @s_str 매크로를 사용하여 생성됩니다.

예제

julia> SubstitutionString("Hello \\g<name>, it's \\1")
s"Hello \g<name>, it's \1"

julia> subst = s"Hello \g<name>, it's \1"
s"Hello \g<name>, it's \1"

julia> typeof(subst)
SubstitutionString{String}

@s_str -> SubstitutionString

정규 표현식 치환에 사용되는 치환 문자열을 생성합니다. 문자열 내에서 \N 형식의 시퀀스는 정규 표현식의 N번째 캡처 그룹을 참조하고, \g<groupname>은 이름이 groupname인 명명된 캡처 그룹을 참조합니다.

예제

julia> msg = "#Hello# from Julia";

julia> replace(msg, r"#(.+)# from (?<from>\w+)" => s"FROM: \g<from>; MESSAGE: \1")
"FROM: Julia; MESSAGE: Hello"

@raw_str -> String

보간 및 이스케이프 없이 원시 문자열을 생성합니다. 예외는 따옴표가 여전히 이스케이프되어야 한다는 것입니다. 백슬래시는 따옴표 문자 앞에 백슬래시 시퀀스가 있을 때만 따옴표와 다른 백슬래시를 이스케이프합니다. 따라서 2n 개의 백슬래시 뒤에 따옴표가 오면 n 개의 백슬래시와 리터럴의 끝을 인코딩하고, 2n+1 개의 백슬래시 뒤에 따옴표가 오면 n 개의 백슬래시 뒤에 따옴표 문자가 인코딩됩니다.

예시

julia> println(raw"\ $x")
\ $x

julia> println(raw"\"")
"

julia> println(raw"\\\"")
\"

julia> println(raw"\\x \\\"")
\\x \"

@b_str

문자열 구문을 사용하여 불변 바이트(UInt8) 벡터를 만듭니다.

예제

julia> v = b"12\x01\x02"
4-element Base.CodeUnits{UInt8, String}:
 0x31
 0x32
 0x01
 0x02

julia> v[2]
0x32

@html_str -> Docs.HTML

리터럴 문자열로부터 HTML 객체를 생성합니다.

예제

julia> html"Julia"
HTML{String}("Julia")

@text_str -> Docs.Text

리터럴 문자열로부터 Text 객체를 생성합니다.

예시

julia> text"Julia"
Julia

isvalid(value) -> Bool

주어진 값이 현재 AbstractChar 또는 String 또는 SubString{String}일 수 있는 해당 유형에 대해 유효하면 true를 반환합니다.

예시

julia> isvalid(Char(0xd800))
false

julia> isvalid(SubString(String(UInt8[0xfe,0x80,0x80,0x80,0x80,0x80]),1,2))
false

julia> isvalid(Char(0xd799))
true

isvalid(T, value) -> Bool

주어진 값이 해당 유형에 대해 유효하면 true를 반환합니다. 현재 유형은 AbstractChar 또는 String일 수 있습니다. AbstractChar의 값은 AbstractChar 유형이거나 UInt32일 수 있습니다. String의 값은 해당 유형, SubString{String}, Vector{UInt8} 또는 그 연속 하위 배열일 수 있습니다.

예시

julia> isvalid(Char, 0xd800)
false

julia> isvalid(String, SubString("thisisvalid",1,5))
true

julia> isvalid(Char, 0xd799)
true

isvalid(s::AbstractString, i::Integer) -> Bool

주어진 인덱스가 s에서 문자의 인코딩 시작인지 여부를 나타내는 술어입니다. isvalid(s, i)가 true이면 s[i]는 해당 인덱스에서 인코딩이 시작되는 문자를 반환하고, false이면 s[i]는 유효하지 않은 인덱스 오류 또는 i가 범위 내에 있는지에 따라 경계 오류를 발생시킵니다. isvalid(s, i)가 O(1) 함수가 되기 위해서는 s의 인코딩이 자기 동기화되어야 합니다. 이는 Julia의 일반 문자열 지원에 대한 기본 가정입니다.

또한 getindex, iterate, thisind, nextind, prevind, length를 참조하십시오.

예제

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (category Ll: Letter, lowercase)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: invalid index [2], valid nearby indices [1]=>'α', [3]=>'β'
Stacktrace:
[...]

match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])

정규 표현식 r의 첫 번째 일치를 s에서 검색하고, 일치하는 경우를 포함하는 RegexMatch 객체를 반환합니다. 일치하지 않으면 아무것도 반환하지 않습니다. 일치하는 하위 문자열은 m.match에 접근하여 검색할 수 있으며, 캡처된 시퀀스는 m.captures에 접근하여 검색할 수 있습니다. 선택적 idx 인수는 검색을 시작할 인덱스를 지정합니다.

예제

julia> rx = r"a(.)a"
r"a(.)a"

julia> m = match(rx, "cabac")
RegexMatch("aba", 1="b")

julia> m.captures
1-element Vector{Union{Nothing, SubString{String}}}:
 "b"

julia> m.match
"aba"

julia> match(rx, "cabac", 3) === nothing
true

eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)

정규 표현식 r의 모든 일치를 문자열 s에서 검색하고 일치 항목에 대한 반복자를 반환합니다. overlap이 true인 경우, 일치하는 시퀀스는 원래 문자열의 인덱스에서 겹칠 수 있지만, 그렇지 않은 경우에는 서로 다른 문자 범위에서 가져와야 합니다.

예제

julia> rx = r"a.a"
r"a.a"

julia> m = eachmatch(rx, "a1a2a3a")
Base.RegexMatchIterator{String}(r"a.a", "a1a2a3a", false)

julia> collect(m)
2-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a3a")

julia> collect(eachmatch(rx, "a1a2a3a", overlap = true))
3-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a2a")
 RegexMatch("a3a")

RegexMatch <: AbstractMatch

문자열에서 발견된 Regex에 대한 단일 일치를 나타내는 유형입니다. 일반적으로 match 함수에서 생성됩니다.

match 필드는 전체 일치하는 문자열의 부분 문자열을 저장합니다. captures 필드는 숫자로 인덱싱된 각 캡처 그룹의 부분 문자열을 저장합니다. 캡처 그룹 이름으로 인덱싱하려면 전체 일치 객체를 대신 인덱싱해야 하며, 예제에서 보여줍니다. 일치의 시작 위치는 offset 필드에 저장됩니다. offsets 필드는 각 캡처 그룹의 시작 위치를 저장하며, 0은 캡처되지 않은 그룹을 나타냅니다.

이 유형은 Regex의 캡처 그룹에 대한 반복자로 사용될 수 있으며, 각 그룹에서 캡처된 부분 문자열을 생성합니다. 이로 인해 일치의 캡처를 구조 분해할 수 있습니다. 그룹이 캡처되지 않은 경우 부분 문자열 대신 nothing이 생성됩니다.

RegexMatch 객체를 수용하는 메서드는 iterate, length, eltype, keys, haskey, 및 getindex에 대해 정의되어 있으며, 여기서 키는 캡처 그룹의 이름 또는 번호입니다. 더 많은 정보는 keys를 참조하십시오.

예제

julia> m = match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30 in the morning")
RegexMatch("11:30", hour="11", minute="30", 3=nothing)

julia> m.match
"11:30"

julia> m.captures
3-element Vector{Union{Nothing, SubString{String}}}:
 "11"
 "30"
 nothing


julia> m["minute"]
"30"

julia> hr, min, ampm = m; # 캡처 그룹을 반복하여 구조 분해

julia> hr
"11"

keys(m::RegexMatch) -> Vector

모든 캡처 그룹에 대한 키의 벡터를 반환합니다. 키는 캡처 그룹이 일치하지 않더라도 포함됩니다. 즉, idx는 m[idx] == nothing인 경우에도 반환 값에 포함됩니다.

이름이 없는 캡처 그룹은 해당 인덱스에 해당하는 정수 키를 가집니다. 이름이 있는 캡처 그룹은 문자열 키를 가집니다.

예제

julia> keys(match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30"))
3-element Vector{Any}:
  "hour"
  "minute"
 3

isless(a::AbstractString, b::AbstractString) -> Bool

문자열 a가 문자열 b보다 알파벳 순서(정확히는 유니코드 코드 포인트에 의한 사전 순서)에서 먼저 오는지 테스트합니다.

예제

julia> isless("a", "b")
true

julia> isless("β", "α")
false

julia> isless("a", "a")
false

==(a::AbstractString, b::AbstractString) -> Bool

두 문자열이 문자 단위(기술적으로는 유니코드 코드 포인트 단위)로 같은지 테스트합니다. 두 문자열 중 하나가 AnnotatedString인 경우 문자열 속성도 일치해야 합니다.

예시

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

cmp(a::AbstractString, b::AbstractString) -> Int

두 문자열을 비교합니다. 두 문자열의 길이가 같고 각 인덱스의 문자가 두 문자열에서 동일하면 0을 반환합니다. a가 b의 접두사이거나 a가 알파벳 순서에서 b보다 앞에 오면 -1을 반환합니다. b가 a의 접두사이거나 b가 알파벳 순서에서 a보다 앞에 오면 1을 반환합니다(기술적으로는 유니코드 코드 포인트에 의한 사전식 순서).

예제

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

lpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

s를 문자열로 변환하고 결과 문자열을 p로 왼쪽에 패딩하여 n자( textwidth ) 길이가 되도록 합니다. 만약 s가 이미 n자 길이라면, 동일한 문자열이 반환됩니다. 기본적으로 공백으로 패딩합니다.

예제

julia> lpad("March", 10)
"     March"

rpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

s를 문자열로 변환하고 결과 문자열의 오른쪽에 p로 패딩하여 n 문자( textwidth ) 길이를 만듭니다. 만약 s가 이미 n 문자 길이라면, 동일한 문자열이 반환됩니다. 기본적으로 공백으로 패딩합니다.

예제

julia> rpad("March", 20)
"March               "

findfirst(pattern::AbstractString, string::AbstractString)
findfirst(pattern::AbstractPattern, string::String)

string에서 pattern의 첫 번째 발생을 찾습니다. findnext(pattern, string, firstindex(s))와 동등합니다.

예제

julia> findfirst("z", "Hello to the world") # 아무것도 반환하지 않지만 REPL에 출력되지 않음

julia> findfirst("Julia", "JuliaLang")
1:5

findnext(pattern::AbstractString, string::AbstractString, start::Integer)
findnext(pattern::AbstractPattern, string::String, start::Integer)

string에서 start 위치에서 시작하여 pattern의 다음 발생을 찾습니다. pattern은 문자열이거나 정규 표현식일 수 있으며, 이 경우 string은 String 유형이어야 합니다.

반환 값은 일치하는 시퀀스가 발견된 인덱스의 범위로, s[findnext(x, s, i)] == x가 성립합니다:

findnext("substring", string, i) == start:stop로, string[start:stop] == "substring"이고 i <= start이거나, 일치하지 않으면 nothing입니다.

예제

julia> findnext("z", "Hello to the world", 1) === nothing
true

julia> findnext("o", "Hello to the world", 6)
8:8

julia> findnext("Lang", "JuliaLang", 2)
6:9

findnext(ch::AbstractChar, string::AbstractString, start::Integer)

문자 ch의 다음 발생을 start 위치에서 시작하여 string에서 찾습니다.

예제

julia> findnext('z', "Hello to the world", 1) === nothing
true

julia> findnext('o', "Hello to the world", 6)
8

findlast(pattern::AbstractString, string::AbstractString)

string에서 pattern의 마지막 발생을 찾습니다. findprev(pattern, string, lastindex(string))와 동일합니다.

예제

julia> findlast("o", "Hello to the world")
15:15

julia> findfirst("Julia", "JuliaLang")
1:5

findlast(ch::AbstractChar, string::AbstractString)

문자 ch의 마지막 발생을 string에서 찾습니다.

예제

julia> findlast('p', "happy")
4

julia> findlast('z', "happy") === nothing
true

findprev(pattern::AbstractString, string::AbstractString, start::Integer)

string에서 start 위치에서 시작하여 pattern의 이전 발생을 찾습니다.

반환 값은 일치하는 시퀀스가 발견된 인덱스의 범위로, s[findprev(x, s, i)] == x가 성립합니다:

findprev("substring", string, i) == start:stop로, string[start:stop] == "substring"이고 stop <= i이거나, 일치하지 않으면 nothing입니다.

예제

julia> findprev("z", "Hello to the world", 18) === nothing
true

julia> findprev("o", "Hello to the world", 18)
15:15

julia> findprev("Julia", "JuliaLang", 6)
1:5

occursin(needle::Union{AbstractString,AbstractPattern,AbstractChar}, haystack::AbstractString)

두 번째 인수의 부분 문자열인지 첫 번째 인수를 확인합니다. needle이 정규 표현식인 경우, haystack에 일치하는 항목이 있는지 확인합니다.

예제

julia> occursin("Julia", "JuliaLang is pretty cool!")
true

julia> occursin('a', "JuliaLang is pretty cool!")
true

julia> occursin(r"a.a", "aba")
true

julia> occursin(r"a.a", "abba")
false

또한 contains를 참조하십시오.

occursin(haystack)

haystack에서 인수가 발생하는지 확인하는 함수를 만듭니다. 즉, needle -> occursin(needle, haystack)와 동등한 함수입니다.

반환된 함수는 Base.Fix2{typeof(occursin)} 유형입니다.

예제

julia> search_f = occursin("JuliaLang is a programming language");

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

문자열을 뒤집습니다. 기술적으로 이 함수는 문자열의 코드 포인트를 뒤집으며, 주된 용도는 뒤집힌 순서의 문자열 처리, 특히 뒤집힌 정규 표현식 검색을 위한 것입니다. s의 인덱스를 reverse(s)의 인덱스로 변환하고 그 반대의 경우도 처리하기 위해 reverseind를 참조하십시오. 또한 코드 포인트가 아닌 사용자 가시 "문자"(그래프)에 대해 작업하기 위해 Unicode 모듈의 graphemes를 참조하십시오. 복사 없이 역순 반복을 위해 Iterators.reverse도 참조하십시오. 사용자 정의 문자열 유형은 reverse 함수를 직접 구현해야 하며, 일반적으로 동일한 유형과 인코딩의 문자열을 반환해야 합니다. 다른 인코딩의 문자열을 반환하는 경우, s[reverseind(s,i)] == reverse(s)[i]를 만족시키기 위해 해당 문자열 유형에 대해 reverseind도 재정의해야 합니다.

예제

julia> reverse("JuliaLang")
"gnaLailuJ"

결합 문자는 놀라운 결과를 초래할 수 있습니다:

julia> reverse("ax̂e") # 모자는 입력에서는 x 위에, 출력에서는 e 위에 있습니다.
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # 그래프를 뒤집습니다; 모자는 입력과 출력 모두에서 x 위에 있습니다.
"ex̂a"

replace([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])

주어진 패턴 pat을 s에서 검색하고 각 발생을 r로 교체합니다. count가 제공되면 최대 count 개의 발생만 교체합니다. pat은 단일 문자, 벡터 또는 문자 집합, 문자열 또는 정규 표현식일 수 있습니다. 만약 r이 함수라면, 각 발생은 r(s)로 교체되며 여기서 s는 일치하는 하위 문자열(이때 pat이 AbstractPattern 또는 AbstractString인 경우) 또는 문자(이때 pat이 AbstractChar 또는 AbstractChar의 모음인 경우)입니다. 만약 pat이 정규 표현식이고 r이 SubstitutionString이라면, r의 캡처 그룹 참조는 해당 일치하는 텍스트로 교체됩니다. string에서 pat의 인스턴스를 제거하려면 r을 빈 String("")으로 설정합니다.

반환 값은 교체 후의 새로운 문자열입니다. io::IO 인수가 제공되면 변환된 문자열이 대신 io에 기록됩니다(즉, io를 반환). (예를 들어, 이는 IOBuffer와 함께 사용되어 미리 할당된 버퍼 배열을 제자리에서 재사용하는 데 사용할 수 있습니다.)

여러 패턴을 지정할 수 있으며, 이들은 왼쪽에서 오른쪽으로 동시에 적용되므로, 어떤 문자에도 하나의 패턴만 적용되며, 패턴은 입력 텍스트에만 적용되고 교체에는 적용되지 않습니다.

예제

julia> replace("Python is a programming language.", "Python" => "Julia")
"Julia is a programming language."

julia> replace("The quick foxes run quickly.", "quick" => "slow", count=1)
"The slow foxes run quickly."

julia> replace("The quick foxes run quickly.", "quick" => "", count=1)
"The  foxes run quickly."

julia> replace("The quick foxes run quickly.", r"fox(es)?" => s"bus\1")
"The quick buses run quickly."

julia> replace("abcabc", "a" => "b", "b" => "c", r".+" => "a")
"bca"

eachsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

str를 구분자 dlm의 발생에 따라 나누고 부분 문자열에 대한 반복자를 반환합니다. dlm은 findnext의 첫 번째 인수로 허용되는 형식(즉, 문자열, 정규 표현식 또는 함수) 중 하나이거나 단일 문자 또는 문자 모음일 수 있습니다.

dlm이 생략되면 기본값은 isspace입니다.

선택적 키워드 인수는 다음과 같습니다:

• limit: 결과의 최대 크기. limit=0은 최대 없음(기본값)을 의미합니다.
• keepempty: 빈 필드를 결과에 포함할지 여부. dlm 인수가 없으면 기본값은 false, dlm 인수가 있으면 true입니다.

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

예제

julia> a = "Ma.rch"
"Ma.rch"

julia> b = eachsplit(a, ".")
Base.SplitIterator{String, String}("Ma.rch", ".", 0, true)

julia> collect(b)
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

eachrsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachrsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

str를 구분 기호 dlm으로 나누어 생성된 SubString의 반복자를 반환하며, 결과는 역순(오른쪽에서 왼쪽으로)으로 제공됩니다. dlm은 findprev의 첫 번째 인수로 허용되는 형식(즉, 문자열, 단일 문자 또는 함수) 중 하나이거나 문자 집합일 수 있습니다.

dlm이 생략되면 기본값은 isspace이며, keepempty의 기본값은 false입니다.

선택적 키워드 인수는 다음과 같습니다:

• limit > 0인 경우, 반복자는 최대 limit - 1회만 나누고 나머지 문자열은 나누지 않고 반환합니다. limit < 1은 나누기에 대한 제한이 없음을 의미합니다(기본값).
• keepempty: 반복할 때 빈 필드를 반환할지 여부 기본값은 dlm 인수가 없는 경우 false, dlm 인수가 있는 경우 true입니다.

split와는 달리, rsplit 및 eachsplit와 이 함수는 입력에서 발생하는 대로 부분 문자열을 오른쪽에서 왼쪽으로 반복합니다.

또한 eachsplit, rsplit를 참조하십시오.

예제

julia> a = "Ma.r.ch";

julia> collect(eachrsplit(a, ".")) == ["ch", "r", "Ma"]
true

julia> collect(eachrsplit(a, "."; limit=2)) == ["ch", "Ma.r"]
true

split(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
split(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

str를 구분자 dlm의 발생에 따라 부분 문자열의 배열로 나눕니다. dlm은 findnext의 첫 번째 인수로 허용되는 형식(즉, 문자열, 정규 표현식 또는 함수) 중 하나이거나 단일 문자 또는 문자 집합일 수 있습니다.

dlm이 생략되면 기본값은 isspace입니다.

선택적 키워드 인수는 다음과 같습니다:

• limit: 결과의 최대 크기. limit=0은 최대 크기가 없음을 의미합니다(기본값).
• keepempty: 빈 필드를 결과에 포함할지 여부. dlm 인수가 없으면 기본값은 false, dlm 인수가 있으면 true입니다.

또한 rsplit, eachsplit를 참조하십시오.

예제

julia> a = "Ma.rch"
"Ma.rch"

julia> split(a, ".")
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

rsplit(s::AbstractString; limit::Integer=0, keepempty::Bool=false)
rsplit(s::AbstractString, chars; limit::Integer=0, keepempty::Bool=true)

문자열의 끝에서부터 시작하는 split와 유사합니다.

예제

julia> a = "M.a.r.c.h"
"M.a.r.c.h"

julia> rsplit(a, ".")
5-element Vector{SubString{String}}:
 "M"
 "a"
 "r"
 "c"
 "h"

julia> rsplit(a, "."; limit=1)
1-element Vector{SubString{String}}:
 "M.a.r.c.h"

julia> rsplit(a, "."; limit=2)
2-element Vector{SubString{String}}:
 "M.a.r.c"
 "h"

strip([pred=isspace,] str::AbstractString) -> SubString
strip(str::AbstractString, chars) -> SubString

str에서 선행 및 후행 문자를 제거합니다. 제거할 문자는 chars로 지정되거나, 함수 pred가 true를 반환하는 문자입니다.

기본 동작은 선행 및 후행 공백과 구분 기호를 제거하는 것입니다: 정확한 세부 사항은 isspace를 참조하십시오.

선택적 chars 인수는 제거할 문자를 지정합니다: 단일 문자, 문자 벡터 또는 문자 집합일 수 있습니다.

또한 lstrip 및 rstrip를 참조하십시오.

예제

julia> strip("{3, 5}\n", ['{', '}', '\n'])
"3, 5"

lstrip([pred=isspace,] str::AbstractString) -> SubString
lstrip(str::AbstractString, chars) -> SubString

str에서 선행 문자를 제거합니다. 이는 chars로 지정된 문자이거나 함수 pred가 true를 반환하는 문자입니다.

기본 동작은 선행 공백 및 구분 기호를 제거하는 것입니다: 정확한 세부 사항은 isspace를 참조하십시오.

선택적 chars 인수는 제거할 문자를 지정합니다: 단일 문자일 수도 있고, 문자 벡터 또는 집합일 수도 있습니다.

또한 strip 및 rstrip를 참조하십시오.

예제

julia> a = lpad("March", 20)
"               March"

julia> lstrip(a)
"March"

rstrip([pred=isspace,] str::AbstractString) -> SubString
rstrip(str::AbstractString, chars) -> SubString

str에서 후행 문자를 제거합니다. 이는 chars로 지정된 문자이거나 함수 pred가 true를 반환하는 문자입니다.

기본 동작은 후행 공백 및 구분 기호를 제거하는 것입니다: 정확한 세부 사항은 isspace를 참조하십시오.

선택적 chars 인수는 제거할 문자를 지정합니다: 단일 문자일 수도 있고, 문자 벡터 또는 집합일 수도 있습니다.

또한 strip 및 lstrip를 참조하십시오.

예제

julia> a = rpad("March", 20)
"March               "

julia> rstrip(a)
"March"

startswith(s::AbstractString, prefix::Union{AbstractString,Base.Chars})

s가 prefix로 시작하면 true를 반환합니다. prefix는 문자열, 문자 또는 문자 튜플/벡터/집합일 수 있습니다. prefix가 문자 튜플/벡터/집합인 경우, s의 첫 번째 문자가 해당 집합에 속하는지 테스트합니다.

자세한 내용은 endswith, contains를 참조하세요.

예제

julia> startswith("JuliaLang", "Julia")
true

startswith(io::IO, prefix::Union{AbstractString,Base.Chars})

IO 객체가 접두사로 시작하는지 확인합니다. 접두사는 문자열, 문자 또는 문자 튜플/벡터/집합일 수 있습니다. 또한 peek를 참조하세요.

startswith(prefix)

prefix로 시작하는지 여부를 확인하는 함수를 만듭니다. 즉, y -> startswith(y, prefix)와 동등한 함수입니다.

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

예제

julia> startswith("Julia")("JuliaLang")
true

julia> startswith("Julia")("Ends with Julia")
false

startswith(s::AbstractString, prefix::Regex)

prefix 정규 표현식 패턴으로 s가 시작하면 true를 반환합니다.

또한 occursin 및 endswith를 참조하십시오.

예제

julia> startswith("JuliaLang", r"Julia|Romeo")
true

endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})

s가 suffix로 끝나면 true를 반환합니다. suffix는 문자열, 문자 또는 문자 튜플/벡터/집합일 수 있습니다. suffix가 문자 튜플/벡터/집합인 경우, s의 마지막 문자가 해당 집합에 속하는지 테스트합니다.

또한 startswith, contains를 참조하세요.

예제

julia> endswith("Sunday", "day")
true

endswith(suffix)

suffix로 끝나는지 확인하는 함수를 만듭니다. 즉, y -> endswith(y, suffix)와 동등한 함수입니다.

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

예제

julia> endswith("Julia")("Ends with Julia")
true

julia> endswith("Julia")("JuliaLang")
false

endswith(s::AbstractString, suffix::Regex)

s가 정규 표현식 패턴 suffix로 끝나면 true를 반환합니다.

또한 occursin 및 startswith를 참조하십시오.

예제

julia> endswith("JuliaLang", r"Lang|Roberts")
true

contains(haystack::AbstractString, needle)

haystack에 needle이 포함되어 있으면 true를 반환합니다. 이는 occursin(needle, haystack)와 동일하지만, startswith(haystack, needle) 및 endswith(haystack, needle)와의 일관성을 위해 제공됩니다.

또한 occursin, in, issubset를 참조하세요.

예제

julia> contains("JuliaLang is pretty cool!", "Julia")
true

julia> contains("JuliaLang is pretty cool!", 'a')
true

julia> contains("aba", r"a.a")
true

julia> contains("abba", r"a.a")
false

contains(needle)

인수에 needle이 포함되어 있는지 확인하는 함수를 만듭니다. 즉, haystack -> contains(haystack, needle)와 동등한 함수입니다.

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

first(s::AbstractString, n::Integer)

문자열 s의 처음 n 문자로 구성된 문자열을 가져옵니다.

예제

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

last(s::AbstractString, n::Integer)

문자열 s의 마지막 n 문자로 구성된 문자열을 가져옵니다.

예제

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

uppercase(c::AbstractChar)

c를 대문자로 변환합니다.

또한 lowercase, titlecase를 참조하세요.

예제

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> uppercase('ê')
'Ê': Unicode U+00CA (category Lu: Letter, uppercase)

uppercase(s::AbstractString)

모든 문자가 대문자로 변환된 s를 반환합니다.

또한 lowercase, titlecase, uppercasefirst를 참조하세요.

예시

julia> uppercase("Julia")
"JULIA"

lowercase(c::AbstractChar)

c를 소문자로 변환합니다.

자세한 내용은 uppercase, titlecase를 참조하세요.

예제

julia> lowercase('A')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (category Ll: Letter, lowercase)

lowercase(s::AbstractString)

모든 문자를 소문자로 변환한 s를 반환합니다.

또한 uppercase, titlecase, lowercasefirst를 참조하세요.

예시

julia> lowercase("STRINGS AND THINGS")
"strings and things"

titlecase(c::AbstractChar)

c를 제목 대문자로 변환합니다. 이는 이중 자음의 경우 대문자와 다를 수 있으므로 아래 예제를 비교하십시오.

자세한 내용은 uppercase, lowercase를 참조하십시오.

예제

julia> titlecase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (category Lt: Letter, titlecase)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (category Lu: Letter, uppercase)

titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

s의 각 단어의 첫 번째 문자를 대문자로 변환합니다. strict가 true인 경우, 나머지 문자는 소문자로 변환되며, 그렇지 않으면 변경되지 않습니다. 기본적으로 새로운 그래프를 시작하는 모든 비문자는 단어 구분자로 간주됩니다. 어떤 문자가 단어 구분자로 간주되어야 하는지를 결정하기 위해 wordsep 키워드로 프레디케이트를 전달할 수 있습니다. s의 첫 번째 문자만 대문자로 변환하려면 uppercasefirst도 참조하십시오.

또한 uppercase, lowercase, uppercasefirst도 참조하십시오.

예제

julia> titlecase("the JULIA programming language")
"The Julia Programming Language"

julia> titlecase("ISS - international space station", strict=false)
"ISS - International Space Station"

julia> titlecase("a-a b-b", wordsep = c->c==' ')
"A-a B-b"

uppercasefirst(s::AbstractString) -> String

s의 첫 번째 문자를 대문자로 변환하여 반환합니다(기술적으로는 유니코드에 대한 "타이틀 케이스"). s의 모든 단어의 첫 번째 문자를 대문자로 만들려면 titlecase를 참조하십시오.

또한 lowercasefirst, uppercase, lowercase, titlecase도 참조하십시오.

예제

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

첫 번째 문자를 소문자로 변환한 s를 반환합니다.

또한 uppercasefirst, uppercase, lowercase, titlecase를 참조하세요.

예제

julia> lowercasefirst("Julia")
"julia"

join([io::IO,] iterator [, delim [, last]])

주어진 구분자(있는 경우)를 인접 항목 사이에 삽입하여 모든 iterator를 단일 문자열로 결합합니다. last가 주어지면 마지막 두 항목 사이에 delim 대신 사용됩니다. iterator의 각 항목은 print(io::IOBuffer, x)를 통해 문자열로 변환됩니다. io가 주어지면 결과는 String으로 반환되는 대신 io에 기록됩니다.

예제

julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"

julia> join([1,2,3,4,5])
"12345"

chop(s::AbstractString; head::Integer = 0, tail::Integer = 1)

s에서 처음 head와 마지막 tail 문자를 제거합니다. 호출 chop(s)는 s의 마지막 문자를 제거합니다. length(s)보다 더 많은 문자를 제거하도록 요청하면 빈 문자열이 반환됩니다.

또한 chomp, startswith, first를 참조하세요.

예제

julia> a = "March"
"March"

julia> chop(a)
"Marc"

julia> chop(a, head = 1, tail = 2)
"ar"

julia> chop(a, head = 5, tail = 5)
""

chopprefix(s::AbstractString, prefix::Union{AbstractString,Regex}) -> SubString

s에서 접두사 prefix를 제거합니다. 만약 s가 prefix로 시작하지 않으면, s와 동일한 문자열이 반환됩니다.

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

예제

julia> chopprefix("Hamburger", "Ham")
"burger"

julia> chopprefix("Hamburger", "hotdog")
"Hamburger"

chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex}) -> SubString

s에서 접미사 suffix를 제거합니다. 만약 s가 suffix로 끝나지 않으면, s와 동일한 문자열이 반환됩니다.

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

예제

julia> chopsuffix("Hamburger", "er")
"Hamburg"

julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"

chomp(s::AbstractString) -> SubString

문자열에서 단일 후행 개행 문자를 제거합니다.

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

예제

julia> chomp("Hello\n")
"Hello"

thisind(s::AbstractString, i::Integer) -> Int

s에서 i가 유효한 범위에 있으면, i가 포함된 문자 인코딩 코드 유닛의 시작 인덱스를 반환합니다. 다시 말해, i가 문자의 시작이면 i를 반환하고, i가 문자의 시작이 아니면 문자의 시작까지 되돌아가서 해당 인덱스를 반환합니다. i가 0 또는 ncodeunits(s)+1과 같으면 i를 반환합니다. 그 외의 경우에는 BoundsError를 발생시킵니다.

예제

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

julia> thisind("α", 4)
ERROR: BoundsError: attempt to access 2-codeunit String at index [4]
[...]

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access 2-codeunit String at index [-1]
[...]

nextind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• 경우 n == 1

  만약 i가 s의 범위 내에 있다면, i 인덱스 이후에 시작하는 문자 인코딩의 시작 인덱스를 반환합니다. 다시 말해, 만약 i가 문자의 시작이라면, 다음 문자의 시작을 반환하고; 만약 i가 문자의 시작이 아니라면, 문자의 시작까지 앞으로 이동하여 그 인덱스를 반환합니다. 만약 i가 0과 같다면 1을 반환합니다. 만약 i가 범위 내에 있지만 lastindex(str)보다 크거나 같다면 ncodeunits(str)+1을 반환합니다. 그렇지 않으면 BoundsError를 발생시킵니다.

• 경우 n > 1

  n==1에 대해 nextind를 n번 적용하는 것처럼 동작합니다. 유일한 차이점은 n이 너무 커서 nextind를 적용하면 ncodeunits(str)+1에 도달할 경우, 남은 각 반복은 반환된 값을 1씩 증가시킵니다. 이는 이 경우 nextind가 ncodeunits(str)+1보다 큰 값을 반환할 수 있음을 의미합니다.

• 경우 n == 0

  i가 s의 유효한 인덱스이거나 0과 같을 경우에만 i를 반환합니다. 그렇지 않으면 StringIndexError 또는 BoundsError가 발생합니다.

예제

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

julia> nextind("α", 3)
ERROR: BoundsError: attempt to access 2-codeunit String at index [3]
[...]

julia> nextind("α", 0, 2)
3

julia> nextind("α", 1, 2)
4

prevind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• 경우 n == 1

  만약 i가 s의 범위 내에 있다면, 인덱스 i 이전에 시작하는 문자 인코딩의 시작 인덱스를 반환합니다. 다시 말해, 만약 i가 문자의 시작이라면, 이전 문자의 시작을 반환하고; 만약 i가 문자의 시작이 아니라면, 문자 시작까지 되돌아가서 그 인덱스를 반환합니다. 만약 i가 1과 같다면 0을 반환합니다. 만약 i가 ncodeunits(str)+1과 같다면 lastindex(str)을 반환합니다. 그렇지 않으면 BoundsError를 발생시킵니다.

• 경우 n > 1

  n==1에 대해 prevind를 n번 적용하는 것처럼 동작합니다. 유일한 차이점은 n이 너무 커서 prevind를 적용하면 0에 도달할 경우, 남은 각 반복은 반환 값을 1씩 감소시킵니다. 이는 이 경우 prevind가 음수 값을 반환할 수 있음을 의미합니다.

• 경우 n == 0

  i가 str의 유효한 인덱스이거나 ncodeunits(str)+1과 같을 경우에만 i를 반환합니다. 그렇지 않으면 StringIndexError 또는 BoundsError가 발생합니다.

예제

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

julia> prevind("α", 0)
ERROR: BoundsError: attempt to access 2-codeunit String at index [0]
[...]

julia> prevind("α", 2, 2)
0

julia> prevind("α", 2, 3)
-1

textwidth(c)

문자를 인쇄하는 데 필요한 열의 수를 제공합니다.

예시

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

문자열을 인쇄하는 데 필요한 열의 수를 제공합니다.

예시

julia> textwidth("March")
5

isascii(c::Union{AbstractChar,AbstractString}) -> Bool

문자가 ASCII 문자 집합에 속하는지, 또는 문자열의 모든 요소가 이 조건을 만족하는지 테스트합니다.

예제

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

예를 들어, isascii는 filter 또는 replace와 같은 함수의 조건 함수로 사용되어 비ASCII 문자를 각각 제거하거나 대체하는 데 사용할 수 있습니다:

julia> filter(isascii, "abcdeγfgh") # 비ASCII 문자를 버림
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # 비ASCII 문자를 공백으로 대체
"abcde fgh"

isascii(cu::AbstractVector{CU}) where {CU <: Integer} -> Bool

벡터의 모든 값이 ASCII 문자 집합(0x00에서 0x7f)에 속하는지 테스트합니다. 이 함수는 빠른 ASCII 검사가 필요한 다른 문자열 구현에서 사용하기 위해 설계되었습니다.

iscntrl(c::AbstractChar) -> Bool

문자가 제어 문자(control character)인지 테스트합니다. 제어 문자는 유니코드의 라틴-1 하위 집합에 있는 비인쇄 문자입니다.

예제

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

문자가 10진수 숫자(0-9)인지 여부를 테스트합니다.

참고: isletter.

예제

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

문자가 글자인지 테스트합니다. 문자는 유니코드 일반 범주 Letter에 속하는 경우 글자로 분류됩니다. 즉, 범주 코드가 'L'로 시작하는 문자입니다.

참고: isdigit.

예제

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

문자가 소문자(letter)인지 테스트합니다 (유니코드 표준의 Lowercase 파생 속성에 따라).

또한 isuppercase를 참조하세요.

예제

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

문자가 숫자인지 여부를 테스트합니다. 문자는 유니코드 일반 범주 번호에 속하는 경우 숫자로 분류됩니다. 즉, 범주 코드가 'N'으로 시작하는 문자입니다.

이 넓은 범주에는 ¾ 및 ௰과 같은 문자가 포함됩니다. 문자가 0과 9 사이의 10진 숫자인지 확인하려면 isdigit를 사용하세요.

예시

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

문자가 인쇄 가능한지 테스트하며, 공백을 포함하지만 제어 문자는 포함하지 않습니다.

예제

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

문자가 유니코드 일반 범주 구두점에 속하는지 여부를 테스트합니다. 즉, 범주 코드가 'P'로 시작하는 문자입니다.

예제

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

문자가 공백 문자 중 하나인지 테스트합니다. ASCII 문자 '\t', '\n', '\v', '\f', '\r', 및 ' ', 라틴-1 문자 U+0085, 그리고 유니코드 범주 Zs의 문자를 포함합니다.

예제

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

문자가 대문자(letter)인지 테스트합니다 (유니코드 표준의 Uppercase 파생 속성에 따라).

또한 islowercase를 참조하세요.

예제

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

문자가 유효한 16진수 숫자인지 테스트합니다. 여기에는 0x 접두사에서의 x는 포함되지 않습니다.

예제

julia> isxdigit('a')
true

julia> isxdigit('x')
false

escape_string(str::AbstractString[, esc]; keep = ())::AbstractString
escape_string(io, str::AbstractString[, esc]; keep = ())::Nothing

전통적인 C 및 유니코드 이스케이프 시퀀스의 일반적인 이스케이프. 첫 번째 형식은 이스케이프된 문자열을 반환하고, 두 번째는 결과를 io에 출력합니다.

백슬래시(\)는 이중 백슬래시("\\")로 이스케이프됩니다. 비인쇄 가능한 문자는 표준 C 이스케이프 코드, NUL에 대한 "\0"(모호하지 않은 경우), 유니코드 코드 포인트("\u" 접두사) 또는 16진수("\x" 접두사)로 이스케이프됩니다.

선택적 esc 인수는 백슬래시로 이스케이프되어야 하는 추가 문자를 지정합니다("는 첫 번째 형식에서 기본적으로 이스케이프됩니다).

인수 keep는 있는 그대로 유지되어야 하는 문자 집합을 지정합니다. 여기서 esc가 우선합니다.

역작업에 대한 unescape_string도 참조하십시오.

예제

julia> escape_string("aaa\nbbb")
"aaa\\nbbb"

julia> escape_string("aaa\nbbb"; keep = '\n')
"aaa\nbbb"

julia> escape_string("\xfe\xff") # 유효하지 않은 utf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # 모호하지 않음
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0는 모호할 수 있음
"ℵ\\x000"

escape_raw_string(s::AbstractString, delim='"') -> AbstractString
escape_raw_string(io, s::AbstractString, delim='"')

원시 문자열 리터럴을 파싱하는 데 사용되는 방식으로 문자열을 이스케이프합니다. 입력 문자열 s(또는 지정된 경우 delim)의 각 큰따옴표(") 문자에 대해 이 함수는 앞에 있는 백슬래시(\) 문자의 수 n을 계산한 다음, n에서 2n+1로 백슬래시의 수를 증가시킵니다( n = 0인 경우에도 마찬가지입니다). 또한 문자열 끝에 있는 백슬래시의 시퀀스를 두 배로 늘립니다.

이 이스케이프 규칙은 원시 문자열 및 기타 비표준 문자열 리터럴에서 사용됩니다. (또한 Microsoft C/C++ 컴파일러 런타임이 명령줄 문자열을 argv[] 배열로 파싱할 때 기대하는 이스케이프 규칙이기도 합니다.)

자세한 내용은 escape_string을 참조하세요.

unescape_string(str::AbstractString, keep = ())::AbstractString
unescape_string(io, s::AbstractString, keep = ())::Nothing

전통적인 C 및 유니코드 이스케이프 시퀀스의 일반적인 언이스케이프. 첫 번째 형식은 이스케이프된 문자열을 반환하고, 두 번째는 결과를 io에 출력합니다. 인수 keep는 (역슬래시와 함께) 그대로 유지할 문자의 컬렉션을 지정합니다.

다음 이스케이프 시퀀스가 인식됩니다:

• 이스케이프된 역슬래시 (\\)
• 이스케이프된 큰따옴표 (\")
• 표준 C 이스케이프 시퀀스 (\a, \b, \t, \n, \v, \f, \r, \e)
• 유니코드 BMP 코드 포인트 (\u 뒤에 1-4개의 16진수 숫자)
• 모든 유니코드 코드 포인트 (\U 뒤에 1-8개의 16진수 숫자; 최대 값 = 0010ffff)
• 16진수 바이트 (\x 뒤에 1-2개의 16진수 숫자)
• 8진수 바이트 (\ 뒤에 1-3개의 8진수 숫자)

또한 escape_string를 참조하십시오.

예제

julia> unescape_string("aaa\\nbbb") # C 이스케이프 시퀀스
"aaa\nbbb"

julia> unescape_string("\\u03c0") # 유니코드
"π"

julia> unescape_string("\\101") # 8진수
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # `keep` 인수 사용
"aaa \\g \n"

AnnotatedString{S <: AbstractString} <: AbstractString

메타데이터가 있는 문자열, 주석이 달린 영역의 형태로.

더 구체적으로, 이는 주석이 달린 값으로 래핑된 문자열의 영역을 허용하는 다른 AbstractString 주위의 간단한 래퍼입니다.

                           C
                    ┌──────┸─────────┐
  "this is an example annotated string"
  └──┰────────┼─────┘         │
     A        └─────┰─────────┘
                    B

위의 다이어그램은 세 개의 범위가 주석이 달린 AnnotatedString을 나타냅니다(라벨 A, B, 및 C로 표시됨). 각 주석은 라벨(Symbol)과 값(Any)을 보유합니다. 이 세 가지 정보는 @NamedTuple{region::UnitRange{Int64}, label::Symbol, value}로 저장됩니다.

라벨은 고유할 필요가 없으며, 동일한 영역은 동일한 라벨을 가진 여러 주석을 가질 수 있습니다.

일반적으로 AnnotatedString에 대해 작성된 코드는 다음 속성을 보존해야 합니다:

• 주석이 적용되는 문자
• 각 문자에 주석이 적용되는 순서

추가적인 의미는 AnnotatedString의 특정 사용에 의해 도입될 수 있습니다.

이 규칙의 결과는 인접하고 연속적으로 배치된 동일한 라벨과 값을 가진 주석이 결합된 범위를 포괄하는 단일 주석과 동등하다는 것입니다.

또한 AnnotatedChar, annotatedstring, annotations, 및 annotate!를 참조하십시오.

생성자

AnnotatedString(s::S<:AbstractString) -> AnnotatedString{S}
AnnotatedString(s::S<:AbstractString, annotations::Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}})

AnnotatedString은 또한 annotatedstring로 생성할 수 있으며, 이는 string와 유사하게 작동하지만 인수에 존재하는 모든 주석을 보존합니다.

예제

julia> AnnotatedString("this is an example annotated string",
                    [(1:18, :A => 1), (12:28, :B => 2), (18:35, :C => 3)])
"this is an example annotated string"

AnnotatedChar{S <: AbstractChar} <: AbstractChar

주석이 있는 문자입니다.

보다 구체적으로, 이는 래핑된 문자와 함께 임의의 레이블이 있는 주석 목록(@NamedTuple{label::Symbol, value})을 보유하는 다른 AbstractChar 주위의 간단한 래퍼입니다.

또한 참조: AnnotatedString, annotatedstring, annotations, 및 annotate!.

생성자

AnnotatedChar(s::S) -> AnnotatedChar{S}
AnnotatedChar(s::S, annotations::Vector{@NamedTuple{label::Symbol, value}})

예제

julia> AnnotatedChar('j', :label => 1)
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)

annotatedstring(values...)

values의 print된 표현을 사용하여 AnnotatedString을 생성합니다.

이것은 string처럼 작동하지만, 존재하는 모든 주석(형태가 AnnotatedString 또는 AnnotatedChar 값인)을 보존하는 데 주의합니다.

또한 AnnotatedString 및 AnnotatedChar를 참조하십시오.

예제

julia> annotatedstring("now a AnnotatedString")
"now a AnnotatedString"

julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label => 1)]), ", and unannotated")
"annotated, and unannotated"

annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
            [position::Union{Integer, UnitRange}]) ->
    Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}}

`str`에 적용되는 모든 주석을 가져옵니다. `position`이 제공되면, `position`과 겹치는 주석만 반환됩니다.

주석은 적용되는 영역과 함께 제공되며, 영역–주석 튜플의 벡터 형태로 제공됩니다.

[`AnnotatedString`](@ref)에서 문서화된 의미론에 따라 반환된 주석의 순서는 적용된 순서와 일치합니다.

또한: [`annotate!`](@ref).

annotations(chr::AnnotatedChar) -> Vector{@NamedTuple{label::Symbol, value}}

chr의 모든 주석을 주석 쌍의 벡터 형태로 가져옵니다.

annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol, value)
annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol, value)

str의 range (또는 전체 문자열)에 레이블이 있는 값(label => value)으로 주석을 추가합니다. 기존의 label 주석을 제거하려면 nothing 값을 사용하십시오.

str에 주석이 적용되는 순서는 AnnotatedString에서 설명한 대로 의미가 있습니다.

annotate!(char::AnnotatedChar, label::Symbol, value::Any)

char에 쌍 label => value로 주석을 추가합니다.