Literal de cadena

Una cadena literal o cadena anónima es una representación literal de un valor de cadena en el código fuente . Generalmente, un lenguaje de programación incluye una estructura de código para cadenas literales, que consiste en una serie de caracteres entre corchetes , normalmente comillas. En muchos lenguajes, el texto "foo"es una cadena literal que codifica el texto, foopero existen muchas otras variaciones.

Al usar comillas, si se desea representar el delimitador en sí mismo en un literal de cadena, se presenta el problema de la colisión de delimitadores . Por ejemplo, si el delimitador es una comilla doble, no se puede representar simplemente una comilla doble en sí misma mediante el literal, """ya que la segunda comilla se interpreta como el final del literal de cadena, no como el valor de la cadena, y de manera similar no se puede escribir "This is "in quotes", but invalid."ya que la parte entre comillas del medio se interpreta como fuera de las comillas. Existen varias soluciones, la más general de las cuales es el uso de secuencias de escape, como "\""o "This is \"in quotes\" and properly escaped.", pero hay muchas otras soluciones.

Las comillas emparejadas, como las llaves en Tcl, permiten cadenas anidadas, como {foo {bar} zork}pero no resuelven el problema de la colisión de delimitadores, ya que un delimitador de cierre desequilibrado no puede simplemente incluirse, como en {}}.

'Esta cadena de Pascal '' contiene dos apóstrofes '' '

"Le dije: "¿Puedes oírme?""

"Esta es la manzana de John." "Le dije: "¿Puedes oírme?"

'Dije: "Esta es la manzana de John ."'

'Dije: "Esta es la manzana de John ."'

qq^Dije: "¿Puedes oírme?"^ qq@Dije: "¿Puedes oírme?"@ qq§Dije: "¿Puedes oírme?"§

local ls = [=[ Esta notación se puede usar para rutas de Windows: ruta local = [[C:\Windows\Fonts]] ]=]

"Dije, " + CHR$ ( 34 ) + "¿Puedes oírme?" + CHR$ ( 34 )

char buffer [ 32 ]; snprintf ( buffer , sizeof buffer , "Esto es %cin quotes.%c" , 34 , 34 );

Las secuencias de escape son una técnica general para representar caracteres que de otro modo serían difíciles de representar directamente, incluidos los delimitadores, los caracteres no imprimibles (como los retrocesos), los saltos de línea y los caracteres de espacio en blanco (que de otro modo serían imposibles de distinguir visualmente), y tienen una larga historia. Por consiguiente, se utilizan ampliamente en literales de cadena, y agregar una secuencia de escape (ya sea a un solo carácter o a lo largo de una cadena) se conoce como escape .

Se elige un carácter como prefijo para codificar caracteres que son difíciles o imposibles de incluir directamente. Lo más común es la barra invertida ; además de otros caracteres, un punto clave es que la barra invertida en sí misma se puede codificar como una doble barra invertida \\y, para cadenas delimitadas, el delimitador en sí se puede codificar mediante escape, por ejemplo, con \"para ". Una expresión regular para dichas cadenas con escape se puede dar de la siguiente manera, como se encuentra en la especificación ANSI C : ^{[ 1 ] [ c ]}

"​(\\.|[^\\"])*

significa "una comilla; seguida de cero o más caracteres de escape (barra invertida seguida de algo, posiblemente barra invertida o comilla), o un carácter que no sea de escape ni de comilla; terminando en una comilla" – el único problema es distinguir la comilla de cierre de una comilla precedida por una barra invertida, que a su vez puede ser de escape. Varios caracteres pueden seguir a la barra invertida, como \uFFFF, dependiendo del esquema de escape.

Una cadena escapada debe ser analizada léxicamente , convirtiéndose así en la cadena original que representa. Esto se realiza durante la fase de evaluación del análisis léxico general del lenguaje de programación: el evaluador del analizador léxico del lenguaje ejecuta su propio analizador léxico para los literales de cadena escapada.

Entre otras cosas, debe ser posible codificar el carácter que normalmente finaliza la cadena constante, además de que debe existir alguna forma de especificar el carácter de escape. Las secuencias de escape no siempre son elegantes ni fáciles de usar, por lo que muchos compiladores también ofrecen otros medios para resolver los problemas comunes. Sin embargo, las secuencias de escape resuelven cualquier problema de delimitación y la mayoría de los compiladores las interpretan. Cuando un carácter de escape se encuentra dentro de un literal de cadena, significa "este es el inicio de la secuencia de escape". Cada secuencia de escape especifica un carácter que se colocará directamente en la cadena. El número real de caracteres necesarios en una secuencia de escape varía. El carácter de escape se encuentra en la parte superior izquierda del teclado, pero el editor lo traducirá, por lo que no se puede insertar directamente en una cadena. La barra invertida se utiliza para representar el carácter de escape en un literal de cadena.

Muchos lenguajes admiten el uso de metacaracteres dentro de literales de cadena. Los metacaracteres tienen diferentes interpretaciones según el contexto y el lenguaje, pero generalmente son una especie de "comando de procesamiento" para representar caracteres imprimibles o no imprimibles.

Por ejemplo, en una cadena literal de C, si la barra invertida va seguida de una letra como "b", "n" o "t", esto representa un carácter no imprimible de retroceso , salto de línea o tabulación , respectivamente. O si la barra invertida va seguida de 1 a 3 dígitos octales , esta secuencia se interpreta como la unidad de código arbitraria con el valor especificado en la codificación del literal (por ejemplo, el código ASCII correspondiente para un literal ASCII). Posteriormente, esto se amplió para permitir la notación de códigos de caracteres hexadecimales más moderna .

" Dije: ¿Puedes oírme ?

Nota: No todas las secuencias de la lista son compatibles con todos los analizadores sintácticos, y puede haber otras secuencias de escape que no estén en la lista.

"La ruta de Windows es C:\\Foo\\Bar\\Baz\\" @"La ruta de Windows es C:\Foo\Bar\Baz\"

<![CDATA[ if (path!=null && depth<2) { add(path); } ]]>

En muchos lenguajes, las cadenas literales pueden contener saltos de línea literales que abarcan varias líneas. Alternativamente, los saltos de línea se pueden escapar, generalmente como \n. Por ejemplo:

eco 'foo bar'

y

echo -e "foo\nbar"

Ambas son sentencias BASH válidas y ambas producen el mismo resultado:

comida bar

Los lenguajes que permiten saltos de línea literales incluyen BASH , Lua , Perl , PHP , R y Tcl . En otros lenguajes, los literales de cadena no pueden incluir saltos de línea.

Dos problemas con las cadenas literales multilínea son los saltos de línea iniciales y finales, y la indentación. Si los delimitadores inicial y final se encuentran en líneas separadas, se generan saltos de línea adicionales; si no, el delimitador dificulta la lectura de la cadena, especialmente en la primera línea, que suele tener una indentación diferente a la del resto. Además, la cadena literal debe estar sin indentar, ya que se conservan los espacios en blanco iniciales; esto interrumpe el flujo del código si la cadena literal aparece dentro de código indentado.

La solución más común para estos problemas son los literales de cadena estilo documento here . Formalmente hablando, un documento here no es un literal de cadena, sino un literal de flujo o un literal de archivo. Estos se originan en scripts de shell y permiten que un literal se pase como entrada a un comando externo. El delimitador de apertura es donde puede ser cualquier palabra, y el delimitador de cierre está en una línea aparte, sirviendo como límite de contenido; el se debe a la redirección de stdin desde el literal. Debido a que el delimitador es arbitrario, estos también evitan el problema de la colisión de delimitadores. Estos también permiten eliminar tabulaciones iniciales mediante la sintaxis variante, aunque los espacios iniciales no se eliminan. La misma sintaxis se ha adoptado desde entonces para literales de cadena multilínea en varios lenguajes, sobre todo Perl, y también se les conoce como documentos here, y conservan la sintaxis, a pesar de ser cadenas y no implicar redirección. Al igual que con otros literales de cadena, estos a veces pueden tener un comportamiento diferente especificado, como la interpolación de variables.<<ENDENDEND<<<<-END

Python, cuyos literales de cadena habituales no permiten saltos de línea literales, tiene en su lugar una forma especial de cadena, diseñada para literales multilínea, llamada comillas triples . Estas usan un delimitador triple, ya sea '''o """. Estos literales se usan especialmente para la documentación en línea, conocida como docstrings .

Tcl permite saltos de línea literales en cadenas y no tiene sintaxis especial para ayudar con cadenas de varias líneas, aunque los delimitadores se pueden colocar en líneas por sí solos y los saltos de línea iniciales y finales se pueden eliminar mediante string trim, mientras que string mapse puede usar para eliminar la sangría.

Algunos lenguajes proporcionan concatenación de literales de cadena , donde los literales de cadena adyacentes se unen implícitamente en un solo literal en tiempo de compilación. Esta es una característica de C, ^{[ 7 ] [ 8 ]} C++, ^{[ 9 ]} D, ^{[ 10 ]} Ruby, ^{[ 11 ]} y Python, ^{[ 12 ]} que la copió de C. ^{[ 13 ]} Cabe destacar que esta concatenación ocurre en tiempo de compilación, durante el análisis léxico (como una fase posterior a la tokenización inicial), y se contrasta con la concatenación de cadenas en tiempo de ejecución (generalmente con el +operador) ^{[ 14 ]} y la concatenación durante el plegado de constantes , que ocurre en tiempo de compilación, pero en una fase posterior (después del análisis de frases o "parsing"). La mayoría de los lenguajes, como C#, Java ^{[ 15 ]} y Perl, no admiten la concatenación implícita de literales de cadena, y en su lugar requieren la concatenación explícita, como con el +operador (esto también es posible en D y Python, pero ilegal en C/C++ – ver más abajo); En este caso, la concatenación puede ocurrir en tiempo de compilación, mediante la reducción de constantes, o puede posponerse hasta el tiempo de ejecución.

char s [] = "hola, " "mundo" ; printf ( "hola, " "mundo" );

char s [] = "hola, " + "mundo" ; printf ( "hola, " + "mundo" );

char archivo_y_mensaje [] = __ARCHIVO__ ": mensaje" ;

char archivo_y_mensaje [] = "ac" ": mensaje" ;

char archivo_y_mensaje [] = "ac: mensaje" ;

#define STRINGIFY(x) #x #define TOSTRING(x) STRINGIFY(x) #define AT __FILE__ ":" TOSTRING(__LINE__)

importar re desde re importar Patrónpatrón : Patrón = re.compile ( "[A-Za-z_]" # letra o guion bajo " [ A-Za-z0-9_]*" # letra, dígito o guion bajo )

l : lista [ str ] = [ "foo" , "bar" "zork" ]

Algunos lenguajes ofrecen más de un tipo de literal, con comportamientos distintos. Esto se utiliza especialmente para indicar cadenas sin formato (sin escape) o para habilitar o deshabilitar la interpolación de variables, pero también tiene otros usos, como distinguir conjuntos de caracteres. Generalmente, esto se logra cambiando el carácter de comillas o añadiendo un prefijo o sufijo. Esto es comparable a los prefijos y sufijos que se usan en los literales enteros , como para indicar números hexadecimales o enteros largos.

Uno de los ejemplos más antiguos se encuentra en los scripts de shell, donde las comillas simples indican una cadena sin formato o "cadena literal", mientras que las comillas dobles contienen secuencias de escape e interpolación variable.

Por ejemplo, en Python , las cadenas sin formato van precedidas de un ro R– compárese 'C:\\Windows'con r'C:\Windows'(aunque una cadena sin formato de Python no puede terminar en un número impar de barras invertidas). Python 2 también distingue dos tipos de cadenas: cadenas ASCII de 8 bits ("bytes") (el valor predeterminado), indicadas explícitamente con un prefijo bo B, y cadenas Unicode, indicadas con un prefijo uo . ^{[ 25 ]} mientras que en Python 3 las cadenas son Unicode por defecto y los bytes son un tipo separado que cuando se inicializan con comillas deben ir precedidos de un .Ubytesb

La notación de C# para cadenas sin formato se llama comillas con @.

@"C:\Foo\Bar\Baz\"

Si bien esto desactiva el escape, permite el uso de comillas dobles, lo que permite representar comillas dentro de la cadena:

"Dije: "Hola.""

C++11 permite cadenas sin formato, cadenas Unicode (UTF-8, UTF-16 y UTF-32) y cadenas de caracteres anchos, determinadas por prefijos. También añade literales para las cadenas existentes de C++ string, que generalmente se prefieren a las cadenas de estilo C existentes.

En Tcl, las cadenas delimitadas por llaves son literales, mientras que las cadenas delimitadas por comillas tienen caracteres de escape e interpolación.

Perl tiene una amplia variedad de cadenas, que se consideran más formalmente operadores, y se conocen como operadores de comillas y operadores similares a comillas . Estos incluyen tanto una sintaxis usual (delimitadores fijos) como una sintaxis genérica, que permite elegir delimitadores. Estos incluyen: ^{[ 26 ]}

'' "" `` // m// qr// s/// y // / q{} qq{} qx{} qw{} m{} qr{} s{}{} tr {}{} y {}{}

REXX utiliza caracteres de sufijo para especificar caracteres o cadenas utilizando su código hexadecimal o binario. Por ejemplo:

'20' x "0010 0000" b "00100000" b 

todos generan el carácter de espacio , evitando la llamada a la función X2C(20).

En algunos lenguajes, las cadenas literales pueden contener marcadores de posición que hacen referencia a variables o expresiones del contexto actual , las cuales se evalúan (generalmente en tiempo de ejecución). Esto se conoce como interpolación de variables o, más comúnmente, interpolación de cadenas . Los lenguajes que admiten la interpolación suelen distinguir entre las cadenas literales interpoladas y las que no lo son. Por ejemplo, en los shells Unix compatibles con sh (así como en Perl y Ruby), las cadenas entre comillas dobles (delimitadas por comillas simples, ") se interpolan, mientras que las cadenas entre comillas simples (delimitadas por apóstrofes simples, ' ) no lo son. A los literales de cadena no interpolados a veces se les denomina "cadenas sin procesar", pero esto es distinto de "cadena sin procesar" en el sentido de escape. Por ejemplo, en Python, una cadena con prefijo ro Rse llama cadena sin procesar y no tiene escape ni interpolación, ^{[ 27 ]} una cadena normal (sin prefijo) tiene escape pero no interpolación, ^{[ 28 ]} y una cadena con prefijo fo Fse llama f-cadena ^{[ 29 ]} y tiene escape ^{[ 30 ]} e interpolación. ^{[ 31 ]}

Por ejemplo, el siguiente código Perl :

$name = "Nancy" ; $greeting = "Hola Mundo" ; print "$name dijo $greeting a la multitud de gente." ;

produce el siguiente resultado:

Nancy saludó al mundo con un "Hola, mundo" a la multitud.

En este caso, el carácter metacaracter ($) (que no debe confundirse con el símbolo en la instrucción de asignación de variables) se interpreta para indicar interpolación de variables y requiere algún tipo de escape si necesita ser mostrado literalmente.

Esto debe contrastarse con la printffunción, que produce el mismo resultado utilizando notación como:

printf "%s dijo %s a la multitud de gente." , $name , $greeting ;

pero no realiza interpolación: es %sun marcador de posición en una cadena de formato printf , pero las variables en sí están fuera de la cadena.

Esto contrasta con las cadenas "en bruto":

print '$name dijo $saludo a la multitud de gente.' ;

que producen resultados como:

$name dijo $saludando a la multitud de gente.

Aquí, los caracteres $ no son metacaracteres y no se interpretan con ningún significado más allá del texto plano.

Los lenguajes que carecen de flexibilidad para especificar literales de cadena dificultan especialmente la escritura de código que genera otro código. Esto es particularmente cierto cuando el lenguaje de generación es igual o similar al lenguaje de salida.

Por ejemplo:

• escribir código para producir quinos
• generar un lenguaje de salida desde dentro de una plantilla web ;
• usar XSLT para generar XSLT, o SQL para generar más SQL
• Generar una representación PostScript de un documento para su impresión, desde una aplicación de procesamiento de documentos escrita en C u otro lenguaje.

Sin embargo, algunos lenguajes están particularmente bien adaptados para producir este tipo de resultados autosimilares, especialmente aquellos que admiten múltiples opciones para evitar la colisión de delimitadores.

El uso de literales de cadena como código que genera otro código puede tener consecuencias negativas para la seguridad, especialmente si la salida se basa, al menos parcialmente, en datos de entrada de usuario no confiables. Esto es particularmente grave en el caso de aplicaciones web, donde usuarios malintencionados pueden aprovechar estas vulnerabilidades para sabotear el funcionamiento de la aplicación, por ejemplo, mediante un ataque de inyección SQL .

• Personaje literal
• Literales XML
• Sigilo (programación informática)

• Literales en programación