Strings

El tipo AbstractString es el supertipo de todas las implementaciones de cadenas en Julia. Las cadenas son codificaciones de secuencias de puntos de código de Unicode tal como se representan mediante el tipo AbstractChar. Julia hace algunas suposiciones sobre las cadenas:

• Las cadenas están codificadas en términos de "unidades de código" de tamaño fijo.

  • Las unidades de código se pueden extraer con codeunit(s, i)
  • La primera unidad de código tiene índice 1
  • La última unidad de código tiene índice ncodeunits(s)
  • Cualquier índice i tal que 1 ≤ i ≤ ncodeunits(s) está dentro de los límites

• La indexación de cadenas se realiza en términos de estas unidades de código:

  • Los caracteres se extraen mediante s[i] con un índice de cadena válido i
  • Cada AbstractChar en una cadena está codificado por una o más unidades de código
  • Solo el índice de la primera unidad de código de un AbstractChar es un índice válido
  • La codificación de un AbstractChar es independiente de lo que lo precede o lo sigue
  • Las codificaciones de cadenas son auto-sincronizadoras – es decir, isvalid(s, i) es O(1)

Algunas funciones de cadena que extraen unidades de código, caracteres o subcadenas de cadenas generan un error si les pasas índices de cadena fuera de los límites o inválidos. Esto incluye codeunit(s, i) y s[i]. Las funciones que realizan aritmética de índices de cadena adoptan un enfoque más relajado para la indexación y te dan el índice de cadena válido más cercano cuando está dentro de los límites, o cuando está fuera de los límites, se comportan como si hubiera un número infinito de caracteres que rellenan cada lado de la cadena. Por lo general, estos caracteres de relleno imaginarios tienen una longitud de unidad de código de 1, pero los tipos de cadena pueden elegir diferentes tamaños de "caracteres" "imaginarios" según lo que tenga sentido para sus implementaciones (por ejemplo, las subcadenas pueden pasar la aritmética de índices a la cadena subyacente a la que proporcionan una vista). Las funciones de indexación relajada incluyen aquellas destinadas a la aritmética de índices: thisind, nextind y prevind. Este modelo permite que la aritmética de índices funcione con índices fuera de los límites como valores intermedios siempre que nunca se usen para recuperar un carácter, lo que a menudo ayuda a evitar la necesidad de codificar alrededor de casos límite.

Consulta también codeunit, ncodeunits, thisind, nextind, prevind.

El tipo AbstractChar es el supertipo de todas las implementaciones de caracteres en Julia. Un carácter representa un punto de código Unicode y se puede convertir a un entero a través de la función codepoint para obtener el valor numérico del punto de código, o se puede construir a partir del mismo entero. Estos valores numéricos determinan cómo se comparan los caracteres con < y ==, por ejemplo. Nuevos tipos T <: AbstractChar deben definir un método codepoint(::T) y un constructor T(::UInt32), como mínimo.

Un subtipo dado de AbstractChar puede ser capaz de representar solo un subconjunto de Unicode, en cuyo caso la conversión de un valor UInt32 no soportado puede lanzar un error. Por el contrario, el tipo incorporado Char representa un superconjunto de Unicode (para codificar sin pérdida flujos de bytes inválidos), en cuyo caso la conversión de un valor no Unicode a UInt32 lanza un error. La función isvalid se puede usar para verificar qué puntos de código son representables en un tipo AbstractChar dado.

Internamente, un tipo AbstractChar puede usar una variedad de codificaciones. La conversión a través de codepoint(char) no revelará esta codificación porque siempre devuelve el valor Unicode del carácter. print(io, c) de cualquier c::AbstractChar produce una codificación determinada por io (UTF-8 para todos los tipos de IO incorporados), a través de la conversión a Char si es necesario.

write(io, c), en contraste, puede emitir una codificación dependiendo de typeof(c), y read(io, typeof(c)) debería leer la misma codificación que write. Nuevos tipos AbstractChar deben proporcionar sus propias implementaciones de write y read.

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

Char es un tipo de 32 bits AbstractChar que es la representación predeterminada de caracteres en Julia. Char es el tipo utilizado para literales de caracteres como 'x' y también es el tipo de elemento de String.

Para representar de manera sin pérdida flujos de bytes arbitrarios almacenados en un String, un valor Char puede almacenar información que no se puede convertir a un punto de código Unicode; convertir tal Char a UInt32 generará un error. La función isvalid(c::Char) se puede utilizar para consultar si c representa un carácter Unicode válido.

codepoint(c::AbstractChar) -> Integer

Devuelve el punto de código Unicode (un entero sin signo) correspondiente al carácter c (o lanza una excepción si c no representa un carácter válido). Para Char, este es un valor UInt32, pero los tipos AbstractChar que representan solo un subconjunto de Unicode pueden devolver un entero de diferente tamaño (por ejemplo, UInt8).

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

Devuelve el número de caracteres en la cadena s desde los índices i hasta j.

Esto se calcula como el número de índices de unidades de código desde i hasta j que son índices de caracteres válidos. Con solo un argumento de cadena, esto calcula el número de caracteres en toda la cadena. Con los argumentos i y j, calcula el número de índices entre i y j inclusive que son índices válidos en la cadena s. Además de los valores dentro de los límites, i puede tomar el valor fuera de los límites ncodeunits(s) + 1 y j puede tomar el valor fuera de los límites 0.

Véase también isvalid, ncodeunits, lastindex, thisind, nextind, prevind.

Ejemplos

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

sizeof(str::AbstractString)

Tamaño, en bytes, de la cadena str. Igual al número de unidades de código en str multiplicado por el tamaño, en bytes, de una unidad de código en str.

Ejemplos

julia> sizeof("")
0

julia> sizeof("∀")
3

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

Concatena cadenas y/o caracteres, produciendo un String o AnnotatedString (según corresponda). Esto es equivalente a llamar a la función string o annotatedstring sobre los argumentos. La concatenación de tipos de cadena incorporados siempre produce un valor de tipo String, pero otros tipos de cadena pueden optar por devolver una cadena de un tipo diferente según corresponda.

Ejemplos

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

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

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

Repite una cadena o carácter n veces. Esto también se puede escribir como repeat(s, n).

Véase también repeat.

Ejemplos

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

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

Convierte un entero n a una cadena en la base dada, especificando opcionalmente un número de dígitos para rellenar.

Véase también digits, bitstring, count_zeros.

Ejemplos

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

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

string(xs...)

Crea una cadena a partir de cualquier valor utilizando la función print.

string no debería definirse directamente. En su lugar, define un método print(io::IO, x::MyType). Si string(x) para un cierto tipo necesita ser altamente eficiente, entonces puede tener sentido agregar un método a string y definir print(io::IO, x::MyType) = print(io, string(x)) para asegurar que las funciones sean consistentes.

Ver también: String, repr, sprint, show.

Ejemplos

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

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

Repite una cadena r veces. Esto se puede escribir como s^r.

Véase también ^.

Ejemplos

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

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

Repite un carácter r veces. Esto se puede lograr de manera equivalente llamando a c^r.

Ejemplos

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

repr(x; context=nothing)

Crea una cadena a partir de cualquier valor utilizando la función show. No debes agregar métodos a repr; en su lugar, define un método show.

El argumento de palabra clave opcional context se puede establecer en un par :key=>value, una tupla de pares :key=>value, o un objeto IO o IOContext cuyos atributos se utilizan para el flujo de I/O pasado a show.

Ten en cuenta que repr(x) suele ser similar a cómo se ingresaría el valor de x en Julia. También consulta repr(MIME("text/plain"), x) para devolver en su lugar una versión "bien presentada" de x diseñada más para el consumo humano, equivalente a la visualización de x en el REPL.

Ejemplos

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)

Crea un nuevo String a partir de un AbstractString existente.

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

Como getindex, pero devuelve una vista de la cadena principal s dentro del rango i:j o r respectivamente en lugar de hacer una copia.

El macro @views convierte cualquier rebanada de cadena s[i:j] en subcadenas SubString(s, i, j) en un bloque de código.

Ejemplos

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

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

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

LazyString <: AbstractString

Una representación perezosa de la interpolación de cadenas. Esto es útil cuando se necesita construir una cadena en un contexto donde realizar la interpolación real y la construcción de la cadena es innecesario o indeseable (por ejemplo, en rutas de error de funciones).

Este tipo está diseñado para ser barato de construir en tiempo de ejecución, tratando de descargar tanto trabajo como sea posible a la macro o a las operaciones de impresión posteriores.

Ejemplos

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

Ver también @lazy_str.

Ayuda extendida

Propiedades de seguridad para programas concurrentes

Una cadena perezosa en sí misma no introduce ningún problema de concurrencia, incluso si se imprime en múltiples tareas de Julia. Sin embargo, si los métodos print sobre un valor capturado pueden tener un problema de concurrencia cuando se invocan sin sincronizaciones, imprimir la cadena perezosa puede causar un problema. Además, los métodos print sobre los valores capturados pueden ser invocados múltiples veces, aunque solo se devolverá exactamente un resultado.

lazy"str"

Crea un LazyString utilizando la sintaxis de interpolación de cadenas regular. Ten en cuenta que las interpolaciones son evaluadas en el momento de la construcción de LazyString, pero la impresión se retrasa hasta el primer acceso a la cadena.

Consulta la documentación de LazyString para conocer las propiedades de seguridad para programas concurrentes.

Ejemplos

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

julia> typeof(str)
LazyString

transcode(T, src)

Convierte datos de cadena entre codificaciones Unicode. src es un String o un Vector{UIntXX} de unidades de código UTF-XX, donde XX es 8, 16 o 32. T indica la codificación del valor de retorno: String para devolver un String (codificado en UTF-8) o UIntXX para devolver un Vector{UIntXX} de datos UTF-XX. (El alias Cwchar_t también se puede usar como el tipo entero, para convertir cadenas wchar_t* utilizadas por bibliotecas externas de C.)

La función transcode tiene éxito siempre que los datos de entrada se puedan representar razonablemente en la codificación de destino; siempre tiene éxito para conversiones entre codificaciones UTF-XX, incluso para datos Unicode no válidos.

Actualmente, solo se admite la conversión de/a UTF-8.

Ejemplos

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

Copia una cadena desde la dirección de una cadena al estilo C (terminada en NUL) codificada como UTF-8. (El puntero se puede liberar de forma segura después). Si se especifica length (la longitud de los datos en bytes), la cadena no tiene que estar terminada en NUL.

Esta función está etiquetada como "insegura" porque se bloqueará si p no es una dirección de memoria válida para los datos de la longitud solicitada.

ncodeunits(s::AbstractString) -> Int

Devuelve el número de unidades de código en una cadena. Los índices que están dentro de los límites para acceder a esta cadena deben satisfacer 1 ≤ i ≤ ncodeunits(s). No todos esos índices son válidos: pueden no ser el inicio de un carácter, pero devolverán un valor de unidad de código al llamar a codeunit(s,i).

Ejemplos

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

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

Ver también codeunit, checkbounds, sizeof, length, lastindex.

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

Devuelve el tipo de unidad de código del objeto de cadena dado. Para cadenas codificadas en ASCII, Latin-1 o UTF-8, esto sería UInt8; para UCS-2 y UTF-16 sería UInt16; para UTF-32 sería UInt32. El tipo de unidad de código no tiene que limitarse a estos tres tipos, pero es difícil pensar en codificaciones de cadena de uso general que no utilicen una de estas unidades. codeunit(s) es lo mismo que typeof(codeunit(s,1)) cuando s es una cadena no vacía.

Ver también ncodeunits.

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

Devuelve el valor de la unidad de código en la cadena s en el índice i. Nota que

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

Es decir, el valor devuelto por codeunit(s, i) es del tipo devuelto por codeunit(s).

Ejemplos

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

julia> typeof(a)
UInt8

Ver también ncodeunits, checkbounds.

codeunits(s::AbstractString)

Obtiene un objeto similar a un vector que contiene las unidades de código de una cadena. Devuelve un envoltorio CodeUnits por defecto, pero codeunits puede definirse opcionalmente para nuevos tipos de cadena si es necesario.

Ejemplos

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

ascii(s::AbstractString)

Convierte una cadena al tipo String y verifica que contenga solo datos ASCII, de lo contrario lanza un ArgumentError indicando la posición del primer byte no ASCII.

Véase también el predicado isascii para filtrar o reemplazar caracteres no ASCII.

Ejemplos

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

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags]) <: AbstractPattern

Un tipo que representa una expresión regular. Los objetos Regex se pueden usar para hacer coincidir cadenas con match.

Los objetos Regex se pueden crear utilizando el macro de cadena @r_str. El constructor Regex(pattern[, flags]) se utiliza generalmente si la cadena pattern necesita ser interpolada. Consulte la documentación del macro de cadena para obtener detalles sobre las banderas.

@r_str -> Regex

Construya una expresión regular, como r"^[a-z]*$", sin interpolación y sin desescapar (excepto por la comilla " que aún debe ser escapada). La expresión regular también acepta una o más banderas, listadas después de la comilla final, para cambiar su comportamiento:

• i habilita la coincidencia sin distinción entre mayúsculas y minúsculas
• m trata los tokens ^ y $ como coincidiendo con el inicio y el final de líneas individuales, en lugar de toda la cadena.
• s permite que el modificador . coincida con nuevas líneas.
• x habilita el "modo de espacio libre": los espacios en blanco entre los tokens de la expresión regular se ignoran, excepto cuando están escapados con \, y # en la expresión regular se trata como el inicio de un comentario (que se ignora hasta el final de la línea).
• a habilita el modo ASCII (desactiva los modos UTF y UCP). Por defecto, \B, \b, \D, \d, \S, \s, \W, \w, etc. coinciden según las propiedades de los caracteres Unicode. Con esta opción, estas secuencias solo coinciden con caracteres ASCII. Esto incluye \u también, que emitirá el valor de carácter especificado directamente como un solo byte, y no intentará codificarlo en UTF-8. Importante, esta opción permite coincidir con cadenas UTF-8 no válidas, tratando tanto el coincididor como el objetivo como bytes simples (como si fueran bytes ISO/IEC 8859-1 / Latin-1) en lugar de como codificaciones de caracteres. En este caso, esta opción a menudo se combina con s. Esta opción se puede refinar aún más comenzando el patrón con (UCP) o (UTF).

Consulte Regex si se necesita interpolación.

Ejemplos

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

Esta expresión regular tiene habilitadas las tres primeras banderas.

SubstitutionString(substr) <: AbstractString

Almacena la cadena dada substr como un SubstitutionString, para su uso en sustituciones de expresiones regulares. Comúnmente construido utilizando el macro @s_str.

Ejemplos

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

Construye una cadena de sustitución, utilizada para sustituciones de expresiones regulares. Dentro de la cadena, las secuencias de la forma \N se refieren al N-ésimo grupo de captura en la regex, y \g<groupname> se refiere a un grupo de captura nombrado con el nombre groupname.

Ejemplos

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

Crea una cadena sin procesar sin interpolación ni desescapado. La excepción es que las comillas aún deben ser escapadas. Las barras invertidas escapan tanto las comillas como otras barras invertidas, pero solo cuando una secuencia de barras invertidas precede a un carácter de comillas. Así, 2n barras invertidas seguidas de una comilla codifican n barras invertidas y el final del literal, mientras que 2n+1 barras invertidas seguidas de una comilla codifican n barras invertidas seguidas de un carácter de comillas.

Ejemplos

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

julia> println(raw"\"")
"

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

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

@b_str

Crea un vector de bytes inmutable (UInt8) utilizando la sintaxis de cadena.

Ejemplos

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

julia> v[2]
0x32

@html_str -> Docs.HTML

Crea un objeto HTML a partir de una cadena literal.

Ejemplos

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

@text_str -> Docs.Text

Crea un objeto Text a partir de una cadena literal.

Ejemplos

julia> text"Julia"
Julia

isvalid(value) -> Bool

Devuelve true si el valor dado es válido para su tipo, que actualmente puede ser AbstractChar o String o SubString{String}.

Ejemplos

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

Devuelve true si el valor dado es válido para ese tipo. Los tipos actualmente pueden ser AbstractChar o String. Los valores para AbstractChar pueden ser de tipo AbstractChar o UInt32. Los valores para String pueden ser de ese tipo, SubString{String}, Vector{UInt8}, o un subarreglo contiguo de estos.

Ejemplos

julia> isvalid(Char, 0xd800)
false

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

julia> isvalid(Char, 0xd799)
true

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

Predicado que indica si el índice dado es el inicio de la codificación de un carácter en s o no. Si isvalid(s, i) es verdadero, entonces s[i] devolverá el carácter cuya codificación comienza en ese índice; si es falso, entonces s[i] generará un error de índice no válido o un error de límites dependiendo de si i está dentro de los límites. Para que isvalid(s, i) sea una función O(1), la codificación de s debe ser auto-sincronizadora. Esta es una suposición básica del soporte de cadenas genéricas de Julia.

Véase también getindex, iterate, thisind, nextind, prevind, length.

Ejemplos

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (categoría Ll: Letra, minúscula)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: índice no válido [2], índices cercanos válidos [1]=>'α', [3]=>'β'
Stacktrace:
[...]

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

Busca la primera coincidencia de la expresión regular r en s y devuelve un objeto RegexMatch que contiene la coincidencia, o nada si la coincidencia falló. La subcadena coincidente se puede recuperar accediendo a m.match y las secuencias capturadas se pueden recuperar accediendo a m.captures. El argumento opcional idx especifica un índice en el que comenzar la búsqueda.

Ejemplos

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)

Busca todas las coincidencias de la expresión regular r en s y devuelve un iterador sobre las coincidencias. Si overlap es true, las secuencias coincidentes pueden superponerse en los índices de la cadena original, de lo contrario, deben ser de rangos de caracteres distintos.

Ejemplos

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 tipo que representa una coincidencia única a un Regex encontrada en una cadena. Típicamente creado a partir de la función match.

El campo match almacena la subcadena de la cadena completa coincidente. El campo captures almacena las subcadenas para cada grupo de captura, indexadas por número. Para indexar por nombre de grupo de captura, el objeto de coincidencia completo debe ser indexado en su lugar, como se muestra en los ejemplos. La ubicación del inicio de la coincidencia se almacena en el campo offset. El campo offsets almacena las ubicaciones del inicio de cada grupo de captura, con 0 denotando un grupo que no fue capturado.

Este tipo se puede usar como un iterador sobre los grupos de captura del Regex, produciendo las subcadenas capturadas en cada grupo. Debido a esto, las capturas de una coincidencia pueden ser desestructuradas. Si un grupo no fue capturado, se producirá nothing en lugar de una subcadena.

Los métodos que aceptan un objeto RegexMatch están definidos para iterate, length, eltype, keys, haskey, y getindex, donde las claves son los nombres o números de un grupo de captura. Consulte keys para más información.

Ejemplos

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; # desestructurar grupos de captura por iteración

julia> hr
"11"

keys(m::RegexMatch) -> Vector

Devuelve un vector de claves para todos los grupos de captura de la expresión regular subyacente. Una clave se incluye incluso si el grupo de captura no coincide. Es decir, idx estará en el valor de retorno incluso si m[idx] == nothing.

Los grupos de captura sin nombre tendrán claves enteras correspondientes a su índice. Los grupos de captura con nombre tendrán claves de cadena.

Ejemplos

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

Prueba si la cadena a precede a la cadena b en orden alfabético (técnicamente, en orden lexicográfico por puntos de código Unicode).

Ejemplos

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

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

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

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

Prueba si dos cadenas son iguales carácter por carácter (técnicamente, punto de código Unicode por punto de código). Si alguna de las cadenas es un AnnotatedString, las propiedades de la cadena también deben coincidir.

Ejemplos

julia> "abc" == "abc"
true

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

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

Compara dos cadenas. Devuelve 0 si ambas cadenas tienen la misma longitud y el carácter en cada índice es el mismo en ambas cadenas. Devuelve -1 si a es un prefijo de b, o si a precede a b en orden alfabético. Devuelve 1 si b es un prefijo de a, o si b precede a a en orden alfabético (técnicamente, orden lexicográfico por puntos de código Unicode).

Ejemplos

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

Convierte s a una cadena y rellena la cadena resultante a la izquierda con p para que tenga n caracteres (en textwidth) de largo. Si s ya tiene n caracteres de largo, se devuelve una cadena igual. Por defecto, se rellena con espacios.

Ejemplos

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

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

Convierte s a una cadena y rellena la cadena resultante a la derecha con p para que tenga n caracteres (en textwidth). Si s ya tiene n caracteres de longitud, se devuelve una cadena igual. Por defecto, se rellena con espacios.

Ejemplos

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

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

Encuentra la primera ocurrencia de pattern en string. Equivalente a findnext(pattern, string, firstindex(s)).

Ejemplos

julia> findfirst("z", "Hello to the world") # no devuelve nada, pero no se imprime en el REPL

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

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

Encuentra la siguiente ocurrencia de pattern en string comenzando en la posición start. pattern puede ser una cadena o una expresión regular, en cuyo caso string debe ser de tipo String.

El valor de retorno es un rango de índices donde se encuentra la secuencia coincidente, de modo que s[findnext(x, s, i)] == x:

findnext("substring", string, i) == start:stop tal que string[start:stop] == "substring" y i <= start, o nothing si no hay coincidencia.

Ejemplos

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)

Encuentra la siguiente ocurrencia del carácter ch en string comenzando en la posición start.

Ejemplos

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

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

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

Encuentra la última ocurrencia de pattern en string. Equivalente a findprev(pattern, string, lastindex(string)).

Ejemplos

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

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

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

Encuentra la última ocurrencia del carácter ch en string.

Ejemplos

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

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

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

Encuentra la ocurrencia anterior de pattern en string comenzando en la posición start.

El valor de retorno es un rango de índices donde se encuentra la secuencia coincidente, de modo que s[findprev(x, s, i)] == x:

findprev("substring", string, i) == start:stop tal que string[start:stop] == "substring" y stop <= i, o nothing si no hay coincidencia.

Ejemplos

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)

Determina si el primer argumento es una subcadena del segundo. Si needle es una expresión regular, verifica si haystack contiene una coincidencia.

Ejemplos

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

Ver también contains.

occursin(haystack)

Crea una función que verifique si su argumento ocurre en haystack, es decir, una función equivalente a needle -> occursin(needle, haystack).

La función devuelta es de tipo Base.Fix2{typeof(occursin)}.

Ejemplos

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

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

Revierte una cadena. Técnicamente, esta función revierte los puntos de código en una cadena y su principal utilidad es para el procesamiento de cadenas en orden inverso, especialmente para búsquedas de expresiones regulares en orden inverso. Véase también reverseind para convertir índices en s a índices en reverse(s) y viceversa, y graphemes del módulo Unicode para operar en "caracteres" visibles para el usuario (grafemas) en lugar de puntos de código. Véase también Iterators.reverse para iteración en orden inverso sin hacer una copia. Los tipos de cadena personalizados deben implementar la función reverse ellos mismos y típicamente deben devolver una cadena con el mismo tipo y codificación. Si devuelven una cadena con una codificación diferente, también deben anular reverseind para ese tipo de cadena para satisfacer s[reverseind(s,i)] == reverse(s)[i].

Ejemplos

julia> reverse("JuliaLang")
"gnaLailuJ"

Los caracteres combinados pueden llevar a resultados sorprendentes:

julia> reverse("ax̂e") # el sombrero está sobre la x en la entrada, sobre la e en la salida
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # revierte grafemas; el sombrero está sobre la x en ambas entradas y salidas
"ex̂a"

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

Busca el patrón dado pat en s, y reemplaza cada ocurrencia con r. Si se proporciona count, reemplaza como máximo count ocurrencias. pat puede ser un solo carácter, un vector o un conjunto de caracteres, una cadena o una expresión regular. Si r es una función, cada ocurrencia se reemplaza con r(s) donde s es la subcadena coincidente (cuando pat es un AbstractPattern o AbstractString) o carácter (cuando pat es un AbstractChar o una colección de AbstractChar). Si pat es una expresión regular y r es un SubstitutionString, entonces las referencias de grupos de captura en r se reemplazan con el texto coincidente correspondiente. Para eliminar instancias de pat de string, establece r en la cadena vacía ("").

El valor de retorno es una nueva cadena después de los reemplazos. Si se proporciona el argumento io::IO, la cadena transformada se escribe en su lugar en io (devolviendo io). (Por ejemplo, esto se puede usar junto con un IOBuffer para reutilizar un arreglo de búfer preasignado en su lugar).

Se pueden especificar múltiples patrones, y se aplicarán de izquierda a derecha simultáneamente, por lo que solo se aplicará un patrón a cualquier carácter, y los patrones solo se aplicarán al texto de entrada, no a los reemplazos.

Ejemplos

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)

Divide str en las ocurrencias del delimitador(es) dlm y devuelve un iterador sobre las subcadenas. dlm puede ser cualquiera de los formatos permitidos por el primer argumento de findnext (es decir, como una cadena, expresión regular o una función), o como un solo carácter o colección de caracteres.

Si se omite dlm, por defecto se utiliza isspace.

Los argumentos de palabra clave opcionales son:

• limit: el tamaño máximo del resultado. limit=0 implica sin máximo (por defecto)
• keepempty: si los campos vacíos deben ser mantenidos en el resultado. El valor por defecto es false sin un argumento dlm, true con un argumento dlm.

Véase también split.

Ejemplos

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)

Devuelve un iterador sobre SubStrings de str, producidos al dividirse en el(los) delimitador(es) dlm, y entregados en orden inverso (de derecha a izquierda). dlm puede ser cualquiera de los formatos permitidos por el primer argumento de findprev (es decir, una cadena, un solo carácter o una función), o una colección de caracteres.

Si se omite dlm, por defecto se utiliza isspace, y keepempty por defecto es false.

Los argumentos de palabra clave opcionales son:

• Si limit > 0, el iterador dividirá como máximo limit - 1 veces antes de devolver el resto de la cadena sin dividir. limit < 1 implica que no hay límite en las divisiones (por defecto).
• keepempty: si los campos vacíos deben ser devueltos al iterar. El valor por defecto es false sin un argumento dlm, true con un argumento dlm.

Tenga en cuenta que a diferencia de split, rsplit y eachsplit, esta función itera los substrings de derecha a izquierda a medida que ocurren en la entrada.

Véase también eachsplit, rsplit.

Ejemplos

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)

Divide str en un arreglo de subcadenas en las ocurrencias del delimitador(es) dlm. dlm puede ser cualquiera de los formatos permitidos por el primer argumento de findnext (es decir, como una cadena, expresión regular o una función), o como un solo carácter o colección de caracteres.

Si se omite dlm, por defecto se utiliza isspace.

Los argumentos opcionales son:

• limit: el tamaño máximo del resultado. limit=0 implica sin máximo (por defecto)
• keepempty: si los campos vacíos deben ser mantenidos en el resultado. El valor por defecto es false sin un argumento dlm, true con un argumento dlm.

Ver también rsplit, eachsplit.

Ejemplos

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)

Similar a split, pero comenzando desde el final de la cadena.

Ejemplos

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

Elimina los caracteres de inicio y fin de str, ya sea aquellos especificados por chars o aquellos para los cuales la función pred devuelve true.

El comportamiento predeterminado es eliminar los espacios en blanco y delimitadores de inicio y fin: consulta isspace para obtener detalles precisos.

El argumento opcional chars especifica qué caracteres eliminar: puede ser un solo carácter, un vector o un conjunto de caracteres.

Consulta también lstrip y rstrip.

Ejemplos

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

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

Elimina los caracteres iniciales de str, ya sea aquellos especificados por chars o aquellos para los cuales la función pred devuelve true.

El comportamiento predeterminado es eliminar los espacios en blanco y los delimitadores iniciales: consulta isspace para obtener detalles precisos.

El argumento opcional chars especifica qué caracteres eliminar: puede ser un solo carácter, o un vector o conjunto de caracteres.

Consulta también strip y rstrip.

Ejemplos

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

julia> lstrip(a)
"March"

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

Elimina los caracteres finales de str, ya sea aquellos especificados por chars o aquellos para los cuales la función pred devuelve true.

El comportamiento predeterminado es eliminar los espacios en blanco y delimitadores finales: consulta isspace para obtener detalles precisos.

El argumento opcional chars especifica qué caracteres eliminar: puede ser un solo carácter, o un vector o conjunto de caracteres.

Consulta también strip y lstrip.

Ejemplos

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

julia> rstrip(a)
"March"

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

Devuelve true si s comienza con prefix, que puede ser una cadena, un carácter o una tupla/vector/conjunto de caracteres. Si prefix es una tupla/vector/conjunto de caracteres, prueba si el primer carácter de s pertenece a ese conjunto.

Véase también endswith, contains.

Ejemplos

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

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

Verifica si un objeto IO comienza con un prefijo, que puede ser una cadena, un carácter o una tupla/vector/conjunto de caracteres. Ver también peek.

startswith(prefix)

Crea una función que verifica si su argumento comienza con prefix, es decir, una función equivalente a y -> startswith(y, prefix).

La función devuelta es de tipo Base.Fix2{typeof(startswith)}, que se puede usar para implementar métodos especializados.

Ejemplos

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

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

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

Devuelve true si s comienza con el patrón de expresión regular, prefix.

Véase también occursin y endswith.

Ejemplos

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

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

Devuelve true si s termina con suffix, que puede ser una cadena, un carácter o una tupla/vector/conjunto de caracteres. Si suffix es una tupla/vector/conjunto de caracteres, prueba si el último carácter de s pertenece a ese conjunto.

Véase también startswith, contains.

Ejemplos

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

endswith(suffix)

Crea una función que verifica si su argumento termina con suffix, es decir, una función equivalente a y -> endswith(y, suffix).

La función devuelta es de tipo Base.Fix2{typeof(endswith)}, que se puede usar para implementar métodos especializados.

Ejemplos

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

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

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

Devuelve true si s termina con el patrón de expresión regular, suffix.

Véase también occursin y startswith.

Ejemplos

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

contains(haystack::AbstractString, needle)

Devuelve true si haystack contiene needle. Esto es lo mismo que occursin(needle, haystack), pero se proporciona para mantener la consistencia con startswith(haystack, needle) y endswith(haystack, needle).

Véase también occursin, in, issubset.

Ejemplos

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)

Crea una función que verifique si su argumento contiene needle, es decir, una función equivalente a haystack -> contains(haystack, needle).

La función devuelta es de tipo Base.Fix2{typeof(contains)}, que se puede usar para implementar métodos especializados.

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

Obtiene una cadena que consiste en los primeros n caracteres de s.

Ejemplos

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

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

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

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

Obtiene una cadena que consiste en los últimos n caracteres de s.

Ejemplos

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

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

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

uppercase(c::AbstractChar)

Convierte c a mayúsculas.

Véase también lowercase, titlecase.

Ejemplos

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (categoría Lu: Letra, mayúscula)

julia> uppercase('ê')
'Ê': Unicode U+00CA (categoría Lu: Letra, mayúscula)

uppercase(s::AbstractString)

Devuelve s con todos los caracteres convertidos a mayúsculas.

Véase también lowercase, titlecase, uppercasefirst.

Ejemplos

julia> uppercase("Julia")
"JULIA"

lowercase(c::AbstractChar)

Convierte c a minúsculas.

Véase también uppercase, titlecase.

Ejemplos

julia> lowercase('A')
'a': ASCII/Unicode U+0061 (categoría Ll: Letra, minúscula)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (categoría Ll: Letra, minúscula)

lowercase(s::AbstractString)

Devuelve s con todos los caracteres convertidos a minúsculas.

Véase también uppercase, titlecase, lowercasefirst.

Ejemplos

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

titlecase(c::AbstractChar)

Convierte c a mayúsculas de título. Esto puede diferir de las mayúsculas para dígrafos, compara el ejemplo a continuación.

Véase también uppercase, lowercase.

Ejemplos

julia> titlecase('a')
'A': ASCII/Unicode U+0041 (categoría Lu: Letra, mayúscula)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (categoría Lt: Letra, mayúscula de título)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (categoría Lu: Letra, mayúscula)

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

Capitaliza el primer carácter de cada palabra en s; si strict es verdadero, cada otro carácter se convierte en minúscula, de lo contrario se dejan sin cambios. Por defecto, todos los no-letras que comienzan un nuevo grafema se consideran como separadores de palabras; se puede pasar un predicado como el argumento wordsep para determinar qué caracteres deben considerarse como separadores de palabras. Ver también uppercasefirst para capitalizar solo el primer carácter en s.

Ver también uppercase, lowercase, uppercasefirst.

Ejemplos

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

Devuelve s con el primer carácter convertido a mayúsculas (técnicamente "título" para Unicode). Consulta también titlecase para capitalizar el primer carácter de cada palabra en s.

Consulta también lowercasefirst, uppercase, lowercase, titlecase.

Ejemplos

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

Devuelve s con el primer carácter convertido a minúscula.

Véase también uppercasefirst, uppercase, lowercase, titlecase.

Ejemplos

julia> lowercasefirst("Julia")
"julia"

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

Une cualquier iterator en una sola cadena, insertando el delimitador dado (si lo hay) entre los elementos adyacentes. Si se proporciona last, se utilizará en lugar de delim entre los dos últimos elementos. Cada elemento de iterator se convierte en una cadena a través de print(io::IOBuffer, x). Si se proporciona io, el resultado se escribe en io en lugar de devolverse como un String.

Ejemplos

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)

Elimina los primeros head y los últimos tail caracteres de s. La llamada chop(s) elimina el último carácter de s. Si se solicita eliminar más caracteres de los que tiene length(s), se devuelve una cadena vacía.

Véase también chomp, startswith, first.

Ejemplos

julia> a = "March"
"March"

julia> chop(a)
"Marc"

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

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

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

Elimina el prefijo prefix de s. Si s no comienza con prefix, se devuelve una cadena igual a s.

Véase también chopsuffix.

Ejemplos

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

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

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

Elimina el sufijo suffix de s. Si s no termina con suffix, se devuelve una cadena igual a s.

Véase también chopprefix.

Ejemplos

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

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

chomp(s::AbstractString) -> SubString

Elimina un solo salto de línea al final de una cadena.

Ver también chop.

Ejemplos

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

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

Si i está dentro de los límites en s, devuelve el índice del inicio del carácter cuyo código de unidad de codificación i es parte. En otras palabras, si i es el inicio de un carácter, devuelve i; si i no es el inicio de un carácter, retrocede hasta el inicio de un carácter y devuelve ese índice. Si i es igual a 0 o ncodeunits(s)+1, devuelve i. En todos los demás casos, lanza BoundsError.

Ejemplos

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

• Caso n == 1

  Si i está dentro de los límites en s, devuelve el índice del inicio del carácter cuya codificación comienza después del índice i. En otras palabras, si i es el inicio de un carácter, devuelve el inicio del siguiente carácter; si i no es el inicio de un carácter, avanza hasta el inicio de un carácter y devuelve ese índice. Si i es igual a 0, devuelve 1. Si i está dentro de los límites pero es mayor o igual a lastindex(str), devuelve ncodeunits(str)+1. De lo contrario, lanza BoundsError.

• Caso n > 1

  Se comporta como si se aplicara n veces nextind para n==1. La única diferencia es que si n es tan grande que aplicar nextind alcanzaría ncodeunits(str)+1, entonces cada iteración restante aumenta el valor devuelto en 1. Esto significa que en este caso nextind puede devolver un valor mayor que ncodeunits(str)+1.

• Caso n == 0

  Devuelve i solo si i es un índice válido en s o es igual a 0. De lo contrario, se lanza StringIndexError o BoundsError.

Ejemplos

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

• Caso n == 1

  Si i está dentro de los límites en s, devuelve el índice del inicio del carácter cuya codificación comienza antes del índice i. En otras palabras, si i es el inicio de un carácter, devuelve el inicio del carácter anterior; si i no es el inicio de un carácter, retrocede hasta el inicio de un carácter y devuelve ese índice. Si i es igual a 1, devuelve 0. Si i es igual a ncodeunits(str)+1, devuelve lastindex(str). De lo contrario, lanza BoundsError.

• Caso n > 1

  Se comporta como si se aplicara n veces prevind para n==1. La única diferencia es que si n es tan grande que aplicar prevind alcanzaría 0, entonces cada iteración restante disminuye el valor devuelto en 1. Esto significa que en este caso prevind puede devolver un valor negativo.

• Caso n == 0

  Devuelve i solo si i es un índice válido en str o es igual a ncodeunits(str)+1. De lo contrario, se lanza StringIndexError o BoundsError.

Ejemplos

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)

Devuelve el número de columnas necesarias para imprimir un carácter.

Ejemplos

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

Devuelve el número de columnas necesarias para imprimir una cadena.

Ejemplos

julia> textwidth("March")
5

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

Prueba si un carácter pertenece al conjunto de caracteres ASCII, o si esto es cierto para todos los elementos de una cadena.

Ejemplos

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

Por ejemplo, isascii se puede usar como una función predicado para filter o replace para eliminar o reemplazar caracteres no ASCII, respectivamente:

julia> filter(isascii, "abcdeγfgh") # descartar caracteres no ASCII
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # reemplazar caracteres no ASCII con espacios
"abcde fgh"

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

Prueba si todos los valores en el vector pertenecen al conjunto de caracteres ASCII (0x00 a 0x7f). Esta función está destinada a ser utilizada por otras implementaciones de cadenas que necesitan una verificación rápida de ASCII.

iscntrl(c::AbstractChar) -> Bool

Prueba si un carácter es un carácter de control. Los caracteres de control son los caracteres no imprimibles del subconjunto Latin-1 de Unicode.

Ejemplos

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

Prueba si un carácter es un dígito decimal (0-9).

Véase también: isletter.

Ejemplos

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

Prueba si un carácter es una letra. Un carácter se clasifica como letra si pertenece a la categoría general de Unicode Letra, es decir, un carácter cuyo código de categoría comienza con 'L'.

Véase también: isdigit.

Ejemplos

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

Prueba si un carácter es una letra minúscula (de acuerdo con la propiedad derivada Lowercase del estándar Unicode).

Véase también isuppercase.

Ejemplos

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

Prueba si un carácter es numérico. Un carácter se clasifica como numérico si pertenece a la categoría general de Unicode Número, es decir, un carácter cuyo código de categoría comienza con 'N'.

Ten en cuenta que esta amplia categoría incluye caracteres como ¾ y ௰. Usa isdigit para verificar si un carácter es un dígito decimal entre 0 y 9.

Ejemplos

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

Prueba si un carácter es imprimible, incluyendo espacios, pero no un carácter de control.

Ejemplos

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

Prueba si un carácter pertenece a la categoría general de Unicode Puntuación, es decir, un carácter cuyo código de categoría comienza con 'P'.

Ejemplos

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

Prueba si un carácter es cualquier carácter de espacio en blanco. Incluye caracteres ASCII '\t', '\n', '\v', '\f', '\r' y ' ', el carácter Latin-1 U+0085, y caracteres en la categoría Unicode Zs.

Ejemplos

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

Prueba si un carácter es una letra mayúscula (de acuerdo con la propiedad derivada Uppercase del estándar Unicode).

Véase también islowercase.

Ejemplos

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

Prueba si un carácter es un dígito hexadecimal válido. Ten en cuenta que esto no incluye x (como en el prefijo estándar 0x).

Ejemplos

julia> isxdigit('a')
true

julia> isxdigit('x')
false

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

Escapeo general de secuencias de escape tradicionales de C y Unicode. La primera forma devuelve la cadena escapada, la segunda imprime el resultado en io.

Las barras invertidas (\) se escapan con una doble barra invertida ("\\"). Los caracteres no imprimibles se escapan ya sea con sus códigos de escape estándar de C, "\0" para NUL (si es no ambiguo), el punto de código unicode ("\u" prefijo) o hex ("\x" prefijo).

El argumento opcional esc especifica cualquier carácter adicional que también debería ser escapado precediéndolo con una barra invertida (" también se escapa por defecto en la primera forma).

El argumento keep especifica una colección de caracteres que deben mantenerse tal como están. Tenga en cuenta que esc tiene prioridad aquí.

Véase también unescape_string para la operación inversa.

Ejemplos

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

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

julia> escape_string("\xfe\xff") # utf-8 inválido
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # no ambiguo
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 sería ambiguo
"ℵ\\x000"

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

Escapa una cadena de la manera utilizada para analizar literales de cadena en bruto. Para cada carácter de comillas dobles (") en la cadena de entrada s (o delim si se especifica), esta función cuenta el número n de caracteres de barra invertida (\) precedentes, y luego aumenta el número de barras invertidas de n a 2n+1 (incluso para n = 0). También duplica una secuencia de barras invertidas al final de la cadena.

Esta convención de escape se utiliza en cadenas en bruto y otros literales de cadena no estándar. (También resulta ser la convención de escape esperada por el tiempo de ejecución del compilador Microsoft C/C++ cuando analiza una cadena de línea de comandos en el arreglo argv[]).

Ver también escape_string.

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

Desescapado general de secuencias de escape tradicionales de C y Unicode. La primera forma devuelve la cadena desescapada, la segunda imprime el resultado en io. El argumento keep especifica una colección de caracteres que (junto con las barras invertidas) se deben mantener tal como están.

Las siguientes secuencias de escape son reconocidas:

• Barra invertida escapada (\\)
• Comillas dobles escapadas (\")
• Secuencias de escape estándar de C (\a, \b, \t, \n, \v, \f, \r, \e)
• Puntos de código BMP de Unicode (\u con 1-4 dígitos hexadecimales finales)
• Todos los puntos de código de Unicode (\U con 1-8 dígitos hexadecimales finales; valor máximo = 0010ffff)
• Bytes hexadecimales (\x con 1-2 dígitos hexadecimales finales)
• Bytes octales (\ con 1-3 dígitos octales finales)

Ver también escape_string.

Ejemplos

julia> unescape_string("aaa\\nbbb") # secuencia de escape de C
"aaa\nbbb"

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

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

julia> unescape_string("aaa \\g \\n", ['g']) # usando el argumento `keep`
"aaa \\g \n"

AnnotatedString{S <: AbstractString} <: AbstractString

Una cadena con metadatos, en forma de regiones anotadas.

Más específicamente, este es un simple envoltorio alrededor de cualquier otro AbstractString que permite que las regiones de la cadena envuelta sean anotadas con valores etiquetados.

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

El diagrama anterior representa un AnnotatedString donde tres rangos han sido anotados (etiquetados como A, B y C). Cada anotación contiene una etiqueta (Symbol) y un valor (Any). Estas tres piezas de información se mantienen como un @NamedTuple{region::UnitRange{Int64}, label::Symbol, value}.

Las etiquetas no necesitan ser únicas, la misma región puede contener múltiples anotaciones con la misma etiqueta.

El código escrito para AnnotatedStrings en general debe conservar las siguientes propiedades:

• Qué caracteres se aplica una anotación
• El orden en que se aplican las anotaciones a cada carácter

Semánticas adicionales pueden ser introducidas por usos específicos de AnnotatedStrings.

Una consecuencia de estas reglas es que anotaciones adyacentes, colocadas consecutivamente, con etiquetas y valores idénticos son equivalentes a una sola anotación que abarca el rango combinado.

Véase también AnnotatedChar, annotatedstring, annotations, y annotate!.

Constructores

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

Un AnnotatedString también se puede crear con annotatedstring, que actúa de manera similar a string pero preserva cualquier anotación presente en los argumentos.

Ejemplos

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 con anotaciones.

Más específicamente, este es un simple envoltorio alrededor de cualquier otro AbstractChar, que contiene una lista de anotaciones etiquetadas arbitrarias (@NamedTuple{label::Symbol, value}) con el carácter envuelto.

Véase también: AnnotatedString, annotatedstring, annotations, y annotate!.

Constructores

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

Ejemplos

julia> AnnotatedChar('j', :label => 1)
'j': ASCII/Unicode U+006A (categoría Ll: Letra, minúscula)

annotatedstring(values...)

Crea un AnnotatedString a partir de cualquier número de values utilizando su representación print.

Esto actúa como string, pero se encarga de preservar cualquier anotación presente (en forma de valores AnnotatedString o AnnotatedChar).

Véase también AnnotatedString y AnnotatedChar.

Ejemplos

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

Obtén todas las anotaciones que se aplican a `str`. Si se proporciona `position`, solo se devolverán las anotaciones que se superpongan con `position`.

Las anotaciones se proporcionan junto con las regiones a las que se aplican, en forma de un vector de tuplas de región-anotación.

De acuerdo con la semántica documentada en [`AnnotatedString`](@ref), el orden de las anotaciones devueltas coincide con el orden en que se aplicaron.

Ver también: [`annotate!`](@ref).

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

Obtiene todas las anotaciones de chr, en forma de un vector de pares de anotaciones.

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

Anotar un rango de str (o la cadena completa) con un valor etiquetado (label => value). Para eliminar anotaciones de label existentes, utiliza un valor de nothing.

El orden en el que se aplican las anotaciones a str es semánticamente significativo, como se describe en AnnotatedString.

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

Anotar char con el par label => value.