Strings

Le type AbstractString est le supertype de toutes les implémentations de chaînes en Julia. Les chaînes sont des encodages de séquences de points de code Unicode tels que représentés par le type AbstractChar. Julia fait quelques hypothèses sur les chaînes :

• Les chaînes sont encodées en termes d'« unités de code » de taille fixe

  • Les unités de code peuvent être extraites avec codeunit(s, i)
  • La première unité de code a l'index 1
  • La dernière unité de code a l'index ncodeunits(s)
  • Tout index i tel que 1 ≤ i ≤ ncodeunits(s) est dans les limites

• L'indexation des chaînes se fait en termes de ces unités de code :

  • Les caractères sont extraits par s[i] avec un index de chaîne valide i
  • Chaque AbstractChar dans une chaîne est encodé par une ou plusieurs unités de code
  • Seul l'index de la première unité de code d'un AbstractChar est un index valide
  • L'encodage d'un AbstractChar est indépendant de ce qui le précède ou le suit
  • Les encodages de chaînes sont auto-synchronisants – c'est-à-dire que isvalid(s, i) est O(1)

Certaines fonctions de chaîne qui extraient des unités de code, des caractères ou des sous-chaînes des chaînes renvoient une erreur si vous leur passez des indices de chaîne hors limites ou invalides. Cela inclut codeunit(s, i) et s[i]. Les fonctions qui effectuent des calculs d'index de chaîne adoptent une approche plus détendue de l'indexation et vous donnent l'index de chaîne valide le plus proche lorsqu'il est dans les limites, ou lorsqu'il est hors limites, se comportent comme s'il y avait un nombre infini de caractères remplissant chaque côté de la chaîne. En général, ces caractères de remplissage imaginaires ont une longueur d'unité de code de 1, mais les types de chaînes peuvent choisir différentes tailles de caractères « imaginaires » selon ce qui a du sens pour leurs implémentations (par exemple, les sous-chaînes peuvent transmettre les calculs d'index à la chaîne sous-jacente à laquelle elles fournissent une vue). Les fonctions d'indexation détendues incluent celles destinées aux calculs d'index : thisind, nextind et prevind. Ce modèle permet aux calculs d'index de fonctionner avec des indices hors limites en tant que valeurs intermédiaires tant que l'on ne les utilise jamais pour récupérer un caractère, ce qui aide souvent à éviter d'avoir besoin de coder autour des cas limites.

Voir aussi codeunit, ncodeunits, thisind, nextind, prevind.

Le type AbstractChar est le supertype de toutes les implémentations de caractères en Julia. Un caractère représente un point de code Unicode et peut être converti en un entier via la fonction codepoint afin d'obtenir la valeur numérique du point de code, ou construit à partir du même entier. Ces valeurs numériques déterminent comment les caractères sont comparés avec < et ==, par exemple. Les nouveaux types T <: AbstractChar devraient définir une méthode codepoint(::T) et un constructeur T(::UInt32), au minimum.

Un sous-type donné d'AbstractChar peut être capable de représenter uniquement un sous-ensemble de Unicode, auquel cas la conversion d'une valeur UInt32 non prise en charge peut générer une erreur. Inversement, le type intégré Char représente un superset de Unicode (afin d'encoder sans perte des flux d'octets invalides), auquel cas la conversion d'une valeur non-Unicode en UInt32 génère une erreur. La fonction isvalid peut être utilisée pour vérifier quels points de code sont représentables dans un type AbstractChar donné.

En interne, un type AbstractChar peut utiliser une variété d'encodages. La conversion via codepoint(char) ne révélera pas cet encodage car elle renvoie toujours la valeur Unicode du caractère. print(io, c) de tout c::AbstractChar produit un encodage déterminé par io (UTF-8 pour tous les types IO intégrés), via conversion en Char si nécessaire.

write(io, c), en revanche, peut émettre un encodage en fonction de typeof(c), et read(io, typeof(c)) devrait lire le même encodage que write. Les nouveaux types AbstractChar doivent fournir leurs propres implémentations de write et read.

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

Char est un type AbstractChar de 32 bits qui est la représentation par défaut des caractères dans Julia. Char est le type utilisé pour les littéraux de caractères comme 'x' et c'est aussi le type d'élément de String.

Pour représenter sans perte des flux d'octets arbitraires stockés dans un String, une valeur Char peut stocker des informations qui ne peuvent pas être converties en un point de code Unicode — convertir un tel Char en UInt32 générera une erreur. La fonction isvalid(c::Char) peut être utilisée pour vérifier si c représente un caractère Unicode valide.

codepoint(c::AbstractChar) -> Integer

Renvoie le point de code Unicode (un entier non signé) correspondant au caractère c (ou lève une exception si c ne représente pas un caractère valide). Pour Char, il s'agit d'une valeur UInt32, mais les types AbstractChar qui ne représentent qu'un sous-ensemble de Unicode peuvent renvoyer un entier de taille différente (par exemple, UInt8).

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

Retourne le nombre de caractères dans la chaîne s des indices i à j.

Cela est calculé comme le nombre d'indices d'unités de code de i à j qui sont des indices de caractères valides. Avec un seul argument de chaîne, cela calcule le nombre de caractères dans l'ensemble de la chaîne. Avec les arguments i et j, cela calcule le nombre d'indices entre i et j inclus qui sont des indices valides dans la chaîne s. En plus des valeurs dans les limites, i peut prendre la valeur hors limites ncodeunits(s) + 1 et j peut prendre la valeur hors limites 0.

Voir aussi isvalid, ncodeunits, lastindex, thisind, nextind, prevind.

Exemples

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

sizeof(str::AbstractString)

Taille, en octets, de la chaîne str. Égal au nombre d'unités de code dans str multiplié par la taille, en octets, d'une unité de code dans str.

Exemples

julia> sizeof("")
0

julia> sizeof("∀")
3

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

Concaténer des chaînes et/ou des caractères, produisant un String ou un AnnotatedString (selon le cas). Cela équivaut à appeler la fonction string ou annotatedstring sur les arguments. La concaténation des types de chaînes intégrés produit toujours une valeur de type String, mais d'autres types de chaînes peuvent choisir de retourner une chaîne d'un type différent si cela est approprié.

Exemples

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

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

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

Répète une chaîne ou un caractère n fois. Cela peut également être écrit comme repeat(s, n).

Voir aussi repeat.

Exemples

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

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

Convertir un entier n en une chaîne dans la base donnée, en spécifiant éventuellement un nombre de chiffres à compléter.

Voir aussi digits, bitstring, count_zeros.

Exemples

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

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

string(xs...)

Créez une chaîne à partir de n'importe quelle valeur en utilisant la fonction print.

string ne doit généralement pas être défini directement. Au lieu de cela, définissez une méthode print(io::IO, x::MyType). Si string(x) pour un certain type doit être très efficace, il peut être judicieux d'ajouter une méthode à string et de définir print(io::IO, x::MyType) = print(io, string(x)) pour garantir que les fonctions sont cohérentes.

Voir aussi : String, repr, sprint, show.

Exemples

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

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

Répète une chaîne r fois. Cela peut être écrit comme s^r.

Voir aussi ^.

Exemples

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

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

Répète un caractère r fois. Cela peut également être accompli en appelant c^r.

Exemples

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

repr(x; context=nothing)

Créez une chaîne à partir de n'importe quelle valeur en utilisant la fonction show. Vous ne devez pas ajouter de méthodes à repr; définissez plutôt une méthode show.

L'argument clé optionnel context peut être défini comme une paire :key=>value, un tuple de paires :key=>value, ou un objet IO ou IOContext dont les attributs sont utilisés pour le flux I/O passé à show.

Notez que repr(x) est généralement similaire à la façon dont la valeur de x serait saisie en Julia. Voir aussi repr(MIME("text/plain"), x) pour retourner à la place une version "jolie" de x conçue davantage pour la consommation humaine, équivalente à l'affichage REPL de x.

Exemples

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)

Crée une nouvelle String à partir d'un AbstractString existant.

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

Comme getindex, mais renvoie une vue dans la chaîne parente s dans la plage i:j ou r respectivement au lieu de faire une copie.

Le macro @views convertit toutes les tranches de chaînes s[i:j] en sous-chaînes SubString(s, i, j) dans un bloc de code.

Exemples

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

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

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

LazyString <: AbstractString

Une représentation paresseuse de l'interpolation de chaînes. Cela est utile lorsqu'une chaîne doit être construite dans un contexte où l'interpolation réelle et la construction de la chaîne sont inutiles ou indésirables (par exemple, dans les chemins d'erreur des fonctions).

Ce type est conçu pour être peu coûteux à construire à l'exécution, essayant de décharger autant de travail que possible soit sur le macro, soit sur les opérations d'impression ultérieures.

Exemples

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

Voir aussi @lazy_str.

Aide étendue

Propriétés de sécurité pour les programmes concurrents

Une chaîne paresseuse elle-même n'introduit aucun problème de concurrence même si elle est imprimée dans plusieurs tâches Julia. Cependant, si les méthodes print sur une valeur capturée peuvent avoir un problème de concurrence lorsqu'elles sont invoquées sans synchronisations, l'impression de la chaîne paresseuse peut poser un problème. De plus, les méthodes print sur les valeurs capturées peuvent être invoquées plusieurs fois, bien qu'un seul résultat exact soit retourné.

lazy"str"

Créez un LazyString en utilisant la syntaxe d'interpolation de chaîne régulière. Notez que les interpolations sont évaluées au moment de la construction de LazyString, mais que l'impression est retardée jusqu'au premier accès à la chaîne.

Consultez la documentation de LazyString pour les propriétés de sécurité des programmes concurrents.

Exemples

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

julia> typeof(str)
LazyString

transcode(T, src)

Convertir des données de chaîne entre les encodages Unicode. src est soit une String soit un Vector{UIntXX} d'unités de code UTF-XX, où XX est 8, 16 ou 32. T indique l'encodage de la valeur de retour : String pour retourner une String (encodée en UTF-8) ou UIntXX pour retourner un Vector{UIntXX} de données UTF-XX. (L'alias Cwchar_t peut également être utilisé comme type entier, pour convertir des chaînes wchar_t* utilisées par des bibliothèques C externes.)

La fonction transcode réussit tant que les données d'entrée peuvent être raisonnablement représentées dans l'encodage cible ; elle réussit toujours pour les conversions entre les encodages UTF-XX, même pour des données Unicode invalides.

Seule la conversion vers/depuis UTF-8 est actuellement prise en charge.

Exemples

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

Copie une chaîne à partir de l'adresse d'une chaîne de style C (terminée par NUL) encodée en UTF-8. (Le pointeur peut être libéré en toute sécurité par la suite.) Si length est spécifié (la longueur des données en octets), la chaîne n'a pas besoin d'être terminée par NUL.

Cette fonction est étiquetée "unsafe" car elle plantera si p n'est pas une adresse mémoire valide pour des données de la longueur demandée.

ncodeunits(s::AbstractString) -> Int

Retourne le nombre d'unités de code dans une chaîne. Les indices qui sont dans les limites pour accéder à cette chaîne doivent satisfaire 1 ≤ i ≤ ncodeunits(s). Tous ces indices ne sont pas valides – ils peuvent ne pas être le début d'un caractère, mais ils retourneront une valeur d'unité de code lors de l'appel de codeunit(s,i).

Exemples

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

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

Voir aussi codeunit, checkbounds, sizeof, length, lastindex.

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

Renvoie le type d'unité de code de l'objet chaîne donné. Pour les chaînes encodées en ASCII, Latin-1 ou UTF-8, cela serait UInt8 ; pour UCS-2 et UTF-16, cela serait UInt16 ; pour UTF-32, cela serait UInt32. Le type d'unité de code ne doit pas être limité à ces trois types, mais il est difficile de penser à des encodages de chaînes largement utilisés qui n'utilisent pas l'une de ces unités. codeunit(s) est le même que typeof(codeunit(s,1)) lorsque s est une chaîne non vide.

Voir aussi ncodeunits.

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

Retourne la valeur de l'unité de code dans la chaîne s à l'index i. Notez que

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

C'est-à-dire que la valeur retournée par codeunit(s, i) est du type retourné par codeunit(s).

Exemples

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

julia> typeof(a)
UInt8

Voir aussi ncodeunits, checkbounds.

codeunits(s::AbstractString)

Obtenez un objet semblable à un vecteur contenant les unités de code d'une chaîne. Renvoie par défaut un wrapper CodeUnits, mais codeunits peut être défini en option pour de nouveaux types de chaînes si nécessaire.

Exemples

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

ascii(s::AbstractString)

Convertir une chaîne en type String et vérifier qu'elle ne contient que des données ASCII, sinon lever une ArgumentError indiquant la position du premier octet non-ASCII.

Voir aussi le prédicat isascii pour filtrer ou remplacer les caractères non-ASCII.

Exemples

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

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags]) <: AbstractPattern

Un type représentant une expression régulière. Les objets Regex peuvent être utilisés pour faire correspondre des chaînes avec match.

Les objets Regex peuvent être créés en utilisant le macro de chaîne @r_str. Le constructeur Regex(pattern[, flags]) est généralement utilisé si la chaîne pattern doit être interpolée. Voir la documentation du macro de chaîne pour des détails sur les flags.

@r_str -> Regex

Construisez une regex, telle que r"^[a-z]*$", sans interpolation et sans déséchapper (sauf pour le guillemet " qui doit toujours être échappé). La regex accepte également un ou plusieurs indicateurs, listés après la citation de fin, pour modifier son comportement :

• i active la correspondance insensible à la casse
• m traite les tokens ^ et $ comme correspondant au début et à la fin de lignes individuelles, plutôt qu'à l'ensemble de la chaîne.
• s permet au modificateur . de correspondre aux nouvelles lignes.
• x active le "mode d'espacement libre" : les espaces entre les tokens regex sont ignorés sauf s'ils sont échappés avec \, et # dans la regex est traité comme le début d'un commentaire (qui est ignoré jusqu'à la fin de la ligne).
• a active le mode ASCII (désactive les modes UTF et UCP). Par défaut, \B, \b, \D, \d, \S, \s, \W, \w, etc. correspondent en fonction des propriétés de caractères Unicode. Avec cette option, ces séquences ne correspondent qu'aux caractères ASCII. Cela inclut également \u, qui émettra la valeur de caractère spécifiée directement en tant que byte unique, et ne tentera pas de l'encoder en UTF-8. Il est important de noter que cette option permet de correspondre à des chaînes UTF-8 invalides, en traitant à la fois le matcher et la cible comme de simples bytes (comme s'ils étaient des bytes ISO/IEC 8859-1 / Latin-1) plutôt que comme des encodages de caractères. Dans ce cas, cette option est souvent combinée avec s. Cette option peut être affinée en commençant le motif par (UCP) ou (UTF).

Voir Regex si une interpolation est nécessaire.

Exemples

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

Cette regex a les trois premiers indicateurs activés.

SubstitutionString(substr) <: AbstractString

Stocke la chaîne donnée substr en tant que SubstitutionString, pour une utilisation dans les substitutions d'expressions régulières. Construit le plus souvent à l'aide du macro @s_str.

Exemples

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

Construit une chaîne de substitution, utilisée pour les substitutions d'expressions régulières. Dans la chaîne, les séquences de la forme \N font référence au N-ième groupe de capture dans l'expression régulière, et \g<groupname> fait référence à un groupe de capture nommé avec le nom groupname.

Exemples

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

Créez une chaîne brute sans interpolation ni désévasion. L'exception est que les guillemets doivent toujours être échappés. Les barres obliques inverses échappent à la fois les guillemets et les autres barres obliques inverses, mais seulement lorsqu'une séquence de barres obliques inverses précède un caractère de citation. Ainsi, 2n barres obliques inverses suivies d'une citation codent n barres obliques inverses et la fin du littéral, tandis que 2n+1 barres obliques inverses suivies d'une citation codent n barres obliques inverses suivies d'un caractère de citation.

Exemples

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

julia> println(raw"\"")
"

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

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

@b_str

Créez un vecteur d'octets immuable (UInt8) en utilisant la syntaxe de chaîne.

Exemples

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

julia> v[2]
0x32

@html_str -> Docs.HTML

Créez un objet HTML à partir d'une chaîne littérale.

Exemples

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

@text_str -> Docs.Text

Créez un objet Text à partir d'une chaîne littérale.

Exemples

julia> text"Julia"
Julia

isvalid(value) -> Bool

Retourne true si la valeur donnée est valide pour son type, qui peut actuellement être soit AbstractChar, soit String, soit SubString{String}.

Exemples

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

Retourne true si la valeur donnée est valide pour ce type. Les types peuvent actuellement être soit AbstractChar soit String. Les valeurs pour AbstractChar peuvent être de type AbstractChar ou UInt32. Les valeurs pour String peuvent être de ce type, SubString{String}, Vector{UInt8}, ou un sous-tableau contigu de celui-ci.

Exemples

julia> isvalid(Char, 0xd800)
false

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

julia> isvalid(Char, 0xd799)
true

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

Prédicat indiquant si l'index donné est le début de l'encodage d'un caractère dans s ou non. Si isvalid(s, i) est vrai, alors s[i] renverra le caractère dont l'encodage commence à cet index, si c'est faux, alors s[i] lèvera une erreur d'index invalide ou une erreur de limites selon que i est dans les limites. Pour que isvalid(s, i) soit une fonction O(1), l'encodage de s doit être auto-synchronisant. C'est une hypothèse de base du support des chaînes génériques de Julia.

Voir aussi getindex, iterate, thisind, nextind, prevind, length.

Exemples

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (catégorie Ll: Lettre, minuscule)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: index invalide [2], indices valides à proximité [1]=>'α', [3]=>'β'
Stacktrace:
[...]

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

Recherchez la première correspondance de l'expression régulière r dans s et renvoyez un objet RegexMatch contenant la correspondance, ou rien si la correspondance a échoué. La sous-chaîne correspondante peut être récupérée en accédant à m.match et les séquences capturées peuvent être récupérées en accédant à m.captures. L'argument optionnel idx spécifie un index à partir duquel commencer la recherche.

Exemples

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)

Recherche de toutes les correspondances de l'expression régulière r dans s et retourne un itérateur sur les correspondances. Si overlap est true, les séquences correspondantes peuvent se chevaucher dans les indices de la chaîne d'origine, sinon elles doivent provenir de plages de caractères distinctes.

Exemples

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

Un type représentant une seule correspondance à un Regex trouvée dans une chaîne. Typiquement créé à partir de la fonction match.

Le champ match stocke la sous-chaîne de la chaîne entière correspondante. Le champ captures stocke les sous-chaînes pour chaque groupe de capture, indexées par numéro. Pour indexer par nom de groupe de capture, l'objet de correspondance entier doit être indexé à la place, comme montré dans les exemples. La localisation du début de la correspondance est stockée dans le champ offset. Le champ offsets stocke les emplacements du début de chaque groupe de capture, avec 0 désignant un groupe qui n'a pas été capturé.

Ce type peut être utilisé comme un itérateur sur les groupes de capture du Regex, produisant les sous-chaînes capturées dans chaque groupe. En raison de cela, les captures d'une correspondance peuvent être déstructurées. Si un groupe n'a pas été capturé, nothing sera produit à la place d'une sous-chaîne.

Des méthodes qui acceptent un objet RegexMatch sont définies pour iterate, length, eltype, keys, haskey, et getindex, où les clés sont les noms ou numéros d'un groupe de capture. Voir keys pour plus d'informations.

Exemples

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; # déstructurer les groupes de capture par itération

julia> hr
"11"

keys(m::RegexMatch) -> Vector

Renvoie un vecteur de clés pour tous les groupes de capture de l'expression régulière sous-jacente. Une clé est incluse même si le groupe de capture ne correspond pas. C'est-à-dire que idx sera dans la valeur de retour même si m[idx] == nothing.

Les groupes de capture non nommés auront des clés entières correspondant à leur index. Les groupes de capture nommés auront des clés de chaîne.

Exemples

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

Testez si la chaîne a vient avant la chaîne b dans l'ordre alphabétique (techniquement, dans l'ordre lexicographique par les points de code Unicode).

Exemples

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

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

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

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

Testez si deux chaînes de caractères sont égales caractère par caractère (techniquement, point de code Unicode par point de code). Si l'une des chaînes est un AnnotatedString, les propriétés de la chaîne doivent également correspondre.

Exemples

julia> "abc" == "abc"
true

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

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

Comparer deux chaînes. Retourner 0 si les deux chaînes ont la même longueur et que le caractère à chaque index est le même dans les deux chaînes. Retourner -1 si a est un préfixe de b, ou si a vient avant b dans l'ordre alphabétique. Retourner 1 si b est un préfixe de a, ou si b vient avant a dans l'ordre alphabétique (techniquement, l'ordre lexicographique par points de code Unicode).

Exemples

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

Convertir s en chaîne et ajouter des caractères p à gauche de la chaîne résultante pour qu'elle fasse n caractères de long (dans textwidth). Si s fait déjà n caractères de long, une chaîne égale est renvoyée. Par défaut, le remplissage se fait avec des espaces.

Exemples

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

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

Transformez s en chaîne et complétez la chaîne résultante à droite avec p pour qu'elle fasse n caractères (dans textwidth) de long. Si s fait déjà n caractères de long, une chaîne égale est renvoyée. Complétez par des espaces par défaut.

Exemples

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

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

Trouve la première occurrence de pattern dans string. Équivalent à findnext(pattern, string, firstindex(s)).

Exemples

julia> findfirst("z", "Hello to the world") # ne retourne rien, mais n'est pas affiché dans le REPL

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

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

Trouver la prochaine occurrence de pattern dans string en commençant à la position start. pattern peut être soit une chaîne de caractères, soit une expression régulière, auquel cas string doit être de type String.

La valeur de retour est une plage d'indices où la séquence correspondante est trouvée, de sorte que s[findnext(x, s, i)] == x :

findnext("substring", string, i) == start:stop tel que string[start:stop] == "substring" et i <= start, ou nothing si aucune correspondance n'est trouvée.

Exemples

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)

Trouver la prochaine occurrence du caractère ch dans string en commençant à la position start.

Exemples

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

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

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

Trouver la dernière occurrence de pattern dans string. Équivalent à findprev(pattern, string, lastindex(string)).

Exemples

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

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

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

Trouver la dernière occurrence du caractère ch dans string.

Exemples

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

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

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

Trouver la précédente occurrence de pattern dans string en commençant à la position start.

La valeur de retour est une plage d'indices où la séquence correspondante est trouvée, de sorte que s[findprev(x, s, i)] == x :

findprev("substring", string, i) == start:stop tel que string[start:stop] == "substring" et stop <= i, ou nothing si aucune correspondance n'est trouvée.

Exemples

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)

Détermine si le premier argument est une sous-chaîne du second. Si needle est une expression régulière, vérifie si haystack contient une correspondance.

Exemples

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

Voir aussi contains.

occursin(haystack)

Créez une fonction qui vérifie si son argument se trouve dans haystack, c'est-à-dire une fonction équivalente à needle -> occursin(needle, haystack).

La fonction retournée est de type Base.Fix2{typeof(occursin)}.

Exemples

julia> search_f = occursin("JuliaLang est un langage de programmation");

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

Inverse une chaîne de caractères. Techniquement, cette fonction inverse les points de code dans une chaîne et son utilité principale est pour le traitement de chaînes en ordre inversé, en particulier pour les recherches d'expressions régulières inversées. Voir aussi reverseind pour convertir les indices dans s en indices dans reverse(s) et vice-versa, et graphemes du module Unicode pour opérer sur les "caractères" visibles par l'utilisateur (graphemes) plutôt que sur les points de code. Voir aussi Iterators.reverse pour une itération en ordre inversé sans faire de copie. Les types de chaînes personnalisés doivent implémenter eux-mêmes la fonction reverse et doivent généralement retourner une chaîne du même type et encodage. S'ils retournent une chaîne avec un encodage différent, ils doivent également remplacer reverseind pour ce type de chaîne afin de satisfaire s[reverseind(s,i)] == reverse(s)[i].

Exemples

julia> reverse("JuliaLang")
"gnaLailuJ"

Les caractères combinés peuvent conduire à des résultats surprenants :

julia> reverse("ax̂e") # le chapeau est au-dessus de x dans l'entrée, au-dessus de e dans la sortie
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # inverse les graphemes ; le chapeau est au-dessus de x dans l'entrée et la sortie
"ex̂a"

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

Recherchez le motif donné pat dans s, et remplacez chaque occurrence par r. Si count est fourni, remplacez au maximum count occurrences. pat peut être un seul caractère, un vecteur ou un ensemble de caractères, une chaîne de caractères, ou une expression régulière. Si r est une fonction, chaque occurrence est remplacée par r(s) où s est la sous-chaîne correspondante (lorsque pat est un AbstractPattern ou AbstractString) ou un caractère (lorsque pat est un AbstractChar ou une collection de AbstractChar). Si pat est une expression régulière et r est une SubstitutionString, alors les références de groupe de capture dans r sont remplacées par le texte correspondant. Pour supprimer les instances de pat de string, définissez r sur la chaîne vide ("").

La valeur de retour est une nouvelle chaîne après les remplacements. Si l'argument io::IO est fourni, la chaîne transformée est plutôt écrite dans io (retournant io). (Par exemple, cela peut être utilisé en conjonction avec un IOBuffer pour réutiliser un tableau de tampon pré-alloué sur place.)

Plusieurs motifs peuvent être spécifiés, et ils seront appliqués de gauche à droite simultanément, donc un seul motif sera appliqué à un caractère, et les motifs ne seront appliqués qu'au texte d'entrée, pas aux remplacements.

Exemples

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)

Divise str sur les occurrences du ou des délimiteurs dlm et renvoie un itérateur sur les sous-chaînes. dlm peut être n'importe quel des formats autorisés par le premier argument de findnext (c'est-à-dire sous forme de chaîne, d'expression régulière ou de fonction), ou comme un seul caractère ou une collection de caractères.

Si dlm est omis, il par défaut à isspace.

Les arguments optionnels sont :

• limit : la taille maximale du résultat. limit=0 implique pas de maximum (par défaut)
• keepempty : si les champs vides doivent être conservés dans le résultat. Par défaut, c'est false sans argument dlm, true avec un argument dlm.

Voir aussi split.

Exemples

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)

Renvoie un itérateur sur les SubStrings de str, produits lors de la séparation sur le(s) délimiteur(s) dlm, et fournis dans l'ordre inverse (de droite à gauche). dlm peut être n'importe quel des formats autorisés par le premier argument de findprev (c'est-à-dire une chaîne, un seul caractère ou une fonction), ou une collection de caractères.

Si dlm est omis, il par défaut à isspace, et keepempty par défaut à false.

Les arguments de mot-clé optionnels sont :

• Si limit > 0, l'itérateur séparera au maximum limit - 1 fois avant de renvoyer le reste de la chaîne non séparé. limit < 1 implique aucune limite aux séparations (par défaut).
• keepempty : si les champs vides doivent être renvoyés lors de l'itération. La valeur par défaut est false sans argument dlm, true avec un argument dlm.

Notez que contrairement à split, rsplit et eachsplit, cette fonction itère les sous-chaînes de droite à gauche comme elles apparaissent dans l'entrée.

Voir aussi eachsplit, rsplit.

Exemples

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)

Divise str en un tableau de sous-chaînes sur les occurrences du ou des délimiteurs dlm. dlm peut être n'importe quel des formats autorisés par le premier argument de findnext (c'est-à-dire sous forme de chaîne, d'expression régulière ou de fonction), ou comme un seul caractère ou une collection de caractères.

Si dlm est omis, il par défaut à isspace.

Les arguments de mot-clé optionnels sont :

• limit : la taille maximale du résultat. limit=0 implique aucune limite (par défaut)
• keepempty : si les champs vides doivent être conservés dans le résultat. Par défaut, c'est false sans argument dlm, true avec un argument dlm.

Voir aussi rsplit, eachsplit.

Exemples

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)

Semblable à split, mais en commençant par la fin de la chaîne.

Exemples

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

Supprime les caractères en tête et en fin de str, soit ceux spécifiés par chars, soit ceux pour lesquels la fonction pred retourne true.

Le comportement par défaut est de supprimer les espaces et délimiteurs en tête et en fin : voir isspace pour des détails précis.

L'argument optionnel chars spécifie quels caractères supprimer : il peut s'agir d'un seul caractère, d'un vecteur ou d'un ensemble de caractères.

Voir aussi lstrip et rstrip.

Exemples

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

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

Supprime les caractères de tête de str, soit ceux spécifiés par chars, soit ceux pour lesquels la fonction pred retourne true.

Le comportement par défaut est de supprimer les espaces et les délimiteurs de tête : voir isspace pour des détails précis.

L'argument optionnel chars spécifie quels caractères supprimer : il peut s'agir d'un seul caractère, ou d'un vecteur ou d'un ensemble de caractères.

Voir aussi strip et rstrip.

Exemples

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

julia> lstrip(a)
"March"

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

Supprime les caractères de fin de str, soit ceux spécifiés par chars, soit ceux pour lesquels la fonction pred renvoie true.

Le comportement par défaut est de supprimer les espaces et les délimiteurs de fin : voir isspace pour des détails précis.

L'argument optionnel chars spécifie quels caractères supprimer : il peut s'agir d'un seul caractère, ou d'un vecteur ou d'un ensemble de caractères.

Voir aussi strip et lstrip.

Exemples

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

julia> rstrip(a)
"March"

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

Retourne true si s commence par prefix, qui peut être une chaîne de caractères, un caractère, ou un tuple/vecteur/ensemble de caractères. Si prefix est un tuple/vecteur/ensemble de caractères, teste si le premier caractère de s appartient à cet ensemble.

Voir aussi endswith, contains.

Exemples

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

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

Vérifiez si un objet IO commence par un préfixe, qui peut être soit une chaîne, un caractère, ou un tuple/vecteur/ensemble de caractères. Voir aussi peek.

startswith(prefix)

Créez une fonction qui vérifie si son argument commence par prefix, c'est-à-dire une fonction équivalente à y -> startswith(y, prefix).

La fonction retournée est de type Base.Fix2{typeof(startswith)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

Exemples

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

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

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

Retourne true si s commence par le motif regex, prefix.

Voir aussi occursin et endswith.

Exemples

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

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

Retourne true si s se termine par suffix, qui peut être une chaîne, un caractère, ou un tuple/vecteur/ensemble de caractères. Si suffix est un tuple/vecteur/ensemble de caractères, teste si le dernier caractère de s appartient à cet ensemble.

Voir aussi startswith, contains.

Exemples

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

endswith(suffix)

Créez une fonction qui vérifie si son argument se termine par suffix, c'est-à-dire une fonction équivalente à y -> endswith(y, suffix).

La fonction retournée est de type Base.Fix2{typeof(endswith)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

Exemples

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

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

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

Retourne true si s se termine par le motif regex, suffix.

Voir aussi occursin et startswith.

Exemples

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

contains(haystack::AbstractString, needle)

Retourne true si haystack contient needle. C'est la même chose que occursin(needle, haystack), mais est fourni pour la cohérence avec startswith(haystack, needle) et endswith(haystack, needle).

Voir aussi occursin, in, issubset.

Exemples

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)

Créez une fonction qui vérifie si son argument contient needle, c'est-à-dire une fonction équivalente à haystack -> contains(haystack, needle).

La fonction retournée est de type Base.Fix2{typeof(contains)}, qui peut être utilisée pour implémenter des méthodes spécialisées.

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

Obtenez une chaîne composée des premiers n caractères de s.

Exemples

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

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

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

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

Obtenez une chaîne composée des derniers n caractères de s.

Exemples

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

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

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

uppercase(c::AbstractChar)

Convertir c en majuscule.

Voir aussi lowercase, titlecase.

Exemples

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (catégorie Lu: Lettre, majuscule)

julia> uppercase('ê')
'Ê': Unicode U+00CA (catégorie Lu: Lettre, majuscule)

uppercase(s::AbstractString)

Renvoie s avec tous les caractères convertis en majuscules.

Voir aussi lowercase, titlecase, uppercasefirst.

Exemples

julia> uppercase("Julia")
"JULIA"

lowercase(c::AbstractChar)

Convertir c en minuscule.

Voir aussi uppercase, titlecase.

Exemples

julia> lowercase('A')
'a': ASCII/Unicode U+0061 (catégorie Ll: Lettre, minuscule)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (catégorie Ll: Lettre, minuscule)

lowercase(s::AbstractString)

Renvoie s avec tous les caractères convertis en minuscules.

Voir aussi uppercase, titlecase, lowercasefirst.

Exemples

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

titlecase(c::AbstractChar)

Convertir c en casse de titre. Cela peut différer de la casse supérieure pour les digraphes, comparez l'exemple ci-dessous.

Voir aussi uppercase, lowercase.

Exemples

julia> titlecase('a')
'A': ASCII/Unicode U+0041 (catégorie Lu: Lettre, majuscule)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (catégorie Lt: Lettre, casse de titre)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (catégorie Lu: Lettre, majuscule)

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

Mettez en majuscule le premier caractère de chaque mot dans s ; si strict est vrai, chaque autre caractère est converti en minuscule, sinon ils restent inchangés. Par défaut, tous les caractères non alphabétiques commençant un nouveau graphe sont considérés comme des séparateurs de mots ; un prédicat peut être passé en tant que mot-clé wordsep pour déterminer quels caractères doivent être considérés comme des séparateurs de mots. Voir aussi uppercasefirst pour mettre en majuscule uniquement le premier caractère de s.

Voir aussi uppercase, lowercase, uppercasefirst.

Exemples

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

Retourne s avec le premier caractère converti en majuscule (techniquement "case de titre" pour Unicode). Voir aussi titlecase pour mettre en majuscule le premier caractère de chaque mot dans s.

Voir aussi lowercasefirst, uppercase, lowercase, titlecase.

Exemples

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

Renvoie s avec le premier caractère converti en minuscule.

Voir aussi uppercasefirst, uppercase, lowercase, titlecase.

Exemples

julia> lowercasefirst("Julia")
"julia"

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

Joindre tout iterator en une seule chaîne, en insérant le délimiteur donné (le cas échéant) entre les éléments adjacents. Si last est donné, il sera utilisé à la place de delim entre les deux derniers éléments. Chaque élément de iterator est converti en chaîne via print(io::IOBuffer, x). Si io est donné, le résultat est écrit dans io plutôt que retourné en tant que String.

Exemples

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)

Supprime les premiers head et les derniers tail caractères de s. L'appel chop(s) supprime le dernier caractère de s. S'il est demandé de supprimer plus de caractères que length(s), alors une chaîne vide est renvoyée.

Voir aussi chomp, startswith, first.

Exemples

julia> a = "Mars"
"Mars"

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

Supprime le préfixe prefix de s. Si s ne commence pas par prefix, une chaîne égale à s est renvoyée.

Voir aussi chopsuffix.

Exemples

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

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

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

Supprime le suffixe suffix de s. Si s ne se termine pas par suffix, une chaîne égale à s est renvoyée.

Voir aussi chopprefix.

Exemples

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

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

chomp(s::AbstractString) -> SubString

Supprime une seule nouvelle ligne à la fin d'une chaîne.

Voir aussi chop.

Exemples

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

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

Si i est dans les limites de s, retourne l'index du début du caractère dont l'unité de code d'encodage i fait partie. En d'autres termes, si i est le début d'un caractère, retourne i ; si i n'est pas le début d'un caractère, rembobine jusqu'au début d'un caractère et retourne cet index. Si i est égal à 0 ou ncodeunits(s)+1, retourne i. Dans tous les autres cas, lance BoundsError.

Exemples

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

• Cas n == 1

  Si i est dans les limites de s, retourne l'index du début du caractère dont l'encodage commence après l'index i. En d'autres termes, si i est le début d'un caractère, retourne le début du caractère suivant ; si i n'est pas le début d'un caractère, avance jusqu'au début d'un caractère et retourne cet index. Si i est égal à 0, retourne 1. Si i est dans les limites mais supérieur ou égal à lastindex(str), retourne ncodeunits(str)+1. Sinon, lance BoundsError.

• Cas n > 1

  Comporte comme l'application de n fois nextind pour n==1. La seule différence est que si n est si grand que l'application de nextind atteindrait ncodeunits(str)+1, alors chaque itération restante augmente la valeur retournée de 1. Cela signifie que dans ce cas, nextind peut retourner une valeur supérieure à ncodeunits(str)+1.

• Cas n == 0

  Retourne i uniquement si i est un index valide dans s ou est égal à 0. Sinon, StringIndexError ou BoundsError est lancé.

Exemples

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

• Cas n == 1

  Si i est dans les limites de s, retourne l'index du début du caractère dont l'encodage commence avant l'index i. En d'autres termes, si i est le début d'un caractère, retourne le début du caractère précédent ; si i n'est pas le début d'un caractère, rembobine jusqu'au début d'un caractère et retourne cet index. Si i est égal à 1, retourne 0. Si i est égal à ncodeunits(str)+1, retourne lastindex(str). Sinon, lance BoundsError.

• Cas n > 1

  Comporte comme l'application de n fois prevind pour n==1. La seule différence est que si n est si grand que l'application de prevind atteindrait 0, alors chaque itération restante diminue la valeur retournée de 1. Cela signifie que dans ce cas, prevind peut retourner une valeur négative.

• Cas n == 0

  Retourne i uniquement si i est un index valide dans str ou est égal à ncodeunits(str)+1. Sinon, StringIndexError ou BoundsError est lancé.

Exemples

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)

Donnez le nombre de colonnes nécessaires pour imprimer un caractère.

Exemples

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

Donne le nombre de colonnes nécessaires pour imprimer une chaîne.

Exemples

julia> textwidth("March")
5

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

Testez si un caractère appartient à l'ensemble des caractères ASCII, ou si cela est vrai pour tous les éléments d'une chaîne.

Exemples

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

Par exemple, isascii peut être utilisé comme fonction prédicat pour filter ou replace pour supprimer ou remplacer les caractères non-ASCII, respectivement :

julia> filter(isascii, "abcdeγfgh") # supprimer les caractères non-ASCII
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # remplacer les caractères non-ASCII par des espaces
"abcde fgh"

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

Testez si toutes les valeurs du vecteur appartiennent à l'ensemble de caractères ASCII (0x00 à 0x7f). Cette fonction est destinée à être utilisée par d'autres implémentations de chaînes qui ont besoin d'une vérification ASCII rapide.

iscntrl(c::AbstractChar) -> Bool

Teste si un caractère est un caractère de contrôle. Les caractères de contrôle sont les caractères non imprimables du sous-ensemble Latin-1 de l'Unicode.

Exemples

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

Teste si un caractère est un chiffre décimal (0-9).

Voir aussi : isletter.

Exemples

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

Testez si un caractère est une lettre. Un caractère est classé comme une lettre s'il appartient à la catégorie générale Unicode Lettre, c'est-à-dire un caractère dont le code de catégorie commence par 'L'.

Voir aussi : isdigit.

Exemples

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

Teste si un caractère est une lettre minuscule (selon la propriété dérivée Lowercase de la norme Unicode).

Voir aussi isuppercase.

Exemples

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

Teste si un caractère est numérique. Un caractère est classé comme numérique s'il appartient à la catégorie générale Unicode Nombre, c'est-à-dire un caractère dont le code de catégorie commence par 'N'.

Notez que cette large catégorie inclut des caractères tels que ¾ et ௰. Utilisez isdigit pour vérifier si un caractère est un chiffre décimal entre 0 et 9.

Exemples

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

Teste si un caractère est imprimable, y compris les espaces, mais pas un caractère de contrôle.

Exemples

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

Teste si un caractère appartient à la catégorie générale Unicode Punctuation, c'est-à-dire un caractère dont le code de catégorie commence par 'P'.

Exemples

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

Teste si un caractère est un caractère d'espacement. Inclut les caractères ASCII '\t', '\n', '\v', '\f', '\r' et ' ', le caractère Latin-1 U+0085, et les caractères de la catégorie Unicode Zs.

Exemples

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

Teste si un caractère est une lettre majuscule (selon la propriété dérivée Uppercase de la norme Unicode).

Voir aussi islowercase.

Exemples

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

Testez si un caractère est un chiffre hexadécimal valide. Notez que cela n'inclut pas x (comme dans le préfixe standard 0x).

Exemples

julia> isxdigit('a')
true

julia> isxdigit('x')
false

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

Échappement général des séquences d'échappement traditionnelles C et Unicode. La première forme renvoie la chaîne échappée, la seconde imprime le résultat dans io.

Les barres obliques inverses (\) sont échappées avec une double barre oblique inverse ("\\"). Les caractères non imprimables sont échappés soit avec leurs codes d'échappement C standard, "\0" pour NUL (si non ambigu), point de code unicode ("\u" préfixe) ou hexadécimal ("\x" préfixe).

L'argument optionnel esc spécifie tout caractère supplémentaire qui doit également être échappé par un backslash (" est également échappé par défaut dans la première forme).

L'argument keep spécifie une collection de caractères qui doivent être conservés tels quels. Remarquez que esc a la priorité ici.

Voir aussi unescape_string pour l'opération inverse.

Exemples

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

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

julia> escape_string("\xfe\xff") # utf-8 invalide
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # non ambigu
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 serait ambigu
"ℵ\\x000"

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

Échappe une chaîne de caractères de la manière utilisée pour analyser les littéraux de chaîne bruts. Pour chaque caractère de guillemet double (") dans la chaîne d'entrée s (ou delim si spécifié), cette fonction compte le nombre n de caractères de barre oblique inversée (\) précédents, puis augmente le nombre de barres obliques de n à 2n+1 (même pour n = 0). Elle double également une séquence de barres obliques à la fin de la chaîne.

Cette convention d'échappement est utilisée dans les chaînes brutes et d'autres littéraux de chaîne non standard. (Il se trouve également que c'est la convention d'échappement attendue par le runtime du compilateur Microsoft C/C++ lorsqu'il analyse une chaîne de ligne de commande dans le tableau argv[]).

Voir aussi escape_string.

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

Déséchappement général des séquences d'échappement traditionnelles C et Unicode. La première forme renvoie la chaîne déséchappée, la seconde imprime le résultat dans io. L'argument keep spécifie une collection de caractères qui (avec les barres obliques inverses) doivent être conservés tels quels.

Les séquences d'échappement suivantes sont reconnues :

• Barre oblique inverse échappée (\\)
• Guillemets doubles échappés (\")
• Séquences d'échappement C standard (\a, \b, \t, \n, \v, \f, \r, \e)
• Points de code Unicode BMP (\u avec 1-4 chiffres hexadécimaux à la fin)
• Tous les points de code Unicode (\U avec 1-8 chiffres hexadécimaux à la fin ; valeur max = 0010ffff)
• Octets hexadécimaux (\x avec 1-2 chiffres hexadécimaux à la fin)
• Octets octaux (\ avec 1-3 chiffres octaux à la fin)

Voir aussi escape_string.

Exemples

julia> unescape_string("aaa\\nbbb") # séquence d'échappement C
"aaa\nbbb"

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

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

julia> unescape_string("aaa \\g \\n", ['g']) # utilisation de l'argument `keep`
"aaa \\g \n"

AnnotatedString{S <: AbstractString} <: AbstractString

Une chaîne avec des métadonnées, sous la forme de régions annotées.

Plus précisément, il s'agit d'un simple wrapper autour de toute autre AbstractString qui permet d'annoter des régions de la chaîne enveloppée avec des valeurs étiquetées.

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

Le diagramme ci-dessus représente un AnnotatedString où trois plages ont été annotées (étiquetées A, B et C). Chaque annotation contient une étiquette (Symbol) et une valeur (Any). Ces trois morceaux d'information sont conservés sous la forme d'un @NamedTuple{region::UnitRange{Int64}, label::Symbol, value}.

Les étiquettes n'ont pas besoin d'être uniques, la même région peut contenir plusieurs annotations avec la même étiquette.

Le code écrit pour les AnnotatedStrings en général doit conserver les propriétés suivantes :

• Quels caractères une annotation est appliquée
• L'ordre dans lequel les annotations sont appliquées à chaque caractère

Des sémantiques supplémentaires peuvent être introduites par des utilisations spécifiques des AnnotatedStrings.

Un corollaire de ces règles est que des annotations adjacentes, placées consécutivement, avec des étiquettes et des valeurs identiques sont équivalentes à une seule annotation s'étendant sur la plage combinée.

Voir aussi AnnotatedChar, annotatedstring, annotations, et annotate!.

Constructeurs

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

Un AnnotatedString peut également être créé avec annotatedstring, qui fonctionne beaucoup comme string mais préserve toutes les annotations présentes dans les arguments.

Exemples

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

Un Char avec des annotations.

Plus précisément, il s'agit d'un simple wrapper autour de tout autre AbstractChar, qui contient une liste d'annotations étiquetées arbitraires (@NamedTuple{label::Symbol, value}) avec le caractère encapsulé.

Voir aussi : AnnotatedString, annotatedstring, annotations, et annotate!.

Constructeurs

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

Exemples

julia> AnnotatedChar('j', :label => 1)
'j': ASCII/Unicode U+006A (catégorie Ll: Lettre, minuscule)

annotatedstring(values...)

Crée un AnnotatedString à partir de n'importe quel nombre de values en utilisant leur représentation printée.

Cela fonctionne comme string, mais prend soin de préserver toutes les annotations présentes (sous la forme de valeurs AnnotatedString ou AnnotatedChar).

Voir aussi AnnotatedString et AnnotatedChar.

Exemples

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}}

Obtenez toutes les annotations qui s'appliquent à `str`. Si `position` est fourni, seules les annotations qui se chevauchent avec `position` seront retournées.

Les annotations sont fournies avec les régions auxquelles elles s'appliquent, sous la forme d'un vecteur de tuples région-annotation.

Conformément à la sémantique documentée dans [`AnnotatedString`](@ref), l'ordre des annotations retournées correspond à l'ordre dans lequel elles ont été appliquées.

Voir aussi : [`annotate!`](@ref).

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

Obtenez toutes les annotations de chr, sous la forme d'un vecteur de paires d'annotations.

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

Annoter une plage de str (ou la chaîne entière) avec une valeur étiquetée (label => value). Pour supprimer les annotations label existantes, utilisez une valeur de nothing.

L'ordre dans lequel les annotations sont appliquées à str est sémantiquement significatif, comme décrit dans AnnotatedString.

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

Annoter char avec la paire label => value.