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: 281453
  • Creada:
  • Creador: DSN XP
  • ¿Es la revisión actual? No
  • Comentario /* Literales de cadenas de caracteres (string) */

Contenido de la revisión

{{wiki.template('Traducción', [ "inglés", "Core JavaScript 1.5 Guide:Literals", "en" ])}}

Literales

Se usan los literales para representar valores en JavaScript. Estos son valores fijos, no variables, que literalmente provee a su script. Esta sección describe los siguientes tipos de literales:

Literales de colecciones (arrays)

Un arreglo literal es una lista encerradas entre corchetes ([]) de cero o más expresiones, cada una de las cuales representa un elemento del arreglo. Cuando usted crea un arreglo usando un arreglo literal, éste es inicializado con los valores especificados a sus elementos y su longitud es configurada de acuerdo al número de argumentos especificados.

El siguiente ejemplo crea un arreglo o colección de bebidas con tres elementos y una longitud de tres:

bebidas = ["Ron", "Vino", "Vodka"]

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 qu es evaluada la expresión que contiene el arreglo literal. Adicionalmente, un literal usado 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.

Commas extra en Arreglos Literales

Usted no tiene que especificar todos los elementos dentro de un arreglo literal. Si usted 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)}} está indefinido 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)}} se pierden o se inicializan como 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)}} se pierden. Sólo la última coma es ignorada. La coma final es opcional.

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

Literales 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 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 despreciados 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 punto flotante

Un literal de punto 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 está dada por una "e" o "E" seguida de un entero, el cual puede tener signo (precedido por "+" o "-"). Un literal de punto flotante debe tener al menos un dígito y cualquiera de los dos, un punto decimal o una "e" (o "E").

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

Brevemente la sintáxis 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 objeto literal es una lista de cero o más pares de nombres de propiedades y valores asociados a un objeto, encerrados entre llaves ({}). Usted no debe utilizar un objeto literal al inicio de una sentencia. Esto provocaría un error o que no se comporte como se espera, debido a que una { será interpretada como el comienzo de un bloque.

El siguiente es un ejemplo de un objeto literal. 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: "Saturno", 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 observe y tome nota:

foo = {a: "alpha", 2: "two"}
document.write (foo.a)    // alpha
document.write (foo[2])   // two
//document.write (foo.2)  // Error: missing ) after argument list
//document.write (foo[a]) // Error: a is not defined
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 por una doble comilla (") o una simple ('). 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 cadena {{mediawiki.external('String object')}} en un valor de cadena literal—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

YDebe usarse una cadena literal almenos 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 ocatales 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 Table 2.1, el precedente backslash es ignorado, pero su uso está despreciado y debería ser abandonado.

Se puede insertar una comilla dentro de una cadena mediante precediendola por un backslash. Esto se conoce como escapando la comilla. Por ejemplo:

var texto = "usted está leyendo la traducción de \"La Guía JavaScript 1.5\" por DSN_XP."
document.write(texto)

El resultado de ello sería:

usted está leyendo la traducción de "La Guía JavaScript 1.5" por DSN_XP.

Para incluir el literal correspondiente al backslash dentro de una cadena, deberá escapar el caracter de backslash. Por ejemplo, para signar 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>
{{wiki.template('Traducción', [ "inglés", "Core JavaScript 1.5 Guide:Literals", "en" ])}}
</p>
<h3 name="Literales"> Literales </h3>
<p>Se usan los literales para representar valores en JavaScript. Estos son valores fijos, no variables, que <i>literalmente</i> provee a 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="Literales_de_colecciones_.28arrays.29"> Literales de colecciones (arrays) </h4>
<p>Un arreglo literal es una lista encerradas entre corchetes ([]) de cero o más expresiones, cada una de las cuales representa un elemento del arreglo. Cuando usted crea un arreglo usando un arreglo literal, éste es inicializado con los valores especificados a sus elementos y su longitud es configurada de acuerdo al número de argumentos especificados.
</p><p>El siguiente ejemplo crea un arreglo o colección de <code>bebidas</code> con tres elementos y una longitud de tres:
</p>
<pre>bebidas = ["Ron", "Vino", "Vodka"]</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/Uso_de_los_iniciadores_de_objeto">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 qu es evaluada la expresión que contiene el arreglo literal. Adicionalmente, un literal usado 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_de_colecci%c3%b3n">el objeto array</a> para más detalles.
</p><p><b>Commas extra en Arreglos Literales</b>
</p><p>Usted no tiene que especificar todos los elementos dentro de un arreglo literal. Si usted 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> está <code>indefinido</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. Recuerde que se referencia al primer elemento de una lista con el valor de cero {{mediawiki.external(0)}}.
</p>
<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> se pierden o se inicializan como 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> se pierden. Sólo la última coma es ignorada. La coma final es opcional.
</p>
<pre>miLista = ['casa', , 'escuela', , ];</pre>
<h4 name="Literales_booleans"> Literales 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 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 despreciados 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_punto_flotante"> Literales de punto flotante </h4>
<p>Un literal de punto 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 está dada por una "e" o "E" seguida de un entero, el cual puede tener signo (precedido por "+" o "-"). Un literal de punto flotante debe tener al menos un dígito y cualquiera de los dos, un punto decimal o una "e" (o "E").
</p><p>Algunos ejemplos de literales de punto flotante son: 3.1415, -3.1E12, .1e12 y 2E-12.
</p><p>Brevemente la sintáxis 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 objeto literal es una lista de cero o más pares de nombres de propiedades y valores asociados a un objeto, encerrados entre llaves ({}). Usted no debe utilizar un objeto literal al inicio de una sentencia. Esto provocaría un error o que no se comporte como se espera, debido a que una { será interpretada como el comienzo de un bloque.
</p><p>El siguiente es un ejemplo de un objeto literal. 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: "Saturno", 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 observe y tome nota:
</p>
<pre class="eval">foo = {a: "alpha", 2: "two"}
document.write (foo.a)    // alpha
document.write (foo[2])   // two
//document.write (foo.2)  // Error: missing ) after argument list
//document.write (foo[a]) // Error: a is not defined
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 por una doble comilla (") o una simple ('). 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 cadena {{mediawiki.external('String object')}} en un valor de cadena literal—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>YDebe usarse una cadena literal almenos 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 ocatales <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 Table 2.1, el precedente backslash es ignorado, pero su uso está despreciado y debería ser abandonado.
</p><p>Se puede insertar una comilla dentro de una cadena mediante precediendola por un backslash. Esto se conoce como <i>escapando</i> la comilla. Por ejemplo:
</p>
<pre>var texto = "usted está leyendo la traducción de \"La Guía JavaScript 1.5\" por DSN_XP."
document.write(texto)
</pre>
<p>El resultado de ello sería:
</p>
<pre>usted está leyendo la traducción de "La Guía JavaScript 1.5" por DSN_XP.
</pre>
<p>Para incluir el literal correspondiente al backslash dentro de una cadena, deberá escapar el caracter de backslash. Por ejemplo, para signar 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