Literales

  • Enlace amigable (slug) de la revisión: Guía_JavaScript_1.5/Literales
  • Título de la revisión: Literales
  • Id de la revisión: 281468
  • Creada:
  • Creador: Retrasao
  • ¿Es la revisión actual? No
  • Comentario /* Literales */

Contenido de la revisión

Literales

Se utilizan los literales para representar valores en JavaScript. Estos son valores fijados, no variables, que usted literalmente proporciona en su script. Esta sección describe los siguientes tipos de literales:

Arreglos de literales

Un arreglo literal es una lista de cero o más expresiones, cada una de las cuales representa un elemento del arreglo, delimitada por corchetes ([]). Cuando crea un arreglo usando un arreglo literal, aquel será inicializado con los valores especificados como sus elementos y su longitud será el número de argumentos especificados.

El siguiente ejemplo crea un arreglo de cafés con tres elementos y una longitud de tres:

cafés = ["Tueste francés", "Colombiano", "Kona"]

Nota Un arreglo literal es un tipo de objeto iniciador. Véase: el uso de objetos iniciadores.

Si un arreglo es creado usando un literal en un script de alto nivel, JavaScript interpreta el arreglo cada vez que es evaluada la expresión que contiene el arreglo literal. Adicionalmente, un literal utilizado en una función es creado cada vez que la función es invocada.

Los arreglos literales también son un arreglo de objetos. Véase: el objeto array para más detalles.

Comas extra en Arreglos Literales

No tiene que especificar todos los elementos dentro de un arreglo literal. Si pone dos comas en una fila, el arreglo es creado con espacios para los elementos no especificados. El siguiente ejemplo crea el arreglo pez:

pez = ["León", , "Angel"]

Este arreglo posee dos elementos con los valores establecidos y un elemento vacío (pez{{mediawiki.external(0)}} es "León", pez{{mediawiki.external(1)}} es undefined y pez{{mediawiki.external(2)}} es "Angel").

Si incluye una coma al final de la lista de elementos, esta coma es ignorada. En el siguiente ejemplo, la longitud del arreglo es tres. No existe miLista{{mediawiki.external(3)}}. Todas las otras comas en la lista indican a un nuevo elemento.

Recuerde que se referencia al primer elemento de una lista con el valor de cero {{mediawiki.external(0)}}.

miLista = ['casa', , 'escuela', ];

En el siguiente ejemplo, la longitud del arreglo es cuatro y miLista{{mediawiki.external(0)}} y miLista{{mediawiki.external(2)}} están vacíos.

miLista = [ , 'casa', , 'escuela'];

En el siguiente ejemplo, la longitud del arreglo es cuatro y miLista{{mediawiki.external(1)}} y miLista{{mediawiki.external(3)}} están vacíos. Sólo la última coma es ignorada.

miLista = ['casa', , 'escuela', , ];

Literales lógicos booleans

El tipo Boolean posee dos valores literales: true y false.

No debe confundirse los valores primitivos Boolean true y false con los valores verdadero {{mediawiki.external('true')}} y falso {{mediawiki.external('false')}} del objeto Boolean. El objeto Boolean es un contenedor {{mediawiki.external('wrapper')}} de los tipos de datos primitivos Boolean. Véase: el objeto boolean para más información.

Literales enteros

Los enteros pueden ser expresados en decimales (base 10), hexadecimales (base 16) y octales (base 8). Un literal entero decimal consiste de una secuencia de dígitos sin un 0 (cero) por delante. Un 0 (cero) por delante en un literal entero indica que este es un octal; Un 0x (o 0X) por delante indica que es un hexadecimal. Un entero hexadecimal puede incluir los dígitos (0-9) y las letras a-f y A-F. Los enteros octales pueden incluir sólamente los dígitos 0-7.

Los literales enteros octales están obsoletos y han sido removidos del estandar de la ECMA-262, Edición 3. JavaScript 1.5 mantiene un soporte para ellos sólo por compatibilidad con versiones anteriores.

Algunos ejemplos de literales enteros son:

0, 117 y -345 (decimales, base 10)
015, 0001 y -077 (octales, base 8) 
0x1123, 0x00111 y -0xF1A7 (hexadecimales, "hex" o base 16)

Literales de coma flotante

Un literal de coma flotante puede contener las siguientes partes:

  • Un entero decimal el cual puede tener signo (precedido por "+" o "-"),
  • Un punto decimal ("."),
  • Una fracción (otro número decimal),
  • Un exponente.

La parte exponencial es una "e" o "E" seguida de un entero, el cual puede tener signo (precedido por "+" o "-"). Un literal de coma flotante debe tener al menos un dígito y, o un punto decimal o una "e" (o "E").

Algunos ejemplos de literales de coma flotante son: 3.1415, -3.1E12, .1e12 y 2E-12.

De forma breve, la sintaxis es: {{mediawiki.external('dígitos')}}{{mediawiki.external('.dígitos')}}[(E|e){{mediawiki.external('(+|-)')}}dígitos]

Por ejemplo:

3.14 2345.789 .3333333333333333333

Literales de objetos

Un literal de objeto es una lista de cero o más pares de nombres de propiedades y valores asociados a dicho objeto, delimitada por llaves ({}). Usted no debe utilizar un literal de objeto al inicio de una sentencia. Esto provocaría un error o un comportamiento inesperado, debido a que una { será interpretada como el comienzo de un bloque.

El siguiente es un ejemplo de un literal de objeto. El primer elemento del objeto automovil define una propiedad, miAuto; el segundo elemento, la propiedad obtenerAuto invoca a la función (TipoAuto("Honda")); el tercer elemento, la propiedad especial usa una variable existente (Ventas).

var Ventas = "Toyota";

function TipoAuto(nombre) {
   if(nombre == "Honda")
      return nombre;
   else
      return "Lo siento, no vendemos " + nombre + ".";
}

automovil = {miAuto: "Saturn", obtenerAuto: TipoAuto("Honda"), especial: Ventas}

document.write(automovil.miAuto); // Saturn
document.write(automovil.obtenerAuto); // Honda
document.write(automovil.especial); // Toyota

Adicionalmente, usted puede usar literales de cadena o numéricos para el nombre de una propiedad o para anidar un objeto dentro de otro. El siguiente ejemplo utiliza estas opciones.

car = {manyCars: {a: "Saab", b: "Jeep"}, 7: "Mazda"}

document.write(car.manyCars.b); // Jeep
document.write(car[7]); // Mazda

Por favor, tenga en cuenta lo siguiente:

foo = {a: "alpha", 2: "two"}
document.write (foo.a)    // alpha
document.write (foo[2])   // two
//document.write (foo.2)  // Error: nos e encuentra ) después de la lista de argumentos
//document.write (foo[a]) // Error: a no ha sido definido
document.write (foo["a"]) // alpha
document.write (foo["2"]) // two

Literales de cadenas de caracteres (string)

Una cadena literal tiene cero o más caracteres encerrados entre comillas dobles (") o simples ('). Una cadena debe estar delimitada por comillas del mismo tipo, es decir, tanto las comillas simples como dobles al inicio y al final de la cadena. Los siguientes ejemplos son cadenas literales:

  • "blah"
  • 'blah'
  • "1234"
  • "una línea \n otra línea"
  • "El gato de John"

Usted puede invocar cualquiera de los métodos del objeto String (cadena) en un valor literal de cadena—JavaScript automáticamente la convierte de una cadena literal a un objeto String temporal, mediante la invocación del método, luego descarta el objeto String temporal. También se puede usar la propiedad String.length con una cadena literal:

  • "El gato de John".length

Debe usarse una cadena literal a menos que desee específicamente utilizar un objeto String. Véase:Objeto String para más detalles.

Uso de caracteres especiales en cadenas de caracteres

Además de los caracteres ordinarios, se puede también incluir caracteres especiales en las cadenas, tal como se muestra en el siguiente ejemplo.

"una línea \n otra línea"

La siguiente tabla lista los caracteres especiales que pueden usarse en cadenas JavaScript.

Caracter Significado
\b Retroceso {{mediawiki.external('Backspace')}}
\f {{mediawiki.external('Form feed')}}
\n Nueva línea
\r Retorno de carro {{mediawiki.external('Carriage return')}}
\t Tabulador {{mediawiki.external('Tab')}}
\v Tabulador vertical
\' Apóstrofe o comilla simple
\" Doble comilla
\\ Caracter Backslash (\).
\XXX El caracter de codificación Latin-1 especificado por tres dígitos octales XXX entre 0 y 377. Por ejemplo, \251 es una secuencia octal para el símbolo de derechos de copia {{mediawiki.external('copyright')}} .
\xXX El caracter de codificación Latin-1 especificado por dos dígitos hexadecimales XX entre 00 y FF. Por ejemplo, \xA9 es una secuencia hexadecimal para el símbolo de copyright.
\uXXXX El caracter Unicode especificado por cuatro dígitos hexadecimales XXXX. por ejemplo, \u00A9 es una secuencia Unicode para el símbolo de copyright. Véase Secuencia de escape Unicode.

Tabla 2.1: Caracteres especiales de JavaScript

Caracteres de escape

Para caracteres no listados en la Tabla 2.1, la contrabarra {{mediawiki.external('backslash')}} precedente es ignorada, pero su uso está obsoleto y debería ser abandonado.

Se puede insertar una comilla dentro de una cadena precediéndola por una contrabarra {{mediawiki.external('backslash')}}. Esto se conoce como escapar la comilla. Por ejemplo:

var texto = "El lee \"La Incineración de Sam McGee\" de R.W. Service."
document.write(texto)

El resultado de ello sería:

El lee "La Incineración de Sam McGee" de R.W. Service.

Para incluir el literal correspondiente a la contrabarra {{mediawiki.external('backslash')}} dentro de una cadena, deberá escapar el caracter de contrabarra {{mediawiki.external('backslash')}}. Por ejemplo, para asignar la ruta de un archivo c:\temp a una cadena, use lo siguiente:

var home = "c:\\temp"

{{template.AnteriorSiguiente("Guía JavaScript_1.5:Constantes", "Guía JavaScript 1.5:Unicode")}}

{{ wiki.languages( { "en": "en/Core_JavaScript_1.5_Guide/Literals", "fr": "fr/Guide_JavaScript_1.5/Constantes_litt\u00e9rales", "ja": "ja/Core_JavaScript_1.5_Guide/Literals", "ko": "ko/Core_JavaScript_1.5_Guide/Literals", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Litera\u0142y" } ) }}

Fuente de la revisión

<p>
</p>
<h3 name="Literales"> Literales </h3>
<p>Se utilizan los literales para representar valores en JavaScript. Estos son valores fijados, no variables, que usted <i>literalmente</i> proporciona en su script. Esta sección describe los siguientes tipos de literales:
</p>
<ul><li> <a href="es/Gu%c3%ada_JavaScript_1.5/Literales#Literales_de_colecciones_.28arrays.29">Arreglos de literales</a>
</li><li> <a href="es/Gu%c3%ada_JavaScript_1.5/Literales#Literales_booleans">Literales lógicos {{mediawiki.external('booleans')}}</a>
</li><li> <a href="es/Gu%c3%ada_JavaScript_1.5/Literales#Literales_en_punto_flotante">Literales de punto flotante</a>
</li><li> <a href="es/Gu%c3%ada_JavaScript_1.5/Literales#Literales_enteros">Literales enteros</a>
</li><li> <a href="es/Gu%c3%ada_JavaScript_1.5/Literales#Literales_de_objetos">Objetos literales</a>
</li><li> <a href="es/Gu%c3%ada_JavaScript_1.5/Literales#Literales_de_cadena_de_caracteres_.28string.29">Cadenas literales (string)</a>
</li></ul>
<h4 name="Arreglos_de_literales"> Arreglos de literales </h4>
<p>Un arreglo literal es una lista de cero o más expresiones, cada una de las cuales representa un elemento del arreglo, delimitada por corchetes ([]). Cuando crea un arreglo usando un arreglo literal, aquel será inicializado con los valores especificados como sus elementos y su longitud será el número de argumentos especificados.
</p><p>El siguiente ejemplo crea un arreglo de <code>cafés</code> con tres elementos y una longitud de tres:
</p>
<pre>cafés = ["Tueste francés", "Colombiano", "Kona"]</pre>
<p><b>Nota</b> Un arreglo literal es un tipo de objeto iniciador. Véase: el <a href="es/Gu%c3%ada_JavaScript_1.5/Crear_nuevos_objetos/Utilizando_Objetos_Iniciadores">uso de objetos iniciadores</a>.
</p><p>Si un arreglo es creado usando un literal en un script de alto nivel, JavaScript interpreta el arreglo cada vez que es evaluada la expresión que contiene el arreglo literal. Adicionalmente, un literal utilizado en una función es creado cada vez que la función es invocada.
</p><p>Los arreglos literales también son un arreglo de objetos. Véase: <a href="es/Gu%c3%ada_JavaScript_1.5/Objetos_base_predefinidos/Objeto_Array">el objeto array</a> para más detalles.
</p><p><b>Comas extra en Arreglos Literales</b>
</p><p>No tiene que especificar todos los elementos dentro de un arreglo literal. Si pone dos comas en una fila, el arreglo es creado con espacios para los elementos no especificados. El siguiente ejemplo crea el arreglo <code>pez</code>:
</p>
<pre>pez = ["León", , "Angel"]</pre>
<p>Este arreglo posee dos elementos con los valores establecidos y un elemento vacío (<code>pez{{mediawiki.external(0)}}</code> es "León", <code>pez{{mediawiki.external(1)}}</code> es <code>undefined</code> y <code>pez{{mediawiki.external(2)}}</code> es "Angel").
</p><p>Si incluye una coma al final de la lista de elementos, esta coma es ignorada. En el siguiente ejemplo, la longitud del arreglo es tres. No existe <code>miLista{{mediawiki.external(3)}}</code>. Todas las otras comas en la lista indican a un nuevo elemento. 
</p>
<div class="tip">
<p>Recuerde que se referencia al primer elemento de una lista con el valor de cero {{mediawiki.external(0)}}.
</p>
</div>
<pre>miLista = ['casa', , 'escuela', ];</pre>
<p>En el siguiente ejemplo, la longitud del arreglo es cuatro y <code>miLista{{mediawiki.external(0)}}</code> y <code>miLista{{mediawiki.external(2)}}</code> están vacíos.
</p>
<pre>miLista = [ , 'casa', , 'escuela'];</pre>
<p>En el siguiente ejemplo, la longitud del arreglo es cuatro y <code>miLista{{mediawiki.external(1)}}</code> y <code>miLista{{mediawiki.external(3)}}</code> están vacíos. Sólo la última coma es ignorada.
</p>
<pre>miLista = ['casa', , 'escuela', , ];</pre>
<h4 name="Literales_l.C3.B3gicos_booleans"> Literales lógicos booleans </h4>
<p>El tipo Boolean posee dos valores literales: <code>true</code> y <code>false</code>.
</p><p>No debe confundirse los valores primitivos Boolean <code>true</code> y <code>false</code> con los valores verdadero {{mediawiki.external('true')}} y falso {{mediawiki.external('false')}} del objeto Boolean. El objeto Boolean es un contenedor {{mediawiki.external('wrapper')}} de los tipos de datos primitivos Boolean. Véase: el <a href="es/Gu%c3%ada_JavaScript_1.5/Objetos_base_predefinidos/Objeto_boolean">objeto boolean</a> para más información.
</p>
<h4 name="Literales_enteros"> Literales enteros </h4>
<p>Los enteros pueden ser expresados en decimales (base 10), hexadecimales (base 16) y octales (base 8). Un literal entero decimal consiste de una secuencia de dígitos sin un 0 (cero) por delante. Un 0 (cero) por delante en un literal entero indica que este es un octal; Un 0x (o 0X) por delante indica que es un hexadecimal. Un entero hexadecimal puede incluir los dígitos (0-9) y las letras a-f y A-F. Los enteros octales pueden incluir sólamente los dígitos 0-7.
</p><p>Los literales enteros octales están obsoletos y han sido removidos del estandar de la ECMA-262, Edición 3. JavaScript 1.5 mantiene un soporte para ellos sólo por compatibilidad con versiones anteriores.
</p><p>Algunos ejemplos de literales enteros son: 
</p>
<pre class="eval">0, 117 y -345 (decimales, base 10)
015, 0001 y -077 (octales, base 8) 
0x1123, 0x00111 y -0xF1A7 (hexadecimales, "hex" o base 16)
</pre>
<h4 name="Literales_de_coma_flotante"> Literales de coma flotante </h4>
<p>Un literal de coma flotante puede contener las siguientes partes:
</p>
<ul><li> Un entero decimal el cual puede tener signo (precedido por "+" o "-"),
</li><li> Un punto decimal ("."),
</li><li> Una fracción (otro número decimal),
</li><li> Un exponente.
</li></ul>
<p>La parte exponencial es una "e" o "E" seguida de un entero, el cual puede tener signo (precedido por "+" o "-"). Un literal de coma flotante debe tener al menos un dígito y, o un punto decimal o una "e" (o "E").
</p><p>Algunos ejemplos de literales de coma flotante son: 3.1415, -3.1E12, .1e12 y 2E-12.
</p><p>De forma breve, la sintaxis es:
{{mediawiki.external('dígitos')}}{{mediawiki.external('.dígitos')}}[(E|e){{mediawiki.external('(+|-)')}}dígitos]
</p><p>Por ejemplo:
</p><p>3.14
2345.789
.3333333333333333333
</p>
<h4 name="Literales_de_objetos"> Literales de objetos </h4>
<p>Un literal de objeto es una lista de cero o más pares de nombres de propiedades y valores asociados a dicho objeto, delimitada por llaves ({}). Usted no debe utilizar un literal de objeto al inicio de una sentencia. Esto provocaría un error o un comportamiento inesperado, debido a que una { será interpretada como el comienzo de un bloque.
</p><p>El siguiente es un ejemplo de un literal de objeto. El primer elemento del objeto <code>automovil</code> define una propiedad, <code>miAuto</code>; el segundo elemento, la propiedad <code>obtenerAuto</code> invoca a la función <code>(TipoAuto("Honda"));</code> el tercer elemento, la propiedad <code>especial</code> usa una variable existente (<code>Ventas</code>).
</p>
<pre>var Ventas = "Toyota";

function TipoAuto(nombre) {
   if(nombre == "Honda")
      return nombre;
   else
      return "Lo siento, no vendemos " + nombre + ".";
}

automovil = {miAuto: "Saturn", obtenerAuto: TipoAuto("Honda"), especial: Ventas}

document.write(automovil.miAuto); // Saturn
document.write(automovil.obtenerAuto); // Honda
document.write(automovil.especial); // Toyota</pre>
<p>Adicionalmente, usted puede usar literales de cadena o numéricos para el nombre de una propiedad o para anidar un objeto dentro de otro. El siguiente ejemplo utiliza estas opciones.
</p>
<pre>car = {manyCars: {a: "Saab", b: "Jeep"}, 7: "Mazda"}

document.write(car.manyCars.b); // Jeep
document.write(car[7]); // Mazda
</pre>
<p>Por favor, tenga en cuenta lo siguiente:
</p>
<pre class="eval">foo = {a: "alpha", 2: "two"}
document.write (foo.a)    // alpha
document.write (foo[2])   // two
//document.write (foo.2)  // Error: nos e encuentra ) después de la lista de argumentos
//document.write (foo[a]) // Error: a no ha sido definido
document.write (foo["a"]) // alpha
document.write (foo["2"]) // two
</pre>
<h4 name="Literales_de_cadenas_de_caracteres_.28string.29"> Literales de cadenas de caracteres (string) </h4>
<p>Una cadena literal tiene cero o más caracteres encerrados entre comillas dobles (") o simples ('). Una cadena debe estar delimitada por comillas del mismo tipo, es decir, tanto las comillas simples como dobles al inicio y al final de la cadena. Los siguientes ejemplos son cadenas literales:
</p>
<ul><li> "blah"
</li><li> 'blah'
</li><li> "1234"
</li><li> "una línea \n otra línea"
</li><li> "El gato de John"
</li></ul>
<p>Usted puede invocar cualquiera de los métodos del objeto String (cadena) en un valor literal de cadena—JavaScript automáticamente la convierte de una cadena literal a un objeto String temporal, mediante la invocación del método, luego descarta el objeto String temporal. También se puede usar la propiedad <code>String.length</code> con una cadena literal:
</p>
<ul><li> "El gato de John".length
</li></ul>
<p>Debe usarse una cadena literal a menos que desee específicamente utilizar un objeto String. Véase:<a href="es/Gu%c3%ada_JavaScript_1.5/Objeto_String">Objeto String</a> para más detalles.
</p>
<h5 name="Uso_de_caracteres_especiales_en_cadenas_de_caracteres"> Uso de caracteres especiales en cadenas de caracteres </h5>
<p>Además de los caracteres ordinarios, se puede también incluir caracteres especiales en las cadenas, tal como se muestra en el siguiente ejemplo.
</p>
<pre>"una línea \n otra línea"</pre>
<p>La siguiente tabla lista los caracteres especiales que pueden usarse en cadenas JavaScript.
</p>
<table class="fullwidth-table">
<tbody><tr>
<th>Caracter</th>
<th>Significado</th>
</tr>
<tr>
<td>\b</td>
<td>Retroceso {{mediawiki.external('Backspace')}}</td>
</tr>
<tr>
<td>\f</td>
<td>{{mediawiki.external('Form feed')}}</td>
</tr>
<tr>
<td>\n</td>
<td>Nueva línea</td>
</tr>
<tr>
<td>\r</td>
<td>Retorno de carro {{mediawiki.external('Carriage return')}}</td>
</tr>
<tr>
<td>\t</td>
<td>Tabulador {{mediawiki.external('Tab')}}</td>
</tr>
<tr>
<td>\v</td>
<td>Tabulador vertical</td>
</tr>
<tr>
<td>\'</td>
<td>Apóstrofe o comilla simple</td>
</tr>
<tr>
<td>\"</td>
<td>Doble comilla</td>
</tr>
<tr>
<td>\\</td>
<td>Caracter Backslash (\).</td>
</tr>
<tr>
<td>\<i>XXX</i></td>
<td>El caracter de codificación Latin-1 especificado por tres dígitos octales <i>XXX</i> entre 0 y 377. Por ejemplo, \251 es una secuencia octal para el símbolo de derechos de copia {{mediawiki.external('copyright')}} .</td>
</tr>
<tr>
<td>\x<i>XX</i></td>
<td>El caracter de codificación Latin-1 especificado por dos dígitos hexadecimales <i>XX</i> entre 00 y FF. Por ejemplo, \xA9 es una secuencia hexadecimal para el símbolo de copyright.</td>
</tr>
<tr>
<td>\u<i>XXXX</i></td>
<td>El caracter Unicode especificado por cuatro dígitos hexadecimales <i>XXXX</i>. por ejemplo, \u00A9 es una secuencia Unicode para el símbolo de copyright. Véase <a href="es/Gu%c3%ada_JavaScript_1.5/Unicode#Secuencia_de_escape_Unicode">Secuencia de escape Unicode</a>. </td>
</tr>
</tbody></table>
<p><small><b>Tabla 2.1: Caracteres especiales de JavaScript</b></small>
</p>
<h5 name="Caracteres_de_escape"> Caracteres de escape </h5>
<p>Para caracteres no listados en la Tabla 2.1, la contrabarra {{mediawiki.external('backslash')}} precedente es ignorada, pero su uso está obsoleto y debería ser abandonado.
</p><p>Se puede insertar una comilla dentro de una cadena precediéndola por una contrabarra {{mediawiki.external('backslash')}}. Esto se conoce como <i>escapar</i> la comilla. Por ejemplo:
</p>
<pre>var texto = "El lee \"La Incineración de Sam McGee\" de R.W. Service."
document.write(texto)
</pre>
<p>El resultado de ello sería:
</p>
<pre>El lee "La Incineración de Sam McGee" de R.W. Service.
</pre>
<p>Para incluir el literal correspondiente a la contrabarra {{mediawiki.external('backslash')}} dentro de una cadena, deberá escapar el caracter de contrabarra {{mediawiki.external('backslash')}}. Por ejemplo, para asignar la ruta de un archivo <code>c:\temp</code> a una cadena, use lo siguiente:
</p>
<pre>var home = "c:\\temp"
</pre>
<p>{{template.AnteriorSiguiente("Guía JavaScript_1.5:Constantes", "Guía JavaScript 1.5:Unicode")}}
</p>{{ wiki.languages( { "en": "en/Core_JavaScript_1.5_Guide/Literals", "fr": "fr/Guide_JavaScript_1.5/Constantes_litt\u00e9rales", "ja": "ja/Core_JavaScript_1.5_Guide/Literals", "ko": "ko/Core_JavaScript_1.5_Guide/Literals", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Litera\u0142y" } ) }}
Revertir a esta revisión