Strings

AbstractString türü, Julia'daki tüm string uygulamalarının süpertipidir. Stringler, AbstractChar türü tarafından temsil edilen Unicode kod noktalarının dizilerinin kodlamalarıdır. Julia, stringler hakkında birkaç varsayımda bulunur:

• Stringler, sabit boyutlu "kod birimleri" açısından kodlanmıştır.

  • Kod birimleri codeunit(s, i) ile çıkarılabilir
  • İlk kod biriminin indeksi 1'dir
  • Son kod biriminin indeksi ncodeunits(s)'dir
  • 1 ≤ i ≤ ncodeunits(s) koşulunu sağlayan herhangi bir indeks geçerlidir

• String indeksleme, bu kod birimleri açısından yapılır:

  • Karakterler, geçerli bir string indeksi i ile s[i] ile çıkarılır
  • Bir stringdeki her AbstractChar, bir veya daha fazla kod birimi ile kodlanmıştır
  • Bir AbstractChar'ın ilk kod biriminin indeksi geçerli bir indekstir
  • Bir AbstractChar'ın kodlaması, öncesinde veya sonrasında ne olduğundan bağımsızdır
  • String kodlamaları kendinden senkronizedir – yani isvalid(s, i) O(1) zaman karmaşıklığına sahiptir

Kod birimlerini, karakterleri veya stringlerden alt dizeleri çıkaran bazı string fonksiyonları, onlara geçersiz veya sınır dışı string indeksleri verirseniz hata verir. Bu, codeunit(s, i) ve s[i]'yi içerir. String indeks aritmetiği yapan fonksiyonlar, indeksleme konusunda daha rahat bir yaklaşım benimser ve sınır içindeyken size en yakın geçerli string indeksini verir veya sınır dışındayken, stringin her iki tarafında sonsuz sayıda karakter varmış gibi davranır. Genellikle bu hayali dolgu karakterlerinin kod birimi uzunluğu 1'dir, ancak string türleri, uygulamaları için mantıklı olan farklı "hayali" karakter boyutlarını seçebilir (örneğin, alt dizeler, indeks aritmetiğini sağladıkları altındaki stringe iletebilir). Rahat indeksleme fonksiyonları, indeks aritmetiği için tasarlanmış olanları içerir: thisind, nextind ve prevind. Bu model, bir karakter almak için asla kullanılmadığı sürece, sınır dışı indekslerle ara değerler olarak çalışacak şekilde indeks aritmetiğinin çalışmasına olanak tanır; bu genellikle kenar durumları etrafında kod yazma gereksinimini azaltmaya yardımcı olur.

Ayrıca codeunit, ncodeunits, thisind, nextind, prevind bakın.

AbstractChar türü, Julia'daki tüm karakter uygulamalarının üst türüdür. Bir karakter, bir Unicode kod noktasını temsil eder ve kod noktasının sayısal değerini elde etmek için codepoint fonksiyonu aracılığıyla bir tam sayıya dönüştürülebilir veya aynı tam sayıdan oluşturulabilir. Bu sayısal değerler, karakterlerin < ve == ile nasıl karşılaştırıldığını belirler. Yeni T <: AbstractChar türleri, en azından bir codepoint(::T) metodu ve bir T(::UInt32) yapıcı tanımlamalıdır.

Verilen bir AbstractChar alt türü, yalnızca Unicode'un bir alt kümesini temsil etme yeteneğine sahip olabilir; bu durumda, desteklenmeyen bir UInt32 değerine dönüşüm bir hata fırlatabilir. Tersine, yerleşik Char türü, geçersiz bayt akışlarını kayıpsız bir şekilde kodlamak için bir üst küme Unicode'u temsil eder; bu durumda, bir Unicode olmayan değerin UInt32'ye dönüşümü bir hata fırlatır. isvalid fonksiyonu, belirli bir AbstractChar türünde hangi kod noktalarının temsil edilebilir olduğunu kontrol etmek için kullanılabilir.

Dahili olarak, bir AbstractChar türü çeşitli kodlamalar kullanabilir. codepoint(char) aracılığıyla dönüşüm, bu kodlamayı açığa çıkarmayacaktır çünkü her zaman karakterin Unicode değerini döndürür. Herhangi bir c::AbstractChar için print(io, c) ifadesi, gerekirse Char'a dönüşüm yoluyla io tarafından belirlenen bir kodlama üretir (tüm yerleşik IO türleri için UTF-8).

Buna karşılık, write(io, c), typeof(c)'ye bağlı olarak bir kodlama yayabilir ve read(io, typeof(c)), write ile aynı kodlamayı okumalıdır. Yeni AbstractChar türleri, write ve read için kendi uygulamalarını sağlamalıdır.

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

Char, Julia'daki karakterlerin varsayılan temsilidir ve 32 bitlik bir AbstractChar türüdür. Char, 'x' gibi karakter literalleri için kullanılan türdür ve aynı zamanda String türünün eleman türüdür.

Bir String içinde saklanan rastgele bayt akışlarını kayıpsız bir şekilde temsil etmek için, bir Char değeri Unicode kod noktasına dönüştürülemeyen bilgileri depolayabilir — böyle bir Char'ı UInt32'ye dönüştürmek bir hata fırlatır. c'nin geçerli bir Unicode karakterini temsil edip etmediğini sorgulamak için isvalid(c::Char) fonksiyonu kullanılabilir.

codepoint(c::AbstractChar) -> Integer

Karakter c ile ilgili Unicode kod noktası (bir işaretsiz tam sayı) döndürülür (veya c geçerli bir karakteri temsil etmiyorsa bir istisna fırlatılır). Char için bu bir UInt32 değeri, ancak yalnızca Unicode'un bir alt kümesini temsil eden AbstractChar türleri farklı boyutta bir tam sayı döndürebilir (örneğin UInt8).

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

Dize s dizisindeki i ile j indeksleri arasındaki karakter sayısını döndürür.

Bu, i ile j arasındaki geçerli karakter indeksleri olan kod birimi indekslerinin sayısı olarak hesaplanır. Sadece tek bir dize argümanı ile, bu tüm dizideki karakter sayısını hesaplar. i ve j argümanları ile, s dizisinde geçerli indeksler olan i ile j arasındaki (dahil) indekslerin sayısını hesaplar. Sınır içindeki değerlere ek olarak, i sınır dışı değeri ncodeunits(s) + 1 alabilir ve j sınır dışı değeri 0 alabilir.

Ayrıca bkz. isvalid, ncodeunits, lastindex, thisind, nextind, prevind.

Örnekler

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

sizeof(str::AbstractString)

str'nin bayt cinsinden boyutu. str'deki kod birimlerinin sayısı ile str'deki bir kod biriminin bayt cinsinden boyutunun çarpımına eşittir.

Örnekler

julia> sizeof("")
0

julia> sizeof("∀")
3

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

Dizeleri ve/veya karakterleri birleştirir, uygun şekilde bir String veya AnnotatedString üretir. Bu, argümanlar üzerinde string veya annotatedstring fonksiyonunu çağırmakla eşdeğerdir. Yerleşik dize türlerinin birleştirilmesi her zaman String türünde bir değer üretirken, diğer dize türleri uygun olduğunda farklı bir türde dize döndürmeyi seçebilir.

Örnekler

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

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

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

Bir dizeyi veya karakteri n kez tekrarlayın. Bu aynı zamanda repeat(s, n) olarak da yazılabilir.

Ayrıca bkz. repeat.

Örnekler

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

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

Bir tam sayıyı n verilen base'de bir dizeye dönüştürür, isteğe bağlı olarak doldurulacak basamak sayısını belirtir.

Ayrıca bkz. digits, bitstring, count_zeros.

Örnekler

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

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

string(xs...)

Herhangi bir değerden bir dize oluşturmak için print işlevini kullanın.

string genellikle doğrudan tanımlanmamalıdır. Bunun yerine, print(io::IO, x::MyType) yöntemini tanımlayın. Belirli bir tür için string(x) yüksek verimli olması gerekiyorsa, string'e bir yöntem eklemek ve print(io::IO, x::MyType) = print(io, string(x)) tanımlamak mantıklı olabilir; bu, işlevlerin tutarlı olmasını sağlar.

Ayrıca bakınız: String, repr, sprint, show.

Örnekler

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

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

Bir dizeyi r kez tekrarlar. Bu, s^r olarak yazılabilir.

Ayrıca bkz. ^.

Örnekler

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

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

Bir karakteri r kez tekrarlar. Bu, c^r çağrılarak da eşdeğer şekilde gerçekleştirilebilir.

Örnekler

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

repr(x; context=nothing)

Herhangi bir değerden bir dize oluşturmak için show fonksiyonunu kullanmalısınız. repr'e yöntem eklememelisiniz; bunun yerine bir show yöntemi tanımlayın.

İsteğe bağlı anahtar argümanı context, bir :key=>value çifti, :key=>value çiftleri içeren bir demet veya show'a geçirilen I/O akışı için kullanılan özelliklere sahip bir IO veya IOContext nesnesi olarak ayarlanabilir.

repr(x)'in genellikle x'in Julia'da nasıl girileceğine benzer olduğunu unutmayın. Bunun yanı sıra, x'in insan tüketimi için tasarlanmış "güzel yazılmış" bir versiyonunu döndürmek için repr(MIME("text/plain"), x) kullanın; bu, x'in REPL görüntülemesine eşdeğerdir.

Örnekler

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)

Mevcut bir AbstractString'den yeni bir String oluşturur.

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

getindex gibi, ancak bir kopya yapmak yerine s ana dizesi içindeki i:j veya r aralığında bir görünüm döndürür.

@views makrosu, bir kod bloğundaki herhangi bir dize dilimini s[i:j] alt dizelerine SubString(s, i, j) dönüştürür.

Örnekler

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

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

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

LazyString <: AbstractString

Bir dizi interpolasyonunun tembel bir temsili. Bu, bir dizinin, gerçek interpolasyonun ve dizi inşasının gereksiz veya istenmeyen olduğu bir bağlamda oluşturulması gerektiğinde faydalıdır (örneğin, işlevlerin hata yollarında).

Bu tür, çalışma zamanında inşa edilmesi için ucuz olacak şekilde tasarlanmıştır ve mümkün olduğunca fazla işi makroya veya daha sonraki yazdırma işlemlerine devretmeye çalışır.

Örnekler

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

Ayrıca @lazy_str bakınız.

Genişletilmiş yardım

Eşzamanlı programlar için güvenlik özellikleri

Bir tembel dizi, birden fazla Julia görevinde yazdırılsa bile, kendisi herhangi bir eşzamanlılık problemi oluşturmaz. Ancak, yakalanmış bir değerin print yöntemleri, senkronizasyon olmadan çağrıldığında bir eşzamanlılık sorunu yaşayabilir; tembel dizinin yazdırılması bir sorun yaratabilir. Ayrıca, yakalanmış değerler üzerindeki print yöntemleri birden fazla kez çağrılabilir, ancak yalnızca tam olarak bir sonuç dönecektir.

lazy"str"

Bir LazyString oluşturmak için normal dize interpolasyon sözdizimini kullanın. Interpolasyonların, LazyString oluşturma zamanında değerlendirildiğini, ancak dizeye ilk erişim anına kadar yazdırmanın ertelendiğini unutmayın.

LazyString belgelerine bakarak eşzamanlı programlar için güvenlik özelliklerini inceleyin.

Örnekler

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

julia> typeof(str)
LazyString

transcode(T, src)

Unicode kodlamaları arasında dize verilerini dönüştürür. src, ya bir String ya da UTF-XX kod birimlerinin Vector{UIntXX}'sidir; burada XX 8, 16 veya 32'dir. T, dönüş değerinin kodlamasını belirtir: (UTF-8 kodlu) bir String döndürmek için String veya UTF-XX verilerinin bir Vector{UIntXX}'sini döndürmek için UIntXX. (Dış C kütüphaneleri tarafından kullanılan wchar_t* dizelerini dönüştürmek için tam sayı türü olarak Cwchar_t de kullanılabilir.)

transcode fonksiyonu, giriş verileri hedef kodlamada makul bir şekilde temsil edilebildiği sürece başarılı olur; geçersiz Unicode verileri için bile, UTF-XX kodlamaları arasında dönüşümler için her zaman başarılıdır.

Şu anda yalnızca UTF-8'e/UTF-8'den dönüşüm desteklenmektedir.

Örnekler

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 tarzı (NUL ile sonlandırılmış) UTF-8 olarak kodlanmış bir stringi bir adresten kopyalar. (Pointer daha sonra güvenle serbest bırakılabilir.) Eğer length belirtilmişse (verinin byte cinsinden uzunluğu), string NUL ile sonlandırılmak zorunda değildir.

Bu fonksiyon "güvensiz" olarak etiketlenmiştir çünkü p, istenen uzunluktaki veriye geçerli bir bellek adresi değilse çökmesine neden olur.

ncodeunits(s::AbstractString) -> Int

Bir dizedeki kod birimlerinin sayısını döndürür. Bu dizeye erişmek için geçerli olan indeksler 1 ≤ i ≤ ncodeunits(s) koşulunu sağlamalıdır. Tüm bu indeksler geçerli olmayabilir – bir karakterin başlangıcı olmayabilirler, ancak codeunit(s,i) çağrıldığında bir kod birimi değeri döndüreceklerdir.

Örnekler

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

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

Ayrıca codeunit, checkbounds, sizeof, length, lastindex bakınız.

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

Verilen dize nesnesinin kod birimi türünü döndürür. ASCII, Latin-1 veya UTF-8 kodlamalı dizeler için bu UInt8 olur; UCS-2 ve UTF-16 için UInt16; UTF-32 için UInt32 olur. Kod birimi türü bu üç türle sınırlı olmak zorunda değildir, ancak bu birimlerden birini kullanmayan yaygın olarak kullanılan dize kodlamalarını düşünmek zordur. codeunit(s) ifadesi, s boş olmayan bir dize olduğunda typeof(codeunit(s,1)) ile aynıdır.

Ayrıca ncodeunits bakınız.

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

Dize s içindeki i indeksindeki kod birimi değerini döndürür. Şunu unutmayın

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

Yani, codeunit(s, i) tarafından döndürülen değer, codeunit(s) tarafından döndürülen türdedir.

Örnekler

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

julia> typeof(a)
UInt8

Ayrıca bkz. ncodeunits, checkbounds.

codeunits(s::AbstractString)

Bir dize içindeki kod birimlerini içeren vektör benzeri bir nesne elde edin. Varsayılan olarak bir CodeUnits sarmalayıcı döner, ancak gerekirse yeni dize türleri için codeunits isteğe bağlı olarak tanımlanabilir.

Örnekler

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

ascii(s::AbstractString)

Bir dizeyi String türüne dönüştürür ve yalnızca ASCII verileri içerdiğini kontrol eder, aksi takdirde ilk non-ASCII baytının konumunu belirten bir ArgumentError fırlatır.

Ayrıca, non-ASCII karakterleri filtrelemek veya değiştirmek için isascii predikatını da inceleyin.

Örnekler

julia> ascii("abcdeγfgh")
HATA: ArgumentError: geçersiz ASCII "abcdeγfgh" dizisinde 6. indekste
Yığın izi:
[...]

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags]) <: AbstractPattern

Bir düzenli ifade temsil eden bir türdür. Regex nesneleri, dizeleri match ile eşleştirmek için kullanılabilir.

Regex nesneleri, @r_str dize makrosu kullanılarak oluşturulabilir. Regex(pattern[, flags]) yapıcı genellikle pattern dizesinin interpolasyona ihtiyaç duyduğu durumlarda kullanılır. Bayraklar hakkında daha fazla bilgi için dize makrosunun belgelerine bakın.

@r_str -> Regex

Bir regex oluşturun, örneğin r"^[a-z]*$" gibi, interpolasyon ve kaçış olmadan (tırnak işareti " hariç, bu hala kaçırılmalıdır). Regex ayrıca, davranışını değiştirmek için son alıntıdan sonra listelenen bir veya daha fazla bayrağı kabul eder:

• i büyük/küçük harf duyarsız eşleşmeyi etkinleştirir
• m ^ ve $ belirteçlerini tüm dize yerine bireysel satırların başlangıç ve sonunu eşleyecek şekilde işler.
• s . belirtecinin yeni satırları eşlemesine izin verir.
• x "serbest boşluk modu"nu etkinleştirir: regex belirteçleri arasındaki boşluklar, \ ile kaçırılmadıkça yok sayılır ve regex içindeki # bir yorumun başlangıcı olarak kabul edilir (bu, satır sonuna kadar yok sayılır).
• a ASCII modunu etkinleştirir (UTF ve UCP modlarını devre dışı bırakır). Varsayılan olarak \B, \b, \D, \d, \S, \s, \W, \w vb. Unicode karakter özelliklerine dayalı olarak eşleşir. Bu seçenekle, bu diziler yalnızca ASCII karakterlerini eşleştirir. Bu, belirtilen karakter değerini doğrudan tek bir bayt olarak çıkaracak olan \u için de geçerlidir ve UTF-8'e kodlamaya çalışmaz. Önemli olarak, bu seçenek, hem eşleştirici hem de hedefin basit baytlar olarak ele alınmasını sağlayarak geçersiz UTF-8 dizeleriyle eşleşmeye izin verir (sanki ISO/IEC 8859-1 / Latin-1 baytlarıymış gibi) ve genellikle s ile birleştirilir. Bu seçenek, deseni (*UCP) veya (*UTF) ile başlatarak daha da rafine edilebilir.

Interpolasyon gerekiyorsa Regex kısmına bakın.

Örnekler

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

Bu regex'in ilk üç bayrağı etkinleştirilmiştir.

SubstitutionString(substr) <: AbstractString

Verilen substr dizesini bir SubstitutionString olarak saklar, düzenli ifade yer değiştirmelerinde kullanılmak üzere. En yaygın olarak @s_str makrosu kullanılarak oluşturulur.

Örnekler

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 -> DeğiştirmeDizesi

Düzenli ifade değiştirmeleri için kullanılan bir değiştirme dizesi oluşturur. Dizedeki \N biçimindeki diziler, düzenli ifadede N'inci yakalama grubuna atıfta bulunur ve \g<groupname> biçimi, groupname adıyla adlandırılmış bir yakalama grubuna atıfta bulunur.

Örnekler

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

İçinde yerleşim ve kaçış olmadan bir ham dize oluşturun. Tek istisna, tırnak işaretlerinin hala kaçırılması gerektiğidir. Ters eğik çizgiler, hem tırnak işaretlerini hem de diğer ters eğik çizgileri kaçırır, ancak yalnızca bir dizi ters eğik çizgi bir alıntı karakterinden önce geliyorsa. Böylece, 2n ters eğik çizgi bir alıntı ile takip edildiğinde n ters eğik çizgi ve literalın sonunu kodlar, 2n+1 ters eğik çizgi bir alıntı ile takip edildiğinde n ters eğik çizgi ve bir alıntı karakterini kodlar.

Örnekler

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

julia> println(raw"\"")
"

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

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

@b_str

Dize değişmez bir bayt (UInt8) vektörü oluşturmak için dize sözdizimi kullanın.

Örnekler

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

julia> v[2]
0x32

@html_str -> Docs.HTML

Bir literal string'den bir HTML nesnesi oluşturun.

Örnekler

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

@text_str -> Docs.Text

Bir literal string'den bir Text nesnesi oluşturun.

Örnekler

julia> text"Julia"
Julia

isvalid(value) -> Bool

Verilen değerin türü için geçerli olup olmadığını kontrol eder, bu tür şu anda ya AbstractChar ya da String ya da SubString{String} olabilir.

Örnekler

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

Verilen değerin o tür için geçerli olup olmadığını kontrol eder. Türler şu anda ya AbstractChar ya da String olabilir. AbstractChar için değerler AbstractChar türünde veya UInt32 türünde olabilir. String için değerler o türde, SubString{String}, Vector{UInt8} veya bunların bitişik bir alt dizisi olabilir.

Örnekler

julia> isvalid(Char, 0xd800)
false

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

julia> isvalid(Char, 0xd799)
true

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

Verilen indeksin s içindeki bir karakterin kodlamasının başlangıcı olup olmadığını belirten bir predikattir. Eğer isvalid(s, i) doğruysa, s[i] o indekste başlayan karakteri döndürecektir; eğer yanlışsa, s[i] geçersiz bir indeks hatası veya i sınırda ise bir sınır hatası verecektir. isvalid(s, i)'nin O(1) bir fonksiyon olabilmesi için, s'nin kodlaması kendinden senkronize olmalıdır. Bu, Julia'nın genel dize desteği için temel bir varsayımdır.

Ayrıca getindex, iterate, thisind, nextind, prevind, length bakınız.

Örnekler

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (kategori Ll: Harf, küçük)

julia> isvalid(str, 2)
false

julia> str[2]
HATA: StringIndexError: geçersiz indeks [2], geçerli yakın indeksler [1]=>'α', [3]=>'β'
Yığın izi:
[...]

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

Düzenli ifade r'nin s içinde ilk eşleşmesini arar ve eşleşmeyi içeren bir RegexMatch nesnesi döner, ya da eşleşme başarısız olursa hiçbir şey döner. Eşleşen alt dizeye m.match ile erişerek ve yakalanan dizilere m.captures ile erişerek ulaşılabilir. İsteğe bağlı idx argümanı, aramaya başlamak için bir indeks belirtir.

Örnekler

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)

Düzenli ifade r'nin s içindeki tüm eşleşmelerini arar ve eşleşmeler üzerinde bir yineleyici döndürür. Eğer overlap true ise, eşleşen diziler orijinal dizideki indeksleri örtüşmesine izin verilir, aksi takdirde farklı karakter aralıklarından olmalıdır.

Örnekler

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

Bir dize içinde bulunan bir Regex için tek bir eşleşmeyi temsil eden bir türdür. Genellikle match fonksiyonundan oluşturulur.

match alanı, tüm eşleşen dize parçasını saklar. captures alanı, her bir yakalama grubu için numara ile indekslenmiş alt dizeleri saklar. Yakalama grubu adı ile indekslemek için, tüm eşleşme nesnesi bunun yerine indekslenmelidir; örneklerde gösterildiği gibi. Eşleşmenin başlangıç konumu offset alanında saklanır. offsets alanı, her yakalama grubunun başlangıç konumlarını saklar; 0, yakalanmamış bir grubu belirtir.

Bu tür, Regex'in yakalama grupları üzerinde bir yineleyici olarak kullanılabilir ve her grupta yakalanan alt dizeleri verir. Bu nedenle, bir eşleşmenin yakalamaları parçalanabilir. Eğer bir grup yakalanmamışsa, bir alt dize yerine nothing dönecektir.

RegexMatch nesnesini kabul eden yöntemler iterate, length, eltype, keys, haskey ve getindex için tanımlanmıştır; burada anahtarlar bir yakalama grubunun adları veya numaralarıdır. Daha fazla bilgi için keys'e bakın.

Örnekler

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; # yakalama gruplarını yineleme ile parçala

julia> hr
"11"

keys(m::RegexMatch) -> Vector

Tüm yakalama gruplarının anahtarlarını içeren bir vektör döndürür. Bir anahtar, yakalama grubu eşleşmeyi başaramasa bile dahil edilir. Yani, idx dönen değerde yer alacaktır, hatta m[idx] == nothing olsa bile.

İsimsiz yakalama grupları, indekslerine karşılık gelen tam sayı anahtarlarına sahip olacaktır. İsimli yakalama grupları ise string anahtarlarına sahip olacaktır.

Örnekler

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

Dize a dize b'den alfabetik sırada (teknik olarak, Unicode kod noktalarına göre leksikografik sırada) önce gelip gelmediğini test eder.

Örnekler

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

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

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

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

İki dizenin karakter karakter (teknik olarak, Unicode kod noktası bazında) eşit olup olmadığını test eder. Eğer dizelerden biri bir AnnotatedString ise, dize özelliklerinin de eşleşmesi gerekir.

Örnekler

julia> "abc" == "abc"
true

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

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

İki dizeyi karşılaştır. Her iki dize de aynı uzunluktaysa ve her bir indeksteki karakterler her iki dizede de aynıysa 0 döndür. a, b'nin ön eki ise veya a, b'den alfabetik sırada önce geliyorsa -1 döndür. b, a'nın ön eki ise veya b, a'dan alfabetik sırada önce geliyorsa (teknik olarak, Unicode kod noktalarına göre leksikografik sırada) 1 döndür.

Örnekler

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'yi string'e çevirir ve elde edilen string'i p ile soldan doldurarak n karakter (textwidth) uzunluğunda hale getirir. Eğer s zaten n karakter uzunluğundaysa, eşit bir string döndürülür. Varsayılan olarak boşluklarla doldurur.

Örnekler

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

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

s'yi string'e çevirir ve elde edilen string'i sağdan p ile doldurarak n karakter (textwidth) uzunluğunda hale getirir. Eğer s zaten n karakter uzunluğundaysa, eşit bir string döndürülür. Varsayılan olarak boşluklarla doldurur.

Örnekler

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

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

pattern'in string'deki ilk geçişini bulur. findnext(pattern, string, firstindex(s)) ile eşdeğerdir.

Örnekler

julia> findfirst("z", "Hello to the world") # hiçbir şey döndürmez, ancak REPL'de yazdırılmaz

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

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

pattern'ın string içinde start konumundan itibaren bir sonraki geçişini bulur. pattern bir dize veya bir düzenli ifade olabilir; bu durumda string String türünde olmalıdır.

Dönüş değeri, eşleşen dizinin bulunduğu indekslerin bir aralığıdır; böylece s[findnext(x, s, i)] == x:

findnext("substring", string, i) == start:stop böylece string[start:stop] == "substring" ve i <= start, veya eşleşmiyorsa nothing.

Örnekler

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 karakterinin start konumundan başlayarak string içinde bir sonraki geçişini bulur.

Örnekler

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

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

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

pattern'ın string içindeki son geçişini bulur. findprev(pattern, string, lastindex(string)) ile eşdeğerdir.

Örnekler

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

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

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

Karakter ch'nin string içindeki son geçişini bulur.

Örnekler

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

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

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

pattern'ın string içinde start konumundan başlayarak önceki bir örneğini bulur.

Dönüş değeri, eşleşen dizinin bulunduğu indekslerin bir aralığıdır; böylece s[findprev(x, s, i)] == x:

findprev("substring", string, i) == start:stop böylece string[start:stop] == "substring" ve stop <= i, veya eşleşme yoksa nothing.

Örnekler

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)

İlk argümanın ikinci argümanın bir alt dize olup olmadığını belirler. Eğer needle bir düzenli ifade ise, haystack'in bir eşleşme içerip içermediğini kontrol eder.

Örnekler

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

Ayrıca contains bakınız.

occursin(haystack)

haystack içinde argümanının geçip geçmediğini kontrol eden bir fonksiyon oluşturun, yani needle -> occursin(needle, haystack) fonksiyonuna eşdeğer bir fonksiyon.

Dönen fonksiyon Base.Fix2{typeof(occursin)} tipindedir.

Örnekler

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

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

Bir dizeyi tersine çevirir. Teknik olarak, bu işlev bir dizideki kod noktalarını tersine çevirir ve ana kullanımı, özellikle ters düzenli ifade aramaları için ters sıralı dize işleme içindir. s içindeki indeksleri reverse(s) içindeki indekslere ve tersine dönüştürmek için reverseind ve kullanıcı görünür "karakterler" (graphemes) üzerinde işlem yapmak için Unicode modülündeki graphemes'i de inceleyin. Kopya oluşturmadan ters sıralı yineleme için Iterators.reverse de mevcuttur. Özel dize türleri, reverse işlevini kendileri uygulamalıdır ve genellikle aynı tür ve kodlama ile bir dize döndürmelidir. Farklı bir kodlama ile bir dize döndürürlerse, s[reverseind(s,i)] == reverse(s)[i] koşulunu sağlamak için o dize türü için reverseind'i de geçersiz kılmalıdırlar.

Örnekler

julia> reverse("JuliaLang")
"gnaLailuJ"

Birleştirici karakterler sürpriz sonuçlara yol açabilir:

julia> reverse("ax̂e") # şapka x'in üzerinde, e'nin üzerinde
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # graphemes'i tersine çevirir; şapka x'in üzerinde hem girişte hem de çıkışta
"ex̂a"

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

Verilen pat desenini s içinde arayın ve her bir örneği r ile değiştirin. Eğer count sağlanmışsa, en fazla count örneği değiştirilir. pat tek bir karakter, bir vektör veya karakterler kümesi, bir dize veya bir düzenli ifade olabilir. Eğer r bir fonksiyonsa, her bir örnek r(s) ile değiştirilir; burada s, eşleşen alt dizedir (eğer pat bir AbstractPattern veya AbstractString ise) veya karakterdir (eğer pat bir AbstractChar veya bir AbstractChar koleksiyonu ise). Eğer pat bir düzenli ifade ise ve r bir SubstitutionString ise, o zaman r içindeki yakalama grubu referansları, karşılık gelen eşleşen metin ile değiştirilir. pat örneklerini string'den kaldırmak için, r'yi boş String ("") olarak ayarlayın.

Dönüş değeri, değişikliklerden sonra yeni bir dizedir. Eğer io::IO argümanı sağlanmışsa, dönüştürülmüş dize bunun yerine io'ya yazılır (dönüş io olur). (Örneğin, bu, önceden tahsis edilmiş bir tampon dizisini yerinde yeniden kullanmak için bir IOBuffer ile birlikte kullanılabilir.)

Birden fazla desen belirtilebilir ve bunlar soldan sağa aynı anda uygulanır, bu nedenle yalnızca bir desen herhangi bir karaktere uygulanır ve desenler yalnızca giriş metnine, değişikliklere değil, uygulanır.

Örnekler

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'yi dlm ayırıcılarının bulunduğu yerlerde ayırın ve alt dizelerin üzerinde bir yineleyici döndürün. dlm, findnext fonksiyonunun ilk argümanı olarak izin verilen herhangi bir formatta (yani bir dize, düzenli ifade veya bir fonksiyon olarak) veya tek bir karakter ya da karakterler koleksiyonu olarak olabilir.

dlm belirtilmezse, varsayılan olarak isspace kullanılır.

İsteğe bağlı anahtar kelime argümanları şunlardır:

• limit: sonucun maksimum boyutu. limit=0 maksimum yoktur (varsayılan)
• keepempty: boş alanların sonuçta tutulup tutulmayacağı. Varsayılan, dlm argümanı olmadan false, dlm argümanı ile true'dur.

Ayrıca bkz. split.

Örnekler

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 üzerinde dlm ayırıcı(ları) ile bölündüğünde üretilen SubString'lerin bir iteratörünü döndürür ve bunları ters sırayla (sağdan sola) verir. dlm, findprev fonksiyonunun ilk argümanı olarak izin verilen herhangi bir formatta (yani bir dize, tek bir karakter veya bir fonksiyon) veya bir karakter koleksiyonu olabilir.

dlm belirtilmezse, varsayılan olarak isspace kullanılır ve keepempty varsayılan olarak false olur.

İsteğe bağlı anahtar kelime argümanları şunlardır:

• Eğer limit > 0 ise, iteratör en fazla limit - 1 kez bölme yapacak ve geri kalan dizeyi bölmeden döndürecektir. limit < 1 bölmelere herhangi bir sınır koymaz (varsayılan).
• keepempty: iterasyon sırasında boş alanların döndürülüp döndürülmeyeceği. Varsayılan, dlm argümanı olmadan false, dlm argümanı ile true'dur.

split, rsplit ve eachsplit ile karşılaştırıldığında, bu fonksiyon girişteki alt dizeleri sağdan sola doğru iterasyon yapar.

Ayrıca bkz. eachsplit, rsplit.

Örnekler

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'yi dlm ayırıcılarının bulunduğu yerlerde alt dizeler dizisine ayırır. dlm, findnext fonksiyonunun ilk argümanı olarak izin verilen herhangi bir formatta (yani bir dize, düzenli ifade veya bir fonksiyon olarak) veya tek bir karakter ya da karakterler koleksiyonu olarak olabilir.

Eğer dlm belirtilmezse, varsayılan olarak isspace kullanılır.

İsteğe bağlı anahtar kelime argümanları şunlardır:

• limit: sonucun maksimum boyutu. limit=0 maksimum yoktur anlamına gelir (varsayılan)
• keepempty: boş alanların sonuçta tutulup tutulmayacağı. Varsayılan, dlm argümanı olmadan false, dlm argümanı ile true'dur.

Ayrıca rsplit, eachsplit ile de bakılabilir.

Örnekler

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)

Dizeyi sonundan başlamak üzere split ile benzer.

Örnekler

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'den baştaki ve sondaki karakterleri kaldırır; bu ya chars ile belirtilen karakterler ya da pred fonksiyonunun true döndürdüğü karakterlerdir.

Varsayılan davranış, baştaki ve sondaki boşluk ve ayırıcıları kaldırmaktır: kesin ayrıntılar için isspace bölümüne bakın.

İsteğe bağlı chars argümanı, kaldırılacak karakterleri belirtir: bu tek bir karakter, karakter vektörü veya karakter kümesi olabilir.

Ayrıca lstrip ve rstrip bölümlerine de bakın.

Örnekler

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

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

str'den önde bulunan karakterleri kaldırır, ya chars ile belirtilenler ya da pred fonksiyonunun true döndürdüğü karakterler.

Varsayılan davranış, önde bulunan boşluk ve ayırıcıları kaldırmaktır: kesin detaylar için isspace bölümüne bakın.

İsteğe bağlı chars argümanı, kaldırılacak karakterleri belirtir: bu tek bir karakter veya bir karakter vektörü ya da kümesi olabilir.

Ayrıca strip ve rstrip bölümlerine de bakın.

Örnekler

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

julia> lstrip(a)
"Mart"

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

str'den sonundaki karakterleri kaldırır, ya chars ile belirtilenler ya da pred fonksiyonunun true döndürdüğü karakterler.

Varsayılan davranış, sonundaki boşlukları ve ayırıcıları kaldırmaktır: kesin detaylar için isspace bölümüne bakın.

İsteğe bağlı chars argümanı, kaldırılacak karakterleri belirtir: bu tek bir karakter veya bir karakter vektörü veya kümesi olabilir.

Ayrıca strip ve lstrip ile de bakabilirsiniz.

Örnekler

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

julia> rstrip(a)
"Mart"

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

prefix ile başlayan s için true döner; prefix bir dize, bir karakter veya karakterlerin bir demeti/vektörü/kümesi olabilir. Eğer prefix bir demet/vektör/küme ise, s'nin ilk karakterinin o kümenin bir parçası olup olmadığını test edin.

Ayrıca endswith, contains bakınız.

Örnekler

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

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

Bir IO nesnesinin bir dize, bir karakter veya bir karakterin demeti/vektörü/kümesi olabilen bir ön ek ile başlayıp başlamadığını kontrol eder. Ayrıca bkz. peek.

startswith(prefix)

prefix ile başlayan bir argümanın olup olmadığını kontrol eden bir fonksiyon oluşturun, yani y -> startswith(y, prefix) fonksiyonuna eşdeğer bir fonksiyon.

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

Örnekler

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

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

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

prefix regex desen s'nin başında olup olmadığını kontrol eder ve true döner.

Ayrıca occursin ve endswith bakınız.

Örnekler

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

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

suffix ile bitip bitmediğini kontrol etmek için s'yi true döndürür; suffix bir dize, bir karakter veya bir karakterler demeti/vektörü/kümesi olabilir. Eğer suffix bir demet/vektör/küme ise, s'nin son karakterinin bu kümenin bir parçası olup olmadığını test edin.

Ayrıca startswith, contains bakınız.

Örnekler

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

endswith(suffix)

Bir argümanın suffix ile bitip bitmediğini kontrol eden bir fonksiyon oluşturun, yani y -> endswith(y, suffix) fonksiyonuna eşdeğer bir fonksiyon.

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

Örnekler

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

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

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

true döndürür eğer s, regex deseni suffix ile bitiyorsa.

Ayrıca bkz. occursin ve startswith.

Örnekler

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

contains(haystack::AbstractString, needle)

haystack içinde needle varsa true döner. Bu, occursin(needle, haystack) ile aynıdır, ancak startswith(haystack, needle) ve endswith(haystack, needle) ile tutarlılık sağlamak için sunulmuştur.

Ayrıca bkz. occursin, in, issubset.

Örnekler

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(iğne)

Bir argümanın iğne içerip içermediğini kontrol eden bir fonksiyon oluşturun, yani samanlık -> contains(samanlık, iğne) fonksiyonuna eşdeğer bir fonksiyon.

Dönen fonksiyon Base.Fix2{typeof(contains)} tipindedir ve özel yöntemler uygulamak için kullanılabilir.

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

s'ninci n karakterden oluşan bir dize döndürür.

Örnekler

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

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

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

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

s'nin son n karakterinden oluşan bir dize alır.

Örnekler

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

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

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

uppercase(c::AbstractChar)

c'yi büyük harfe dönüştür.

Ayrıca bkz. lowercase, titlecase.

Örnekler

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (kategori Lu: Harf, büyük harf)

julia> uppercase('ê')
'Ê': Unicode U+00CA (kategori Lu: Harf, büyük harf)

uppercase(s::AbstractString)

Tüm karakterleri büyük harfe dönüştürerek s'yi döndürür.

Ayrıca lowercase, titlecase, uppercasefirst bakınız.

Örnekler

julia> uppercase("Julia")
"JULIA"

küçükharf(c::AbstractChar)

c'yi küçük harfe dönüştür.

Ayrıca bkz. büyükharf, başharf.

Örnekler

julia> küçükharf('A')
'a': ASCII/Unicode U+0061 (kategori Ll: Harf, küçük harf)

julia> küçükharf('Ö')
'ö': Unicode U+00F6 (kategori Ll: Harf, küçük harf)

lowercase(s::AbstractString)

Tüm karakterleri küçük harfe dönüştürerek s'yi döndürür.

Ayrıca bkz. uppercase, titlecase, lowercasefirst.

Örnekler

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

titlecase(c::AbstractChar)

c'yi başlık durumuna dönüştür. Bu, çift harfler için büyük harften farklı olabilir, aşağıdaki örneği karşılaştırın.

Ayrıca bkz. uppercase, lowercase.

Örnekler

julia> titlecase('a')
'A': ASCII/Unicode U+0041 (kategori Lu: Harf, büyük harf)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (kategori Lt: Harf, başlık durumu)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (kategori Lu: Harf, büyük harf)

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

s içindeki her kelimenin ilk karakterini büyük harfle başlatır; eğer strict true ise, diğer tüm karakterler küçük harfe dönüştürülür, aksi takdirde olduğu gibi bırakılır. Varsayılan olarak, yeni bir graphem ile başlayan tüm harf dışı karakterler kelime ayırıcı olarak kabul edilir; hangi karakterlerin kelime ayırıcı olarak kabul edileceğini belirlemek için wordsep anahtar kelimesi ile bir predikat geçirilebilir. Sadece s içindeki ilk karakteri büyük harfle başlatmak için uppercasefirst fonksiyonuna da bakın.

Ayrıca uppercase, lowercase, uppercasefirst fonksiyonlarına da bakın.

Örnekler

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'yi ilk karakterini büyük harfe çevirerek döndürür (teknik olarak Unicode için "başlık durumu"). S'deki her kelimenin ilk karakterini büyük harfe çevirmek için titlecase ile de bakabilirsiniz.

Ayrıca lowercasefirst, uppercase, lowercase, titlecase ile de bakabilirsiniz.

Örnekler

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

İlk karakteri küçük harfe dönüştürülmüş s'yi döndürür.

Ayrıca bkz. uppercasefirst, uppercase, lowercase, titlecase.

Örnekler

julia> lowercasefirst("Julia")
"julia"

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

Herhangi bir iterator'ı tek bir dizeye birleştirir, komşu öğeler arasında verilen ayırıcıyı (varsa) ekler. Eğer last verilmişse, son iki öğe arasında delim yerine kullanılacaktır. iterator'ın her bir öğesi print(io::IOBuffer, x) aracılığıyla bir dizeye dönüştürülür. Eğer io verilmişse, sonuç bir String olarak döndürülmek yerine io'ya yazılır.

Örnekler

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'den ilk head ve son tail karakterlerini kaldırır. chop(s) çağrısı s'den son karakteri kaldırır. Eğer length(s)'den daha fazla karakter kaldırılması isteniyorsa, boş bir dize döndürülür.

Ayrıca bkz. chomp, startswith, first.

Örnekler

julia> a = "Mart"
"Mart"

julia> chop(a)
"Mar"

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

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

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

prefix'i s'den kaldır. Eğer s, prefix ile başlamıyorsa, s'ye eşit bir string döndürülür.

Ayrıca bkz. chopsuffix.

Örnekler

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

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

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

s'den suffix'i kaldırır. Eğer s, suffix ile bitmiyorsa, s'ye eşit bir dize döndürülür.

Ayrıca chopprefix bakınız.

Örnekler

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

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

chomp(s::AbstractString) -> SubString

Bir dize üzerindeki tek bir son satır sonunu kaldırır.

Ayrıca bkz. chop.

Örnekler

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

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

Eğer i, s içinde sınırlar içindeyse, i'nin parçası olduğu karakterin kodlama kod biriminin başlangıç indeksini döndür. Başka bir deyişle, eğer i bir karakterin başlangıcıysa, i'yi döndür; eğer i bir karakterin başlangıcı değilse, bir karakterin başlangıcına kadar geri sar ve o indeksi döndür. Eğer i, 0 veya ncodeunits(s)+1'e eşitse, i'yi döndür. Diğer tüm durumlarda BoundsError fırlat.

Örnekler

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

julia> thisind("α", 4)
HATA: BoundsError: 2-kod birimlik String'e [4] indeksinde erişim denemesi
[...]

julia> thisind("α", -1)
HATA: BoundsError: 2-kod birimlik String'e [-1] indeksinde erişim denemesi
[...]

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

• Durum n == 1

  Eğer i s içinde geçerliyse, i indeksinden sonra başlayan karakterin başlangıç indeksini döndür. Başka bir deyişle, eğer i bir karakterin başlangıcıysa, bir sonraki karakterin başlangıcını döndür; eğer i bir karakterin başlangıcı değilse, bir karakterin başlangıcına kadar ilerle ve o indeksi döndür. Eğer i 0'a eşitse 1 döndür. Eğer i geçerli bir indeksse ama lastindex(str)'ten büyük veya eşitse ncodeunits(str)+1 döndür. Aksi takdirde BoundsError fırlatılır.

• Durum n > 1

  n==1 için nextind uygulamak gibi davranır. Tek fark, eğer n o kadar büyükse ki nextind uygulamak ncodeunits(str)+1'e ulaşırsa, kalan her iterasyon döndürülen değeri 1 artırır. Bu, bu durumda nextind'in ncodeunits(str)+1'den büyük bir değer döndürebileceği anlamına gelir.

• Durum n == 0

  i yalnızca s içinde geçerli bir indeksse veya 0'a eşitse döndürülür. Aksi takdirde StringIndexError veya BoundsError fırlatılır.

Örnekler

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

julia> nextind("α", 3)
HATA: BoundsError: [3] indeksinde 2-kod bir String'e erişim denemesi
[...]

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

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

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

• Durum n == 1

  Eğer i s içinde geçerliyse, i indeksinden önce başlayan karakterin başlangıç indeksini döndür. Başka bir deyişle, eğer i bir karakterin başlangıcıysa, önceki karakterin başlangıcını döndür; eğer i bir karakterin başlangıcı değilse, bir karakterin başlangıcına kadar geri sar ve o indeksi döndür. Eğer i 1'e eşitse 0 döndür. Eğer i ncodeunits(str)+1'e eşitse lastindex(str) döndür. Aksi takdirde BoundsError fırlatılır.

• Durum n > 1

  n==1 için prevind uygulamak gibi davranır. Tek fark, eğer n o kadar büyükse ki prevind uygulamak 0'a ulaşırsa, her kalan iterasyon döndürülen değeri 1 azaltır. Bu durumda prevind negatif bir değer döndürebilir.

• Durum n == 0

  i yalnızca str içinde geçerli bir indeksse veya ncodeunits(str)+1'e eşitse döndürülür. Aksi takdirde StringIndexError veya BoundsError fırlatılır.

Örnekler

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

julia> prevind("α", 0)
HATA: BoundsError: 2-kod bir String'e [0] indeksinden erişim denemesi
[...]

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

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

textwidth(c)

Bir karakteri yazdırmak için gereken sütun sayısını verir.

Örnekler

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

Bir dizeyi yazdırmak için gereken sütun sayısını verir.

Örnekler

julia> textwidth("March")
5

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

Bir karakterin ASCII karakter setine ait olup olmadığını veya bir dizi içindeki tüm elemanlar için bunun doğru olup olmadığını test eder.

Örnekler

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

Örneğin, isascii fonksiyonu filter veya replace için bir predikat fonksiyonu olarak kullanılabilir; sırasıyla ASCII olmayan karakterleri kaldırmak veya değiştirmek için:

julia> filter(isascii, "abcdeγfgh") # ASCII olmayan karakterleri at
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # ASCII olmayan karakterleri boşluklarla değiştir
"abcde fgh"

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

Vektördeki tüm değerlerin ASCII karakter kümesine (0x00 ile 0x7f arasında) ait olup olmadığını test eder. Bu fonksiyon, hızlı bir ASCII kontrolüne ihtiyaç duyan diğer string uygulamaları tarafından kullanılmak üzere tasarlanmıştır.

iscntrl(c::AbstractChar) -> Bool

Bir karakterin kontrol karakteri olup olmadığını test eder. Kontrol karakterleri, Unicode'un Latin-1 alt kümesinin yazdırılamayan karakterleridir.

Örnekler

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

Bir karakterin ondalık rakam (0-9) olup olmadığını test eder.

Ayrıca bkz: isletter.

Örnekler

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

Bir karakterin harf olup olmadığını test eder. Bir karakter, Unicode genel kategorisi Harf'e ait olduğunda, yani kategori kodu 'L' ile başlayan bir karakter olduğunda harf olarak sınıflandırılır.

Ayrıca bkz: isdigit.

Örnekler

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

Bir karakterin küçük harf olup olmadığını test eder (Unicode standardının Lowercase türetilmiş özelliğine göre).

Ayrıca isuppercase bakınız.

Örnekler

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

Bir karakterin sayısal olup olmadığını test eder. Bir karakter, Unicode genel kategorisi Sayı'ya ait olduğunda sayısal olarak sınıflandırılır, yani kategori kodu 'N' ile başlayan bir karakterdir.

Bu geniş kategori, ¾ ve ௰ gibi karakterleri içerir. Bir karakterin 0 ile 9 arasında bir ondalık rakam olup olmadığını kontrol etmek için isdigit kullanın.

Örnekler

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

Bir karakterin yazdırılabilir olup olmadığını, boşluklar dahil, ancak kontrol karakterleri hariç test eder.

Örnekler

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

Bir karakterin Unicode genel kategorisi Noktalama işaretine ait olup olmadığını test eder, yani kategori kodu 'P' ile başlayan bir karakterdir.

Örnekler

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

Bir karakterin herhangi bir boşluk karakteri olup olmadığını test eder. ASCII karakterleri '\t', '\n', '\v', '\f', '\r' ve ' ', Latin-1 karakteri U+0085 ve Unicode kategorisi Zs'deki karakterleri içerir.

Örnekler

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

Bir karakterin büyük harf olup olmadığını test eder (Unicode standardının Uppercase türetilmiş özelliğine göre).

Ayrıca islowercase bakınız.

Örnekler

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

Bir karakterin geçerli bir onaltılık basamak olup olmadığını test eder. Bunun 0x ön eki gibi standartta x'i içermediğini unutmayın.

Örnekler

julia> isxdigit('a')
true

julia> isxdigit('x')
false

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

Geleneksel C ve Unicode kaçış dizilerinin genel kaçışı. İlk form kaçış dizisini döndürür, ikinci form sonucu ioya yazdırır.

Ters eğik çizgiler (\) çift ters eğik çizgi ile ("\\") kaçırılır. Yazdırılamayan karakterler ya standart C kaçış kodlarıyla, NUL için "\0" (eğer belirsiz değilse), unicode kod noktası ("\u" ön eki) veya onaltılık ("\x" ön eki) ile kaçırılır.

İsteğe bağlı esc argümanı, ayrıca ters eğik çizgi ile kaçırılması gereken herhangi bir ek karakteri belirtir (" de ilk formda varsayılan olarak kaçırılır).

keep argümanı, olduğu gibi tutulması gereken karakterlerin bir koleksiyonunu belirtir. Burada esc önceliklidir.

Ayrıca unescape_string ters işlem için bakınız.

Örnekler

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

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

julia> escape_string("\xfe\xff") # geçersiz utf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # belirsiz değil
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 belirsiz olurdu
"ℵ\\x000"

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

Ham bir dizeyi ham dize literalleri için ayrıştırma sırasında kullanılan şekilde kaçış yapar. Girdi dizesindeki her çift tırnak (") karakteri için s (veya belirtilmişse delim), bu fonksiyon önceki ters eğik çizgi (\) karakterlerinin sayısını n olarak sayar ve ardından n'den 2n+1'e kadar ters eğik çizgilerin sayısını artırır (n = 0 için bile). Ayrıca, dize sonundaki ters eğik çizgi dizisini de iki katına çıkarır.

Bu kaçış kuralı, ham dizelerde ve diğer standart dışı dize literallerinde kullanılır. (Ayrıca, Microsoft C/C++ derleyici çalışma zamanının bir komut satırı dizesini argv[] dizisine ayrıştırırken beklediği kaçış kuralıdır.)

Ayrıca escape_string bakınız.

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

Geleneksel C ve Unicode kaçış dizilerinin genel çözülmesi. İlk form, kaçış dizisini döndürür, ikincisi sonucu io'ya yazdırır. keep argümanı, olduğu gibi tutulacak karakterlerin (ve ters eğik çizgilerin) bir koleksiyonunu belirtir.

Aşağıdaki kaçış dizileri tanınır:

• Kaçış ters eğik çizgi (\\)
• Kaçış çift tırnak (\")
• Standart C kaçış dizileri (\a, \b, \t, \n, \v, \f, \r, \e)
• Unicode BMP kod noktaları (\u ile 1-4 ardışık onaltılık basamak)
• Tüm Unicode kod noktaları (\U ile 1-8 ardışık onaltılık basamak; maksimum değer = 0010ffff)
• Onaltılık baytlar (\x ile 1-2 ardışık onaltılık basamak)
• Sekizli baytlar (\ ile 1-3 ardışık sekizli basamak)

Ayrıca escape_string bakınız.

Örnekler

julia> unescape_string("aaa\\nbbb") # C kaçış dizisi
"aaa\nbbb"

julia> unescape_string("\\u03c0") # unicode
"π"

julia> unescape_string("\\101") # sekizli
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # `keep` argümanını kullanma
"aaa \\g \n"

AnnotatedString{S <: AbstractString} <: AbstractString

Metadata içeren, anotasyonlu bölgeler şeklinde bir dize.

Daha spesifik olarak, bu, sarılı dize içindeki bölgelerin etiketli değerlerle anotasyonlanmasına izin veren herhangi bir AbstractString etrafında basit bir sargıdır.

                           C
                    ┌──────┸─────────┐
  "bu bir örnek anotasyonlu dizedir"
  └──┰────────┼─────┘         │
     A        └─────┰─────────┘
                    B

Yukarıdaki diyagram, üç aralığın anotasyonlandığı bir AnnotatedString'i temsil etmektedir (etiketleri A, B ve C). Her anotasyon bir etiket (Symbol) ve bir değer (Any) tutar. Bu üç bilgi, @NamedTuple{region::UnitRange{Int64}, label::Symbol, value} olarak tutulur.

Etiketlerin benzersiz olması gerekmez, aynı bölge aynı etiketle birden fazla anotasyon tutabilir.

Genel olarak AnnotatedString'ler için yazılan kod, aşağıdaki özellikleri korumalıdır:

• Bir anotasyonun hangi karakterlere uygulandığı
• Her karakter için anotasyonların uygulandığı sıra

AnnotatedString'lerin belirli kullanımlarıyla ek anlamlar getirilebilir.

Bu kuralların bir sonucu olarak, aynı etiket ve değerlere sahip bitişik, ardışık yerleştirilmiş anotasyonlar, birleşik aralığı kapsayan tek bir anotasyona eşdeğerdir.

Ayrıca AnnotatedChar, annotatedstring, annotations ve annotate! ile de bakılabilir.

Yapıcılar

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

Bir AnnotatedString, annotatedstring ile de oluşturulabilir; bu, string gibi çalışır ancak argümanlarda mevcut olan herhangi bir anotasyonu korur.

Örnekler

julia> AnnotatedString("bu bir örnek anotasyonlu dizedir",
                    [(1:18, :A => 1), (12:28, :B => 2), (18:35, :C => 3)])
"bu bir örnek anotasyonlu dizedir"

AnnotatedChar{S <: AbstractChar} <: AbstractChar

A Char with annotations.

More specifically, this is a simple wrapper around any other AbstractChar, which holds a list of arbitrary labelled annotations (@NamedTuple{label::Symbol, value}) with the wrapped character.

See also: AnnotatedString, annotatedstring, annotations, and annotate!.

Constructors

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

Examples

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

annotatedstring(values...)

Herhangi bir sayıda values kullanarak bir AnnotatedString oluşturur ve bunların print edilmiş temsilini kullanır.

Bu, string gibi çalışır, ancak mevcut olan herhangi bir notasyonu (AnnotatedString veya AnnotatedChar değerleri şeklinde) korumaya özen gösterir.

Ayrıca bkz. AnnotatedString ve AnnotatedChar.

Örnekler

julia> annotatedstring("şimdi bir AnnotatedString")
"şimdi bir AnnotatedString"

julia> annotatedstring(AnnotatedString("notlu", [(1:9, :label => 1)]), ", ve notsuz")
"notlu, ve notsuz"

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

`str` için geçerli olan tüm notları alın. `position` sağlanırsa, yalnızca `position` ile örtüşen notlar döndürülecektir.

Notlar, uygulandıkları bölgelerle birlikte, bölge–not çiftleri şeklinde bir vektör olarak sağlanır.

[`AnnotatedString`](@ref) belgelerinde belgelenen anlamlara uygun olarak, döndürülen notların sırası, uygulandıkları sırayı yansıtır.

Ayrıca bkz: [`annotate!`](@ref).

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

chr'nin tüm anotasyonlarını, anotasyon çiftleri vektörü biçiminde alın.

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

Bir str (veya tüm dize) için etiketli bir değer (label => value) ile bir range'i anotlayın. Mevcut label anotasyonlarını kaldırmak için nothing değerini kullanın.

str üzerinde anotasyonların uygulanma sırası anlamsal olarak önemlidir; bu, AnnotatedString içinde açıklanmıştır.

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

char'ı label => value çifti ile anotlayın.