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
'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
'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
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
"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
line"
"This is a long line"
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
"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
'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
"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
"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
"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
"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
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
'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
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
"∀ 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
Hello,
world.
"""
" Hello,\n world.\n"
Comparación de cadenas
Podemos usar operadores de comparación para comparar cadenas en orden lexicográfico:
Ejemplo
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
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
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
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
".: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