Cadenas de Julia

Una cadena (en inglés: string) es una secuencia finita compuesta por cero o más caracteres. Es un tipo de datos en los lenguajes de programación que representa texto.

Julia normalmente usa comillas simples'para crear caracteres individuales, comillas dobles"o comillas triples"""para crear cadenas. Por ejemplo:

c = 'x'

str = "EJEMPLO"

ejemplo = """Ejemplo "EJEMPLO",包含了单个引号"""

Características de los tipos de cadena de Julia:

  • El tipo concreto incorporado en Julia para cadenas (y literales de cadena) es String.
  • Los tipos de cadena de Julia son subtipos del tipo abstracto AbstractString.
  • Julia tiene un excelente tipo para representar un solo carácter, llamado AbstractChar. Char es un subtipo incorporado de AbstractChar, un tipo primitivo de 32 bits que puede representar cualquier carácter Unicode (basado en la codificación UTF-8).
  • Las cadenas de Julia son inmutables: el valor de cualquier objeto AbstractString no se puede cambiar.

Carácter

Un carácter individual se representa con un valor Char.

Char es un tipo primitivo de 32 bits, que se puede convertir en su valor entero correspondiente, es decir, el código Unicode:

Ejemplo

julia> c = 'x'
'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)

julia> typeof(c)
Char

julia> c = Int('x')
120

julia> typeof(c)
Int64

También podemos convertir un valor entero en Char:

Ejemplo

julia> Char(97)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> Char(120)
'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)

Podemos realizar comparaciones y operaciones aritméticas limitadas con valores Char:

Ejemplo

julia> 'A' < 'a'
true

julia> 'A' <= 'a' <= 'Z'
false

julia> 'A' <= 'X' <= 'Z'
true

julia> 'x' - 'a'
23

julia> 'A' + 1
'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)

Cadenas

Las cadenas en Julia se pueden declarar con comillas dobles"o tres comillas dobles"""para declararlas. Si necesita usar comillas en alguna parte de la cadena, puede usar las tres comillas dobles para hacerlo, como se muestra a continuación:

Ejemplo

julia> str = "EJEMPLO"
"EJEMPLO"

julia> ejemplo = """Tutorial de novatos "EJEMPLO", contiene una comilla"""
"Tutorial de novatos\"EJEMPLO\", contiene una comilla"

Si la cadena es demasiado larga, podemos usar una barra invertida\para dividirla:

Ejemplo

julia> "This is a long \
       line"

"This is a long line"
Las cadenas de Julia también pueden usar índices, como los arreglos, para leer el carácter en una posición específica o extraer la subcadena en una posición determinada. La posición inicial del índice es1obegin, la posición final esend :

Ejemplo

julia> str = "EJEMPLO"
"EJEMPLO"

julia> str[begin]
'R': ASCII/Unicode U+0052 (category Lu: Letter, uppercase)

julia> str[1]
'R': ASCII/Unicode U+0052 (category Lu: Letter, uppercase)

julia> str[2]
'U': ASCII/Unicode U+0055 (category Lu: Letter, uppercase)

julia> str[end]
'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)

julia> str[end-1]
'O': ASCII/Unicode U+004F (category Lu: Letter, uppercase)

Podemos usar índices de rango para extraer subcadenas:

Ejemplo

julia> str = "EJEMPLO"
"EJEMPLO"

julia> str[begin:end]
"EJEMPLO"

julia> str[begin:end-1]
"RUNOO"

julia> str[2:5]
"UNOO"

Además, la expresiónstr[k]ystr[k:k]da resultados diferentes; la primera obtiene el carácter en la posición especificada mediante el índice, y su tipo es Char; la segunda lee la cadena mediante el rango dado, pero solo es una cadena que contiene un carácter:

Ejemplo

julia> str[6]
'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)

julia> str[6:6]
"B"

La extracción por rango también se puede realizar usandoSubStringel método, por ejemplo:

Ejemplo

julia> str = "long string"
"long string"

julia> substr = SubString(str, 1, 4)
"long"

julia> typeof(substr)
SubString{String}

Concatenación de cadenas

Podemos usar el método string() para concatenar varias cadenas:

Ejemplo

julia> greet = "Hello"
"Hello"

julia> whom = "world"
"world"

julia> string(greet, ", ", whom, ".\n")
"Hello, world.\n"

Interpolación

Concatenar para construir cadenas a veces es algo engorroso. Para reducir las llamadas redundantes a string o la multiplicación repetida, Julia permite interpolar literales de cadena usando $, como en Perl:

Ejemplo

julia> "$greet, $whom.\n"
"Hello, world.\n"

Esto es más legible y conveniente, y equivale a la concatenación de cadenas anterior: el sistema reescribe este literal de cadena, aparentemente de una sola línea, como una concatenación de literales de cadena con parámetros.string(greet, ", ", whom, ".\n")。

En$La expresión completa más corta a continuación se considera la expresión cuyo valor se inserta en la cadena. Por lo tanto, puedes usar paréntesis para insertar cualquier expresión en una cadena:

Ejemplo

julia> "1 + 2 = $(1 + 2)"
"1 + 2 = 3"

Tanto la concatenación como la interpolación llaman a string para convertir los objetos a forma de cadena. Sin embargo, string en realidad solo devuelve la salida de print, por lo que los nuevos tipos deben agregar métodos print o show, no métodos string.

La mayoría de los objetos que no son AbstractString se convierten en cadenas que corresponden estrechamente a su forma de entrada como expresiones de texto:

Ejemplo

julia> v = [1,2,3]
3-element Vector{Int64}:
 1
 2
 3

julia> "v: $v"
"v: [1, 2, 3]"

string es la identidad de los valores AbstractString y AbstractChar, por lo que se insertan en las cadenas como ellos mismos, sin comillas ni escapes:

Ejemplo

julia> c = 'x'
'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)

julia> "hi, $c"
"hi, x"

Si desea incluir texto en un literal de cadena$, use una barra invertida para escaparlo:

Ejemplo

julia> print("I have \$100 in my account.\n")
I have $100 in my account.

Unicode y UTF-8

Julia admite completamente caracteres y cadenas Unicode.

En los literales de carácter, los códigos Unicode se pueden representar con las secuencias de escape Unicode \u y \U, y también con todas las secuencias de escape estándar de C. Estas también se pueden usar para escribir literales de cadena:

Ejemplo

julia> s = "\u2200 x \u2203 y"
"∀ x ∃ y"

Estos caracteres Unicode se muestran como escapes o como caracteres especiales dependiendo de la configuración regional de tu terminal y de su soporte para Unicode. Los literales de cadena están codificados en UTF-8. UTF-8 es una codificación de longitud variable, es decir, no todos los caracteres se codifican con el mismo número de bytes (code units). En UTF-8, los caracteres ASCII (los menores que 0x80 (128)) se codifican con un solo byte, igual que en ASCII; mientras que los caracteres de 0x80 en adelante se codifican con hasta 4 bytes.


Literales de cadena con triple comilla

Las comillas triples"""..."""nos brindan comodidad para crear cadenas más largas y complejas. Dentro de las comillas triples se pueden usar convenientemente saltos de línea, comillas y sangrías, sin necesidad de un manejo especial.

Ejemplo

julia> str = """
           Hello,
           world.
         """

"  Hello,\n  world.\n"

Comparación de cadenas

Podemos usar operadores de comparación para comparar cadenas en orden lexicográfico:

Ejemplo

julia> "abracadabra" < "xylophone"
true

julia> "abracadabra" == "xylophone"
false

julia> "Hello, world." != "Goodbye, world."
true

julia> "1 + 2 = 3" == "1 + 2 = $(1 + 2)"
true

Puedes usar las funciones findfirst y findlast para buscar el índice de un carácter específico:

Ejemplo

julia> findfirst(isequal('o'), "xylophone")
4

julia> findlast(isequal('o'), "xylophone")
7

julia> findfirst(isequal('z'), "xylophone")

Puedes usar las funciones findnext y findprev con un tercer argumento para buscar caracteres en un desplazamiento dado:

Ejemplo

julia> findnext(isequal('o'), "xylophone", 1)
4

julia> findnext(isequal('o'), "xylophone", 5)
7

julia> findprev(isequal('o'), "xylophone", 5)
4

julia> findnext(isequal('o'), "xylophone", 8)

Puedes usar la función occursin para comprobar si se puede encontrar una subcadena en una cadena.

Ejemplo

julia> occursin("world", "Hello, world.")
true

julia> occursin("o", "Xylophon")
true

julia> occursin("a", "Xylophon")
false

julia> occursin('o', "Xylophon")
true

El último ejemplo muestra que occursin también se puede usar para buscar literales de carácter.

Además, hay otras dos funciones de cadena convenientes: repeat y join:

Ejemplo

julia> repeat(".:Z:.", 10)
".:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:."

julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"

Otras funciones útiles incluyen:

  • firstindex(str)- Devuelve el índice (de byte) más pequeño que se puede usar para indexar en str (para cadenas, esto siempre es 1, pero no necesariamente para otros contenedores).
  • lastindex(str)- Devuelve el índice (de byte) más grande que se puede usar para indexar en str.
  • length(str)- El número de caracteres en str.
  • length(str, i, j)- El número de índices de caracteres válidos en str desde i hasta j.
  • ncodeunits(str)- El número de unidades de código (code units) en la cadena.
  • codeunit(str, i)- Devuelve el valor de la unidad de código en el índice i de la cadena str.
  • thisind(str, i)- Dado un índice arbitrario en una cadena, encuentra el primer índice del punto de indexación.
  • nextind(str, i, n=1)- Encuentra el inicio del enésimo carácter después del índice i.
  • prevind(str, i, n=1)- Encuentra el inicio del enésimo carácter antes del índice i.

Literales de cadena sin procesar

Las cadenas sin procesar, sin interpolación y sin escapes se pueden expresarraw"..."mediante literales de cadena no estándar de la forma. Los literales de cadena sin procesar generan un objeto String ordinario que contiene el contenido encerrado exactamente como se ingresó, sin interpolación ni escapes. Esto es útil para cadenas que contienen código o marcado que utiliza"o\"caracteres especiales. Es muy útil.

La excepción es que las comillas aún deben escaparse, por ejemploraw"\""es equivalente a"\"". Para poder expresar todas las cadenas, la barra invertida también debe escaparse, pero solo cuando aparece justo antes de una comilla.

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

Observa que las dos primeras barras invertidas se muestran literalmente en la salida, porque no están delante de una comilla. Sin embargo, la siguiente barra invertida escapa a la barra invertida que le sigue; y como estas barras invertidas aparecen delante de una comilla, la última barra invertida escapa una comilla.

Otras extensiones