Unicode

Unicode modülü, Unicode karakterleri ve dizeleri yönetmek için temel işlevsellik sağlar. Doğrulama, kategori belirleme, normalizasyon, büyük/küçük harf dönüşümü ve graphem segmentasyonu gibi işlemleri içerir ve etkili Unicode veri yönetimini mümkün kılar.

Unicode.julia_chartransform(c::Union{Char,Integer})

Unicode karakterini (Char) veya kod noktasını (Integer) c'yi, Julia ayrıştırıcısında kullanılan özel eşdeğerliğe göre karşılık gelen "eşdeğer" karakter veya kod noktasına eşleştirir (NFC normalizasyonuna ek olarak).

Örneğin, 'µ' (U+00B5 mikro) Julia'nın ayrıştırıcısı tarafından 'μ' (U+03BC mu) ile eşdeğer olarak kabul edilir, bu nedenle julia_chartransform bu dönüşümü gerçekleştirirken diğer karakterleri değiştirmeden bırakır:

julia> Unicode.julia_chartransform('µ')
'μ': Unicode U+03BC (kategori Ll: Harf, küçük)

julia> Unicode.julia_chartransform('x')
'x': ASCII/Unicode U+0078 (kategori Ll: Harf, küçük)

julia_chartransform, Julia ayrıştırıcısının kullandığı normalizasyonu taklit etmek için Unicode.normalize fonksiyonuna geçmek için esasen faydalıdır:

julia> s = "µö"
"µö"

julia> s2 = Unicode.normalize(s, compose=true, stable=true, chartransform=Unicode.julia_chartransform)
"μö"

julia> collect(s2)
2-element Vector{Char}:
 'μ': Unicode U+03BC (kategori Ll: Harf, küçük)
 'ö': Unicode U+00F6 (kategori Ll: Harf, küçük)

julia> s2 == string(Meta.parse(s))
true

Unicode.isassigned(c) -> Bool

Verilen karakter veya tam sayının atanmış bir Unicode kod noktası olup olmadığını kontrol eder. true döner.

Örnekler

julia> Unicode.isassigned(101)
true

julia> Unicode.isassigned('\x01')
true

isequal_normalized(s1::AbstractString, s2::AbstractString; casefold=false, stripmark=false, chartransform=identity)

s1 ve s2'nin kanonik olarak eşdeğer Unicode dizgeleri olup olmadığını döndürür. Eğer casefold=true ise, büyük/küçük harf farkını göz ardı eder (Unicode büyük/küçük harf dönüştürmesi yapar); eğer stripmark=true ise, diakritik işaretleri ve diğer birleştirici karakterleri temizler.

Unicode.normalize ile olduğu gibi, özel normalizasyonlar gerçekleştirmek için chartransform anahtar kelimesi aracılığıyla bir işlev de geçirebilirsiniz ( Integer kod noktalarını kod noktalarına eşleyen) , örneğin Unicode.julia_chartransform.

Örnekler

Örneğin, "noël" dizgesi, "ë"nin tek bir kod noktası U+00EB'den mi yoksa ASCII karakteri 'e'nin ardından U+0308 birleştirici-diyaliz karakteri ile mi oluşturulduğuna bağlı olarak Unicode'da iki kanonik olarak eşdeğer şekilde oluşturulabilir.

julia> s1 = "noël"
"noël"

julia> s2 = "noël"
"noël"

julia> s1 == s2
false

julia> isequal_normalized(s1, s2)
true

julia> isequal_normalized(s1, "noel", stripmark=true)
true

julia> isequal_normalized(s1, "NOËL", casefold=true)
true

Unicode.normalize(s::AbstractString; keywords...)
Unicode.normalize(s::AbstractString, normalform::Symbol)

Dizeyi s normalleştir. Varsayılan olarak, kanonik bileşim (compose=true) Unicode sürüm stabilitesini sağlamadan gerçekleştirilir (compat=false), bu da mümkün olan en kısa eşdeğer dizeyi üretir ancak daha önceki Unicode sürümlerinde bulunmayan bileşim karakterlerini tanıtabilir.

Alternatif olarak, Unicode standardının dört "normal formundan" biri belirtilebilir: normalform :NFC, :NFD, :NFKC veya :NFKD olabilir. Normal formlar C (kanonik bileşim) ve D (kanonik ayrıştırma), aynı soyut dize için farklı görsel olarak özdeş temsilleri tek bir kanonik forma dönüştürür; form C daha kompakt bir yapıya sahiptir. Normal formlar KC ve KD ayrıca "uyumluluk eşdeğerlerini" kanonikleştirir: soyut olarak benzer ancak görsel olarak farklı karakterleri tek bir kanonik seçeneğe dönüştürür (örneğin, ligatürleri bireysel karakterlere genişletir), form KC daha kompakt bir yapıya sahiptir.

Alternatif olarak, Unicode.normalize(s; keywords...) çağrılarak daha ince kontrol ve ek dönüşümler elde edilebilir; burada aşağıdaki boolean anahtar kelime seçeneklerinden herhangi sayıda (hepsi compose dışında varsayılan olarak false'dur) belirtilir:

• compose=false: kanonik bileşimi gerçekleştirme
• decompose=true: kanonik bileşimin yerine kanonik ayrıştırma yap (compose=true mevcutsa göz ardı edilir)
• compat=true: uyumluluk eşdeğerleri kanonikleştirilir
• casefold=true: Unicode büyük/küçük harf katlama işlemi yap, örneğin büyük/küçük harf duyarsız dize karşılaştırması için
• newline2lf=true, newline2ls=true veya newline2ps=true: çeşitli yeni satır dizilerini (LF, CRLF, CR, NEL) sırasıyla bir satır besleme (LF), satır ayırma (LS) veya paragraf ayırma (PS) karakterine dönüştür
• stripmark=true: diakritik işaretleri (örneğin, aksanlar) kaldır
• stripignore=true: Unicode'un "varsayılan yok sayılabilir" karakterlerini (örneğin, yumuşak tire veya soldan sağa işaret) kaldır
• stripcc=true: kontrol karakterlerini kaldır; yatay sekmeler ve form beslemeleri boşluklara dönüştürülür; yeni satırlar da boşluklara dönüştürülür, aksi takdirde bir yeni satır dönüştürme bayrağı belirtilmedikçe
• rejectna=true: atanmış kod noktaları bulunursa bir hata fırlat
• stable=true: Unicode sürüm stabilitesini zorla (daha önceki Unicode sürümlerinden eksik karakterler tanıtma)

Ayrıca, chartransform anahtar kelimesini (varsayılan olarak identity) kullanarak Integer kod noktalarını kod noktalarına eşleyen keyfi bir fonksiyon geçirebilirsiniz; bu, s işlenirken her karakter üzerinde çağrılır ve keyfi ek normalizasyonlar gerçekleştirmek için kullanılır. Örneğin, chartransform=Unicode.julia_chartransform geçirerek, Julia'nın tanımlayıcıları ayrıştırırken gerçekleştirdiği birkaç Julia'ya özgü karakter normalizasyonunu uygulayabilirsiniz (NFC normalizasyonuna ek olarak: compose=true, stable=true).

Örneğin, NFKC compose=true, compat=true, stable=true seçeneklerine karşılık gelir.

Örnekler

julia> "é" == Unicode.normalize("é") #LHS: Unicode U+00e9, RHS: U+0065 & U+0301
true

julia> "μ" == Unicode.normalize("µ", compat=true) #LHS: Unicode U+03bc, RHS: Unicode U+00b5
true

julia> Unicode.normalize("JuLiA", casefold=true)
"julia"

julia> Unicode.normalize("JúLiA", stripmark=true)
"JuLiA"

graphemes(s::AbstractString) -> GraphemeIterator

S içinde, Unicode UAX #29 tarafından tanımlandığı gibi, dize içindeki genişletilmiş graphemlere karşılık gelen alt dizelerin üzerinde bir yineleyici döndürür. (Kabaca, bunlar kullanıcıların tek karakterler olarak algılayacağı şeylerdir, her ne kadar birden fazla kod noktası içerebilirler; örneğin, bir harf ile bir aksan işareti bir tek graphem olarak kabul edilir.)

graphemes(s::AbstractString, m:n) -> SubString

S'nin m-inci ile n-inci graphemlerinden oluşan bir SubString döndürür. Burada ikinci argüman m:n tam sayı değerli bir AbstractUnitRange dir.

Gevşek bir şekilde, bu, dizgedeki m:n-inci kullanıcı tarafından algılanan "karakterler" ile ilgilidir. Örneğin:

julia> s = graphemes("exposé", 3:6)
"posé"

julia> collect(s)
5-element Vector{Char}:
 'p': ASCII/Unicode U+0070 (category Ll: Letter, lowercase)
 'o': ASCII/Unicode U+006F (category Ll: Letter, lowercase)
 's': ASCII/Unicode U+0073 (category Ll: Letter, lowercase)
 'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)
 '́': Unicode U+0301 (category Mn: Mark, nonspacing)

Bu, "exposé" içindeki 3. ile 7. kod noktalarını (Chars) içerir, çünkü "é" graphemi aslında iki Unicode kod noktasından oluşur (bir 'e' ve ardından bir akut aksan birleştirme karakteri U+0301).

Graphem sınırlarını bulmak, dizge içeriği üzerinde yineleme gerektirdiğinden, graphemes(s, m:n) fonksiyonu, alt dizenin sonuna kadar olan dizge uzunluğuna (kod noktası sayısına) orantılı bir zaman gerektirir.