Cadenas de texto en Julia (3ª parte – ¡Hola Julia!)

Las cadenas de texto en Julia son secuencias de caracteres ordenadas, algo similar a los que sucede en el resto de los lenguajes. Lo que las convierte en un tipo de dato especial. Aunque en Julia tenemos una ventaja, la que se puede en algunos casos volver un inconveniente, que es la posibilidad de trabajar con Unicode. Evitando problemas a la hora de usar caracteres que no existen en inglés.

Comillas dobles y comillas simple

Lo primero que debemos saber a la hora de crear cadenas de carácter en Julia es que estas se crean encerrando los caracteres entre comillas dobles. Las comillas simples solamente se pueden usar para un carácter. Lo que tiene algunas consecuencias a la hora de trabajar, ya que no es lo mismo "a" que 'a'. La primera es una cadena de caracteres y la segunda es único carácter.

"a" == 'a' # false

Usar comillas sencillas para encerrar más de un carácter dará un error de sintaxis, esto es 'hola' parará la ejecución del código.

Por lo que es importante diferenciar el uso de "" para cadenas de caracteres y '' para caracteres.

Accediendo a los elementos de una cadena de caracteres

Para acceder a los elementos de una cadena de caracteres se ha de indicar el nombre de la variable y entre corchetes la posición del elemento al que se desea acceder. Por ejemplo

var = "hola"
var[1] # 'h'
var[2] # 'o'

Lo primero es que la primera posición comienza en un 1, al igual que sucede en Matlab, no en 0 como puede ser el caso de Python. Así que el último elemento es igual a la longitud de la cadena, valor que se puede obtener con length(var). Aunque si lo que se quiere es acceder al elemento se puede usar la palabra reservado end

var[length(var)]
var[end]

En ambos casos se accede a la 'a'.

Subcadenas de texto

Las subcandenas de texto se pueden obtener utilizando el operador dos puntos (:). Operador que es familiar para los que trabajan con Matlab. En lugar de pasar un numero se puede pasar la primera posición, dos puntos y la última posición de la cadena.

var[2:3] # "ol"

Para los que vienen de Python en el caso de Julia sí que se incluye el último elemento cuando se genera la lista. Si queremos ir siempre hasta la última posición, se puede usar el comando end, sin que sea necesario que calculemos antes cuál es la última posición.

var[2:end] # "ola"

Cadenas con Unicode

Los símbolos Unicode también pueden formar parte de una cadena de caracteres.

var = "🍐 es una pera"

Aunque en estos casos hay que tener cuidado, ya que los símbolos Unicode ocupan cuatro posiciones en lugar de una. Intentar acceder a una posición intermedia de las ocupadas por un símbolo Unicode producirá un error, por lo que se debería evitar esto. Esto es, en la cadena de ejemplo el símbolo de la pera esta en la posición 1, el primer espacio esta en la posición 5 e intentar acceder a las posiciones 2, 3 o 4 dará un error. Esto es:

var[1] # '🍐'
var[2] # StringIndexError
var[5] # ' '

Por lo que es importante evitar acceder a estas posiciones de la cadena.

Iterar en cadenas con símbolos Unicode

Para iterar en cadenas con símbolos Unicode debemos usar algunas de las funciones que ofrece Julia, entre las que destacan firstindex para obtener la primera posición y nextind para obtener la siguiente y sizeofpara obtener el tamaño de la cadena ( length nos da el número de caracteres, no la longitud de la cadena). Así se puede usar un bucle while (bucle cuya sintaxis básica es exactamente igual que en Matlab) para iterar sobre una cadena

frutas = "🍌 🍎 🍐"

index = firstindex(frutas)
while index <= sizeof(frutas)
    println(fruits[index])
    index = nextind(frutas, index)
end

Identificar elementos dentro de una cadena

Para saber si un carácter existe dentro de una cadena de texto se puede usar el operador in (o alternativamente el símbolo ∈ que se pude conseguir con in). Así para saber si una cadena contiene la letra 'a' se puede usar

'a' ∈ "hola"  # true
'a' ∈ "Adios" # false

Es importante notar que no se puede usar comillas dobles en este caso, ya que tendríamos un error.

"la" ∈ "hola" # Error

Lo que hace necesario funciones nativas de Julia para estos casos.

Identificar subcadenas en cadena

Par identifica la posición de subcadenas tenemos dos funciones principales findfirst y findnext. La primera nos permite encontrar la primera ocurrencia de una cadena y la segunda la siguiente a partir de una posición dada. En ambos casos, cuando la subcadena existe devolverá la posición de esta, la posición inicial y la final, si no existe una subcadena que cumpla la condición devolverán el valor nothing. Es importante notar que en la línea de comandos de Julia el valor nothing no mostrará, es necesario usar la función show() para poder ver el valor.

a = nothing
a # No se verá nada en la pantalla

Para confirmar que a contiene nothing se debería usar la siguiente instrucción

show(a)

Primera posición

La primera posición de una subcadena se puede obtener con la función findfirst a la que se le pasa como primeros parámetros la cadena a buscar y como segundo la cadena dónde buscar.

findfirst("la", "Hola Julia") # 3:4
findfirst("ha", "Hola Julia") # nothing

Siguientes posiciones

Para conocer las siguientes posiciones de una subcadena en una cadena se debería usar la función findnext. El primer parámetro de esta función es la cadena que buscar, el segundo es la cadena en la que buscar y la tercera es la primera posición para buscar.

findnext("a", "Hola Julia", 1) # 4:4
findnext("a", "Hola Julia", 4) # 4:4
findnext("a", "Hola Julia", 5) # 10:10

En los ejemplos se puede ver cómo se busca la subcadena desde la primera posición que se ha indicado, incluyendo esta. Algo importante a la hora de buscar más de una posición.

Concatenación de cadenas

Las cadenas de texto se concatenan con operador '*', generando una nueva cadena. De forma análoga a las operaciones algebraicas es posible usar el operar ^ para repetir una misma cadena más de una vez. Así se puede obtener

"Hola" * " " * "Mundo" # "Hola Mundo"
"Hola" ^ 3 # "HolaHolaHola"

Interpolación de cadenas

En los casos más sencillos la concatenación de cadenas puede ser suficiente, pero para crear cadenas más complejas una mejor solución es usar interpolación. Lo que nos permite introducir en una cadena de texto el resultado de cualquier variable u operación que podamos hacer con Julia. Para lo que se usa el comando el operador $ dentro de una cadena

mundo = "mundo"
"Hola $mundo" # "Hola mundo"

Además de esto se puede usar paréntesis para envolver cualquier variable u operación que se desee reemplazar dentro de la cadena.

"El valor de 1+2 es $(1+2)" # "El valor de 1+2 es 3"

Algo que nos ofrece muchas posibilidades a la hora de generar mensaje en nuestros programas.

Grandes posibilidades con las cadenas de texto en Julia

Julia ofrece muchas posibilidades a la hora de trabajar con cadenas de texto. Partiendo del hecho de trabajar de forma nativa con texto Unicode, lo que en otros lenguajes puede ser un problema. Aunque esto también tiene un precio, al existir caracteres que ocupan una posición o cuatro en la cadena nos encontramos que necesario tomar precauciones cuando se trabaja con estos objetos.