En programación de computadoras , el síndrome del palillo inclinado ( LTS ) es la situación en la que una expresión entre comillas se vuelve ilegible porque contiene una gran cantidad de caracteres de escape , generalmente barras invertidas ("\"), para evitar la colisión del delimitador . [1] [2]
La documentación oficial de Perl [3] introdujo el término a un uso más amplio; allí, la frase se usa para describir expresiones regulares que coinciden con rutas de estilo Unix , en las que los elementos están separados por barras /
. La barra también se utiliza como delimitador expresión regular predeterminada, por lo que se utilizará, literalmente, en la expresión, hay que escapó con una vuelta barra \
, lo que lleva a cuchilladas escapado frecuentes representados como \/
. Si se duplica, como en las URL, esto da \/\/
como resultado un escape //
. Un fenómeno similar ocurre para las rutas de DOS / Windows , donde la barra invertida se usa como un separador de ruta, lo que requiere una barra invertida doble \\
; esto se puede volver a escapar para una expresión regular dentro de una cadena de escape, lo que requiere \\\\
que coincida con una sola barra invertida. En casos extremos, como una expresión regular en una cadena de escape, hacer coincidir una ruta de la Convención de nomenclatura uniforme (que comienza \\
) requiere 8 barras diagonales inversas \\\\\\\\
debido a que 2 barras diagonales inversas tienen un doble escape.
LTS aparece en muchos lenguajes de programación y en muchas situaciones, incluso en patrones que coinciden con los identificadores uniformes de recursos (URI) y en programas que generan texto entre comillas. Muchos quines entran en la última categoría.
Ejemplo de patrón
Considere la siguiente expresión regular de Perl destinada a hacer coincidir los URI que identifican archivos en el pub
directorio de un sitio FTP :
m / ftp: \ / \ / [^ \ /] * \ / pub \ //
Perl, como sed antes, resuelve este problema permitiendo que muchos otros caracteres sean delimitadores de una expresión regular. Por ejemplo, los siguientes tres ejemplos son equivalentes a la expresión dada anteriormente:
m {ftp: // [^ /] * / pub /}m # ftp: // [^ /] * / pub / #m! ftp: // [^ /] * / pub /!
O esta traducción común para convertir barras invertidas en barras diagonales:
tr / \\ / \ //
puede ser más fácil de entender cuando se escribe así:
tr {\\} {/}
Ejemplo de texto citado
Un programa Perl para imprimir una etiqueta de enlace HTML, donde la URL y el texto del enlace se almacenan en variables $url
y $text
, respectivamente, podrían verse así. Observe el uso de barras invertidas para escapar de los caracteres entre comillas dobles:
imprimir " $ texto " ;
El uso de comillas simples para delimitar la cadena no es factible, ya que Perl no expande variables dentro de cadenas entre comillas simples. El siguiente código, por ejemplo, no funcionaría según lo previsto:
imprimir ' $ texto '
El uso de la printf
función es una solución viable en muchos lenguajes (Perl, C , PHP ):
printf ( '% s ' , $ url , $ texto );
El qq
operador en Perl permite cualquier delimitador:
Aquí los documentos son especialmente adecuados para cadenas de varias líneas; sin embargo, los documentos de Perl here no habían permitido una sangría adecuada antes de la v5.26. [4] Este ejemplo muestra la sintaxis de Perl:
imprimir << HERE_IT_ENDS ; $ texto HERE_IT_ENDS
Otros idiomas
C#
El lenguaje de programación C # maneja LTS mediante el uso del @
símbolo al comienzo de los literales de cadena, antes de las comillas iniciales, p. Ej.
string filePath = @ "C: \ Foo \ Bar.txt" ;
en lugar de requerir de otra manera:
string filePath = "C: \\ Foo \\ Bar.txt" ;
C ++
El estándar C ++ 11 agrega cadenas sin procesar :
std :: string filePath = R " ( C: \ Foo \ Bar.txt ) " ;
Si la cadena contiene los caracteres )"
, se puede utilizar un delimitador opcional, como d
en el siguiente ejemplo:
std :: regex re { R " d ( s /" \ ([^ "] * \)" / '\ 1' / g ) d " };
Ir
Go indica que una cadena está sin formato utilizando la comilla invertida como delimitador:
s : = `C: \ Foo \ Bar.txt`
Las cadenas sin formato pueden contener cualquier carácter excepto las comillas inversas; no hay código de escape para una comilla invertida en una cadena sin formato. Las cadenas sin formato también pueden abarcar varias líneas, como en este ejemplo, donde las cadenas s
y t
son equivalentes:
s : = `Una cadena que abarca varias líneas. ' t : = " Una cadena que \ npasa varias \ nlíneas ".
Pitón
Python tiene una construcción similar usando r
:
filePath = r "C: \ Foo \ Bar.txt"
También se pueden usar junto con comillas triples:
ejemplo = r "" "Primera línea:" C: \ Foo \ Bar.txt " Segunda línea: nada" ""
Rubí
Ruby usa comillas simples para indicar una cadena sin procesar:
filePath = 'C: \ Foo \ Bar.txt'
También tiene literales de porcentaje de expresiones regulares con opción de delimitador como Perl:
% r {ftp: // [^ /] * / pub /} % r # ftp: // [^ /] * / pub / # % r! ftp: // [^ /] * / pub /!
Oxido
Rust usa una variante del r
prefijo: [5]
" \ x52 " ; // R r "\ x52" ; // \ x52 r # "" foo "" # ; // "foo" r ## "foo #" # barra "## ; // foo #" # barra
El literal comienza con r
seguido de cualquier número de #
, seguido de uno "
. Los "
contenidos adicionales en el literal se consideran parte del literal, a menos que estén seguidos por al menos tantos #
como se usan después de la apertura r
.
Scala
Scala permite el uso de comillas triples para evitar confusiones:
val filePath = "" "C: \ Foo \ Bar.txt" "" val pubPattern = "" "ftp: // [^ /] * / pub /" "" r
Las comillas triples también permiten cadenas de varias líneas, como se muestra aquí:
val text = "" "Primera línea, segunda línea." ""
Sed
Las expresiones regulares de Sed , particularmente aquellas que usan el operador "s", son muy similares a Perl (sed es un predecesor de Perl). El delimitador predeterminado es "/", pero se puede utilizar cualquier delimitador; el valor predeterminado es "s / regexp / replacement /", pero "s: regexp: replacement:" también es un formulario válido. Por ejemplo, para hacer coincidir un directorio "pub" (como en el ejemplo de Perl) y reemplazarlo con "foo", el valor predeterminado (escapando de las barras) es
s / ftp: \ / \ / [^ \ /] * \ / pub \ // foo /
El uso de un signo de exclamación ("!") Como delimitador en su lugar produce
s ! ftp : // [^ /] * / pub / ! foo !
Ver también
Referencias
- ^ Andy Lester, Richard Foley (2005). Depuración Pro Perl . Andy Lester, Richard Foley. pag. 176. ISBN 1-59059-454-1.
- ^ Daniel Goldman (febrero de 2013). Guía definitiva de sed . Prensa EHDP. ISBN 978-1-939824-00-4.
- ^ perlop en perldoc.perl.org.
- ^ Documentos con sangría aquí
- ^ Literales de cadena de bytes sin procesar en rust-lang.org.