Niveles de registro

Un String en Julia es una secuencia ordenada de caracteres. Como señala el manual: «Por supuesto, el verdadero problema surge cuando uno se pregunta qué es un carácter».

Gran parte de esta complejidad se tratará con más detalle en el concepto Chars, pero en resumen:

• Todos los strings en Julia son Unicode.
• Los strings que además resultan ser ASCII (letras inglesas de la A a la Z en mayúsculas y minúsculas, dígitos y algunos signos de puntuación) son fáciles de manejar.
• Con la mayoría de los demás sistemas de escritura del mundo es posible trabajar, pero requieren más cuidado.

Literales de string

En general, los strings se encierran entre comillas dobles " ". Las comillas simples ' ' solo se usan para Chars.

También es posible usar comillas dobles triples """ """, lo que permite usar " dentro del string sin escaparlo. Más importante aún, la indentación adicional no deseada se elimina de los strings multilínea.

julia> """
       Multiline
       
       """
"Multiline\nString\n"

Escapar caracteres

Como la mayoría de los lenguajes desde C en adelante, Julia usa una barra invertida \ para escapar:

1. Para introducir caracteres no imprimibles, como el salto de línea \n del ejemplo anterior.
2. Para proteger caracteres que de otro modo tendrían un significado especial, como \$ (ver más abajo).

Indexación

En principio, los strings se pueden indexar exactamente igual que los vectores:

julia> s[1], s[5]
('J', 'a')

Esto funciona claramente para un string ASCII como «Julia», pero ignora la mayoría de los idiomas del mundo.

Considera uno de los caracteres de Beowulf, escrito en inglés antiguo hace unos 15 siglos.

«Hrōðgār» claramente tiene 7 caracteres, pero no todos son ASCII.

julia> king = "Hrōðgār"
"Hrōðgār"

julia> length(king)
7

julia> isascii(king)
false

# collect() converts to a Char vector:
julia> collect(king)
7-element Vector{Char}:
 'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase)
 'r': ASCII/Unicode U+0072 (category Ll: Letter, lowercase)
 'ō': Unicode U+014D (category Ll: Letter, lowercase)
 'ð': Unicode U+00F0 (category Ll: Letter, lowercase)
 'g': ASCII/Unicode U+0067 (category Ll: Letter, lowercase)
 'ā': Unicode U+0101 (category Ll: Letter, lowercase)
 'r': ASCII/Unicode U+0072 (category Ll: Letter, lowercase)

Indexar un string como este empieza bien, pero en algún punto se rompe:

julia> king[3]
'ō': Unicode U+014D (category Ll: Letter, lowercase)

julia> king[4]
ERROR: StringIndexError: invalid index [4], valid nearby indices [3]=>'ō', [5]=>'ð'

El problema es que indexar así cuenta bytes, que en los strings no ASCII no tienen una relación 1:1 con los caracteres. Un carácter Unicode/UTF-8 puede necesitar hasta 4 bytes para representarse, y el concepto Chars lo explorará con más detalle.

Construir strings

Concatenación

Muchos lenguajes usan + como operador de concatenación de strings, pero Julia no. Al menos el mensaje de error es útil.

julia> "s1 " + "s2"
ERROR: MethodError: no method matching +(::String, ::String)
The function `+` exists, but no method is defined for this combination of argument types.
String concatenation is performed with * 

julia> "s1 " * "s2"
"s1 s2"

La función string() concatena un número arbitrario de strings.

julia> string("lots ", "of ", "bits")
"lots of bits"

La función join() hace lo mismo y también toma un vector de strings y los concatena con un separador dado (por defecto "").

julia> join(["lots", "of", "bits"], "_")
"lots_of_bits"

Ten en cuenta que los strings son inmutables y que la concatenación implica copiar. Por lo tanto, las concatenaciones repetidas dentro de un bucle son ineficientes, y es mejor reunir los fragmentos en un vector y unirlos todos al final.

Repetición

Sencillo:

julia> repeat("Abc", 5)
"AbcAbcAbcAbcAbc"

Interpolación

Muchos lenguajes tienen una forma de insertar valores calculados dentro de los strings, aunque hay un desacuerdo enorme sobre la mejor sintaxis que usar.

En Julia, los valores interpolados van precedidos por $.

julia> myvar = 42
42

julia> "myvar evaluates to $myvar"
"myvar evaluates to 42"

julia> r = 5.3
5.3

julia> "A circle of radius $r has area $(π * r^2)"
"A circle of radius 5.3 has area 88.24733763933729"

Los paréntesis son obligatorios cuando omitirlos sería ambiguo, pero opcionales para un único identificador seguido de un espacio en blanco.

Para incluir un $ en el string, escápalo como \$.

Ten en cuenta la limitación de que la interpolación no permite actualmente dar formato, como la cantidad de decimales que mostrar.

@sprintf()

Para un control más preciso sobre el armado de strings, Julia copia la función sprintf de C (y de varios lenguajes posteriores: Wikipedia enumera unos 30).

En Julia, esto se implementa como una macro dentro del módulo Printf, de ahí el prefijo @.

julia> using Printf

julia> r = 5.3
5.3

julia> @sprintf("A circle of radius %.1f has area %.2f", r, π * r^2)
"A circle of radius 5.3 has area 88.25"

Funciones de string

Por simplicidad, esta sección se centrará en las funciones que devuelven un nuevo string y dejan sin cambios el string original. Muchas tienen una equivalente, nombrada con el sufijo !, que modifica el string original en su lugar.

Longitud

¿Qué tan largo es un string? A veces depende de cómo lo cuentes.

El caso sencillo son los strings ASCII, donde cada carácter ocupa 1 byte.

julia> string_asc = "Julia"
"Julia"

julia> length(string_asc)
5

julia> sizeof(string_asc)
5

La función length() devuelve el número de caracteres, y la función sizeof() el número de bytes.

Esta distinción se vuelve importante con otros conjuntos de caracteres:

julia> king = "Hrōðgār"
"Hrōðgār"

julia> length(king)
7

julia> sizeof(king)
10

Dividir

Una operación común en programación es tomar un string largo y dividirlo en partes, según un string separador de uno o más caracteres.

En general, usamos la función split(). El separador por defecto es (cualquier) espacio en blanco, pero se pueden especificar otros.

julia> split("my little string")
3-element Vector{SubString{String}}:
 "my"
 "little"
 "string"

julia> split("My_snake_case_string", "_")
4-element Vector{SubString{String}}:
 "My"
 "snake"
 "case"
 "string"

Estos ejemplos dividen un string en strings más pequeños. Dividir un string en caracteres es una operación distinta.

Buscar y reemplazar

¿Contiene un string una subcadena especificada? Curiosamente, hay dos funciones para comprobarlo: occursin() y contains() difieren solo en el orden de sus argumentos.

julia> needle = "Julia"
"Julia"

julia> haystack = "Python, Julia and R"
"Python, Julia and R"

julia> occursin(needle, haystack)
true

julia> contains(haystack, needle)
true

Para ser más específicos con la posición:

julia> startswith(haystack, "Python")
true

julia> endswith(haystack, "Python")
false

Para obtener los índices inicio:fin de una subcadena, tenemos varias funciones:

• findfirst()
• findlast()
• findprev()
• findnext()

julia> findfirst(needle, haystack)
9:13

Para reemplazar subcadenas, enumera los cambios con la sintaxis x => y.

julia> replace("abc", "a"=>"b", "b"=>"c", "c"=>"a")
"bca"

Desde Julia 1.7, la función replace puede tomar un número arbitrario de cambios, con la garantía de que ningún carácter se cambiará más de una vez durante el reemplazo.

La sintaxis x => y se llama pair, un tipo importante en Julia que se cubre con más detalle en el concepto Dicts and Pairs.

Espacios en blanco

A menudo necesitamos quitar los espacios en blanco del principio y/o del final de un string.

Las funciones para esto son lstrip() (izquierda), rstrip() (derecha) y strip() (ambos lados).

julia> strip("\n\t  useful_bit\n\n")
"useful_bit"

Cambiar mayúsculas y minúsculas

Estas funciones tienen nombres bastante claros por sí solos:

julia> s = repeat("aBcD ", 5)
"aBcD aBcD aBcD aBcD aBcD "

julia> uppercase(s)
"ABCD ABCD ABCD ABCD ABCD "

julia> lowercase(s)
"abcd abcd abcd abcd abcd "

julia> titlecase(s)  # Initial letter of each word uppercase
"Abcd Abcd Abcd Abcd Abcd "