Julia Language
Instrumentos de cuerda

Sintaxis

• "[cuerda]"
• '[Valor escalar de Unicode]'
• grafemas ([string])

Parámetros

¡Hola Mundo!

Las cadenas en Julia se delimitan usando el símbolo " :

julia> mystring = "Hello, World!"
"Hello, World!"

Tenga en cuenta que a diferencia de otros idiomas, el símbolo ' no se puede utilizar en su lugar. ' define un carácter literal ; este es un tipo de datos Char y solo almacenará un único valor escalar Unicode :

julia> 'c'
'c'

julia> 'character'
ERROR: syntax: invalid character literal

Uno puede extraer los valores escalares de Unicode de una cadena iterando sobre ella con un bucle for :

julia> for c in "Hello, World!"
           println(c)
       end
H
e
l
l
o
,
 
W
o
r
l
d
!

Grafemas

El tipo Char de Julia representa un valor escalar de Unicode , que solo en algunos casos corresponde a lo que los humanos perciben como un "personaje". Por ejemplo, una representación del carácter é, como en el resumen, es en realidad una combinación de dos valores escalares de Unicode:

julia> collect("é")
2-element Array{Char,1}:
 'e'
 '́'

Las descripciones de Unicode para estos puntos de código son "LATINA PEQUEÑA LETINA E" y "COMBINACIÓN DE ACOMISTA AGUDA". Juntos, definen un único carácter "humano", que en términos de Unicode se denomina grafema . Más específicamente, el Anexo # 29 de Unicode motiva la definición de un grupo de grafemas porque:

Es importante reconocer que lo que el usuario piensa como un "carácter", una unidad básica de un sistema de escritura para un idioma, puede que no sea un solo punto de código Unicode. En su lugar, esa unidad básica puede estar formada por múltiples puntos de código Unicode. Para evitar la ambigüedad con el uso de la computadora del término carácter, esto se llama un carácter percibido por el usuario. Por ejemplo, "G" + acento agudo es un carácter percibido por el usuario: los usuarios lo consideran como un solo carácter, aunque en realidad está representado por dos puntos de código Unicode. Estos caracteres percibidos por el usuario se aproximan a lo que se llama un grupo de grafemas, que se puede determinar mediante programación.

Julia proporciona la función de graphemes para iterar sobre los grupos de grafemas en una cadena:

julia> for c in graphemes("résumé")
           println(c)
       end
r
é
s
u
m
é

Observe cómo el resultado, imprimir cada carácter en su propia línea, es mejor que si hubiéramos iterado sobre los valores escalares de Unicode:

julia> for c in "résumé"
           println(c)
       end
r
e

s
u
m
e

Normalmente, cuando se trabaja con caracteres en un sentido percibido por el usuario, es más útil tratar con grupos de grafemas que con valores escalares de Unicode. Por ejemplo, supongamos que queremos escribir una función para calcular la longitud de una sola palabra. Una solución ingenua sería utilizar

julia> wordlength(word) = length(word)
wordlength (generic function with 1 method)

Notamos que el resultado es contraintuitivo cuando la palabra incluye grupos de grafemas que constan de más de un punto de código:

julia> wordlength("résumé")
8

Cuando usamos la definición más correcta, usando la función de graphemes , obtenemos el resultado esperado:

julia> wordlength(word) = length(graphemes(word))
wordlength (generic function with 1 method)

julia> wordlength("résumé")
6

Convertir tipos numéricos a cadenas

Existen numerosas formas de convertir tipos numéricos a cadenas en Julia:

julia> a = 123
123

julia> string(a)
"123"

julia> println(a)
123

La función string() también puede tomar más argumentos:

julia> string(a, "b")
"123b"

También puede insertar (también conocido como interpolar) enteros (y algunos otros tipos) en cadenas usando $ :

julia> MyString = "my integer is $a"
"my integer is 123"

Consejo de rendimiento: los métodos anteriores pueden ser bastante convenientes a veces. Pero, si va a realizar muchas, muchas de estas operaciones y le preocupa la velocidad de ejecución de su código, la guía de rendimiento de Julia recomienda esto y, en cambio, favorece los siguientes métodos:

Puede suministrar múltiples argumentos para print() e println() que funcionarán en ellos exactamente como la string() opera en múltiples argumentos:

julia> println(a, "b")
123b

O, al escribir en un archivo, también puede utilizar, por ejemplo,

open("/path/to/MyFile.txt", "w") do file
    println(file, a, "b", 13)
end

o

file = open("/path/to/MyFile.txt", "a")
println(file, a, "b", 13)
close(file)

Estos son más rápidos porque evitan la necesidad de formar primero una cadena a partir de piezas dadas y luego emitirlas (ya sea a la pantalla de la consola o a un archivo) y, en cambio, solo generar de forma secuencial las distintas piezas.

Créditos: Respuesta basada en SO Pregunta ¿Cuál es la mejor manera de convertir un Int en una cadena en Julia? con respuesta por Michael Ohlrogge y entrada de Fengyang Wang

Interpolación de cadenas (insertar el valor definido por la variable en la cadena)

En Julia, como en muchos otros idiomas, es posible interpolar insertando valores definidos por variables en cadenas. Para un ejemplo simple:

n = 2
julia> MyString = "there are $n ducks"
"there are 2 ducks"

Podemos usar otros tipos que no sean numéricos, por ej.

Result = false
julia> println("test results is $Result")
test results is false

Puedes tener múltiples interpolaciones dentro de una cadena dada:

MySubStr = "a32"
MyNum = 123.31
println("$MySubStr  ,   $MyNum")

Interpolación de consejos de rendimiento es bastante conveniente. Pero, si lo va a hacer muchas veces muy rápidamente, no es lo más eficiente. En su lugar, consulte Convertir tipos numéricos en cadenas para obtener sugerencias cuando el rendimiento es un problema.

Uso de sprint para crear cadenas con funciones IO

Las cadenas se pueden hacer a partir de funciones que funcionan con objetos IO utilizando la función sprint . Por ejemplo, la función code_llvm acepta un objeto IO como primer argumento. Típicamente, se usa como

julia> code_llvm(STDOUT, *, (Int, Int))

define i64 @"jlsys_*_46115"(i64, i64) #0 {
top:
  %2 = mul i64 %1, %0
  ret i64 %2
}

Supongamos que queremos esa salida como una cadena en su lugar. Entonces podemos simplemente hacer

julia> sprint(code_llvm, *, (Int, Int))
"\ndefine i64 @\"jlsys_*_46115\"(i64, i64) #0 {\ntop:\n  %2 = mul i64 %1, %0\n  ret i64 %2\n}\n"

julia> println(ans)

define i64 @"jlsys_*_46115"(i64, i64) #0 {
top:
  %2 = mul i64 %1, %0
  ret i64 %2
}

Convertir los resultados de funciones "interactivas" como code_llvm en cadenas puede ser útil para el análisis automatizado, como probar si el código generado puede haber retrocedido.

La función sprint es una función de orden superior que toma la función que opera en objetos IO como su primer argumento. Detrás de escena, crea un IOBuffer en la RAM, llama a la función dada y toma los datos del búfer en un objeto String .