Tipos de referencia ECMAScript

Los tipos de referencia se denominan generalmente clases (class).

Este tutorial discutirá una gran cantidad de tipos de referencia predefinidos en ECMAScript.

Tipos de referencia

Los tipos de referencia se denominan generalmente clases (class), lo que significa que cuando se manejan valores de referencia, se trata de objetos.

Este tutorial discutirá una gran cantidad de tipos de referencia predefinidos en ECMAScript.

A partir de ahora, se enfocará en tipos de referencia relacionados de manera estricta con los tipos primitivos ya discutidos.

Nota:En el sentido tradicional, ECMAScript no tiene verdaderamente clases. De hecho, además de indicar que no existen clases, la palabra 'clase' no aparece en absoluto en ECMA-262. ECMAScript define 'definición de objeto', que lógicamente es equivalente a las clases en otros lenguajes de programación.

Consejo:Este tutorial utilizará el término "objeto".

Los objetos se crean con el operador new seguido del nombre del objeto que se va a instanciar. Por ejemplo, el siguiente código crea una instancia del objeto Object:

var o = new Object();

Esta sintaxis es similar al lenguaje Java, pero ECMAScript requiere usar corchetes cuando hay más de un parámetro. Si no hay parámetros, como en el siguiente código, los corchetes pueden omitirse:

var o = new Object;

Nota:Aunque los corchetes no son obligatorios, es mejor usarlos para evitar confusiones.

Consejo:Exploraremos más a fondo los objetos y su comportamiento en el capítulo sobre fundamentos de objetos.

El punto principal de esta sección es el tipo de referencia con tipos primitivos equivalentes.

Object

El objeto Object no es muy útil por sí mismo, pero antes de entender otras clases, es importante entenderlo. Porque el objeto Object en ECMAScript es similar al java.lang.Object en Java, todos los objetos en ECMAScript heredan de este objeto, y todas las propiedades y métodos del objeto Object aparecerán en otros objetos, por lo que entender el objeto Object permite entender mejor otros objetos.

El objeto Object tiene las siguientes propiedades:

constructor
Referencia (puntero) a la función que crea el objeto. Para el objeto Object, este puntero apunta a la función original Object().
Prototype
Referencia al prototipo del objeto. Para todos los objetos, se devuelve por defecto una instancia del objeto Object.

El objeto Object también tiene varios métodos:

hasOwnProperty(property)
Determina si el objeto tiene una propiedad específica. Debe especificar esta propiedad como cadena. (Por ejemplo, o.hasOwnProperty("name"))
IsPrototypeOf(object)
Determina si el objeto es el prototipo de otro objeto.
PropertyIsEnumerable
Determina si la propiedad dada puede ser enumerada con la sentencia for...in.
ToString()
Devuelve la representación de cadena original del objeto. Para el objeto Object, ECMA-262 no define este valor, por lo que diferentes implementaciones de ECMAScript pueden tener diferentes valores.
ValueOf()
Devuelve el valor original más adecuado para el objeto. Para muchos objetos, el valor devuelto por este método es idéntico al de ToString().

Notas:Cada propiedad y método enumerados anteriormente serán sobrescritos por otros objetos.

Objeto Boolean

El objeto Boolean es un tipo de referencia del tipo Boolean original.

Para crear un objeto Boolean, solo se necesita pasar un valor Boolean como parámetro:

var oBooleanObject = new Boolean(true);

El objeto Boolean sobrescribe el método ValueOf() del objeto Object, devolviendo el valor original, es decir, true y false. El método ToString() también se sobrescribe, devolviendo la cadena "true" o "false".

Lamentablemente, en ECMAScript se utiliza poco el objeto Boolean, incluso cuando se usa, es difícil de entender.

Los problemas suelen aparecer cuando se utiliza el objeto Boolean en expresiones Booleanas. Por ejemplo:

var oFalseObject = new Boolean(false);
var bResult = oFalseObject && true; // Sale true

En este código, se crea un objeto Boolean con el valor false. Luego, se opera AND con el valor original true. El resultado de AND entre false y true en operaciones Booleanas es false. Sin embargo, en esta línea de código, se calcula oFalseObject, no su valor false.

Como se discutió anteriormente, en expresiones Booleanas, todos los objetos se convierten automáticamente en true, por lo que el valor de oFalseObject es true. Luego true se opera AND con true, el resultado es true.

Nota:Aunque debes entender la disponibilidad del objeto Boolean, es mejor usar valores primitivos de Boolean para evitar los problemas mencionados en esta sección.

Ver

Para obtener más información sobre el objeto Boolean, visita Manual de Referencia del Objeto Booleano de JavaScript.

Objeto Number

Como podrías esperar, el objeto Number es un tipo de referencia del tipo Number original. Para crear un objeto Number, utiliza el siguiente código:

var oNumberObject = new Number(68);

Deberías haber reconocido el objeto Number mencionado en la sección anterior de este capítulo, cuando se discutieron los valores especiales (como Number.MAX_VALUE). Todas las propiedades especiales son propiedades estáticas del objeto Number.

Para obtener el valor original del objeto Number, solo se necesita usar el método valueOf():

var iNumber = oNumberObject.valueOf();

Claro, la clase Number también tiene el método toString(), que se ha discutido en detalle en la sección sobre conversión de tipos.

Además de los métodos estándar heredados del objeto Object, el objeto Number tiene varios métodos específicos para el manejo de números.

Método toFixed()

El método toFixed() devuelve la representación de cadena de un número con un número específico de dígitos decimales. Por ejemplo:

var oNumberObject = new Number(68);
alert(oNumberObject.toFixed(2));  //Salida: "68.00"

En este caso, el parámetro del método toFixed() es 2, lo que indica que se deben mostrar dos decimales. Este método devuelve "68.00", los dígitos en blanco se rellenan con 0. Este método es muy útil para aplicaciones de procesamiento de moneda. El método toFixed() puede representar números con 0 a 20 dígitos decimales, los valores fuera de este rango generan un error.

Método toExponential()

Otro método relacionado con la formateo de números es toExponential(), que devuelve la representación de cadena de un número en forma de notación científica.

Del mismo modo que el método toFixed(), el método toExponential() también tiene un parámetro que especifica el número de dígitos decimales a salida. Por ejemplo:

var oNumberObject = new Number(68);
alert(oNumberObject.toExponential(1));  //Salida: "6.8e+1"

El resultado de este código es "6.8e+1", como se explicó anteriormente, representa 6.8x101. El problema es, ¿qué hacer si no se sabe qué forma (forma predeterminada o forma exponencial) usar para representar el número? Se puede usar el método toPrecision().

Método toPrecision()

El método toPrecision() devuelve la forma predeterminada o la forma exponencial de un número según la forma más significativa. Tiene un parámetro, que es el número total de dígitos utilizados para representar el número (sin incluir la parte exponencial). Por ejemplo,

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(1));  //Salida: "7e+1"

La tarea de este código es representar el número 68 con un solo dígito, el resultado es "7e+1", representado de otra manera es 70. De hecho, el método toPrecision() redondea los números. Sin embargo, si se representa a 68 con 2 dígitos, es mucho más fácil:

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(2));  //Salida: "68"

Claro, el resultado es "68", porque es la representación exacta de ese número. Pero, ¿qué pasa si se especifican más dígitos de los necesarios?

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(3));  // salida "68.0"

En este caso, toPrecision(3) es equivalente a toFixed(1), y la salida es "68.0".

Los métodos toFixed(), toExponential() y toPrecision() realizan operaciones de redondeo para representar correctamente un número con el número correcto de dígitos decimales.

Consejo:Al igual que el objeto Boolean, el objeto Number también es importante, pero se debe usar este objeto lo menos posible para evitar problemas potenciales. Siempre que sea posible, utilice la representación primitiva de los números.

Ver

Para obtener más información sobre el objeto Number, visite Manual de Referencia del Objeto Number de JavaScript.

Objeto String

El objeto String es la representación del tipo primitivo String, que se crea de la siguiente manera:

var oStringObject = new String("hello world");

Los métodos valueOf() y toString() del objeto String devuelven el valor original del tipo String:

alert(oStringObject.valueOf() == oStringObject.toString());	// salida "true"

Si ejecuta este código, la salida es "true", lo que indica que estos valores realmente son iguales.

Notas:El objeto String es uno de los tipos de referencia más complejos en ECMAScript. Al igual que, el enfoque de esta sección es solo la funcionalidad básica de String. Para más funciones avanzadas, consulte los capítulos relacionados de este tutorial o revise Manual de Referencia del Objeto String de JavaScript.

Propiedad length

El objeto String tiene la propiedad length, que es el número de caracteres en la cadena:

var oStringObject = new String("hello world");
alert(oStringObject.length);	// salida "11"

Este ejemplo sale "11", es decir, el número de caracteres en "hello world". Nota, incluso si la cadena contiene caracteres de doble byte (en comparación con los caracteres ASCII, que solo ocupan un byte), cada carácter se cuenta como uno.

charAt() y charCodeAt() métodos

El objeto String también tiene una gran cantidad de métodos.

Primero, los métodos charAt() y charCodeAt() acceden a caracteres individuales en una cadena. Ambos métodos tienen un parámetro, que es la posición del carácter a operar.

charAt() método devuelve una cadena que contiene el carácter en la posición especificada:

var oStringObject = new String("hello world");
alert(oStringObject.charAt(1));	// salida "e"

En la cadena "hola mundo", el carácter en la posición 1 es "e" En la sección "Tipos de datos primitivos ECMAScript", se mencionó que la posición del primer carácter es 0, la posición del segundo carácter es 1, y así sucesivamente. Por lo tanto, el retorno de charAt(1) es "e".

Si lo que se desea no es el carácter, sino el código de carácter, se puede llamar al método charCodeAt():

var oStringObject = new String("hello world");
alert(oStringObject.charCodeAt(1)); // salida "101"

Este ejemplo devuelve "101", que es el código de carácter de la letra minúscula "e".

El método concat()

A continuación, se encuentra el método concat(), que se utiliza para conectar una o más cadenas al valor original de un objeto String. Este método retorna el valor original de String, manteniendo inalterado el objeto String:

var oStringObject = new String("hola ");
var sResult = oStringObject.concat("world");
alert(sResult); // salida "hola mundo"
alert(oStringObject); // salida "hola "

En este fragmento de código, el método concat() retorna "hola mundo", mientras que el objeto String sigue almacenando "hola ". Por esta razón, es más común usar el signo más (+) para conectar cadenas, ya que esta forma indica el comportamiento real:

var oStringObject = new String("hola ");
var sResult = oStringObject + "world";
alert(sResult); // salida "hola mundo"
alert(oStringObject); // salida "hola "

Los métodos indexOf() y lastIndexOf()

Hasta ahora, se han discutido métodos para conectar cadenas, y métodos para acceder a caracteres individuales en una cadena. Sin embargo, si no se puede determinar si realmente existe un carácter en una cadena, ¿qué método debe llamarse? En este caso, se puede llamar a los métodos indexOf() y lastIndexOf().

Los métodos indexOf() y lastIndexOf() siempre retornan la posición de la subcadena en otra cadena especificada, si no encuentra la subcadena, devuelve -1.

La diferencia entre estos dos métodos radica en que indexOf() comienza a buscar la subcadena en el principio (posición 0) de la cadena, mientras que lastIndexOf() comienza a buscar desde el final de la cadena. Por ejemplo:

var oStringObject = new String("hola mundo!");
alert(oStringObject.indexOf("o"));		//Se salida "4"
alert(oStringObject.lastIndexOf("o"));	//Se salida "7"

Aquí, la primera cadena "o" aparece en la posición 4, es decir, en la "o" de "hello"; la última cadena "o" aparece en la posición 7, es decir, en la "o" de "world". Si la cadena solo contiene una cadena "o", entonces las posiciones devueltas por indexOf() y lastIndexOf() son las mismas.

Método localeCompare()

El siguiente método es localeCompare(), que ordena las cadenas. Este método tiene un parámetro - la cadena a comparar, y devuelve uno de los siguientes tres valores:

  • Si el objeto String se encuentra antes de la cadena especificada en los parámetros alfabéticamente, se devuelve un número negativo.
  • Si el objeto String es igual a la cadena especificada en los parámetros, se devuelve 0
  • Si el objeto String se encuentra después de la cadena especificada en los parámetros alfabéticamente, se devuelve un número positivo.

Notas:Si el valor devuelto es negativo, lo más común es -1, aunque el valor real está determinado por la implementación. Si el valor devuelto es positivo, al igual que en el caso anterior, lo más común es 1, aunque el valor real está determinado por la implementación.

El siguiente es un ejemplo:

var oStringObject = new String("yellow");
alert(oStringObject.localeCompare("brick"));		//Se salida "1"
alert(oStringObject.localeCompare("yellow"));		//Se salida "0"
alert(oStringObject.localeCompare("zoo"));		//Se salida "-1"

En este código, la cadena "yellow" se compara con 3 valores, es decir, "brick", "yellow" y "zoo". Dado que se ordenan alfabéticamente, "yellow" está después de "brick", por lo que localeCompare() devuelve 1; "yellow" es igual a "yellow", por lo que localeCompare() devuelve 0; "zoo" está después de "yellow", localeCompare() devuelve -1. Vamos a repetirlo una vez más, ya que el valor devuelto está determinado por la implementación, es mejor llamar al método localeCompare() de la siguiente manera:

var oStringObject1 = new String("amarillo");
var oStringObject2 = new String("ladrillo");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " viene antes de " + oStringObject2);
}
  alert(oStringObject1 + " viene después de " + oStringObject2);
}
  alert("Las dos cadenas son iguales");
}

Con esta estructura, se puede garantizar que este código se ejecute correctamente en todas las implementaciones.

Lo único especial del método localeCompare() es que el entorno regional (locale, que incluye tanto el país/región como el idioma) especifica exactamente cómo se ejecuta este método. En Estados Unidos, el idioma inglés es el idioma estándar de la implementación ECMAScript, y localeCompare() es sensible a mayúsculas y minúsculas, donde las letras mayúsculas se sitúan después de las minúsculas en el orden alfabético. Sin embargo, en otras regiones, las cosas pueden no ser así.

slice() y substring()

ECMAScript proporciona dos métodos para crear valores de cadena a partir de subcadenas, es decir, slice() y substring(). Ambos métodos devuelven subcadenas de la cadena a procesar, y aceptan uno o dos parámetros. El primer parámetro es la posición de inicio de la subcadena que se desea obtener, y el segundo parámetro (si se utiliza) es la posición de finalización de la subcadena antes de la que se debe obtener (es decir, el carácter en la posición de finalización no se incluye en el valor devuelto). Si se omite el segundo parámetro, la posición de finalización se establece por defecto en la longitud de la cadena.

Al igual que el método concat(), los métodos slice() y substring() no modifican el valor propio del objeto String. Solo devuelven el valor original del String, manteniendo inalterado el objeto String.

var oStringObject = new String("hello world");
alert(oStringObject.slice("3")); // Sale "lo world"
alert(oStringObject.substring("3")); // Sale "lo world"
alert(oStringObject.slice("3", "7")); // Sale "lo w"
alert(oStringObject.substring("3", "7")); // Sale "lo w"

En este ejemplo, el uso de slice() y substring() es idéntico y también devuelven el mismo valor. Cuando solo se especifica el parámetro 3, ambas métodos devuelven "lo world", ya que el segundo "l" de "hello" está en la posición 3. Cuando se especifican dos parámetros "3" y "7", ambas métodos devuelven "lo w" (la letra "o" de "world" está en la posición 7, por lo que no se incluye en el resultado).

¿Por qué hay dos métodos con funcionalidades completamente iguales? En realidad, estos métodos no son completamente iguales, aunque solo difieren en la forma en que manejan los parámetros negativos.

Para parámetros negativos, el método slice() suma el parámetro a la longitud de la cadena, mientras que substring() lo trata como 0 (es decir, lo ignora). Por ejemplo:

var oStringObject = new String("hello world");
alert(oStringObject.slice("-3")); // Sale "rld"
alert(oStringObject.substring("-3")); // Sale "hello world"
alert(oStringObject.slice("3, -4")); // Sale "lo w"
alert(oStringObject.substring("3, -4")); // Sale "hel"

De esta manera, se puede ver la principal diferencia entre los métodos slice() y substring().

Cuando solo se especifica el parámetro -3, slice() devuelve "rld", substring() devuelve "hello world". Esto se debe a que para la cadena "hello world", slice("-3") se convierte en slice("8"), y substring("-3") se convierte en substring("0").

Del mismo modo, al usar los parámetros 3 y -4, la diferencia es clara. slice() se convertirá en slice(3, 7), como en el ejemplo anterior, regresando "lo w". Mientras que el método substring() interpretará los dos parámetros como substring(3, 0), que es substring(0, 3), ya que substring() siempre toma el número más pequeño como posición de inicio y el número más grande como posición de finalización. Por lo tanto, substring("3, -4") regresará "hel". La última línea de código se utiliza para explicar cómo usar estos métodos.

toLowerCase(), toLocaleLowerCase(), toUpperCase() y toLocaleUpperCase()

El último conjunto de métodos que se discutirá involucra la conversión de mayúsculas y minúsculas. Hay 4 métodos para realizar conversiones de mayúsculas y minúsculas, es decir

  • toLowerCase()
  • toLocaleLowerCase()
  • toUpperCase()
  • toLocaleUpperCase()

Como sugiere el nombre, los primeros dos métodos se utilizan para convertir una cadena a minúsculas, y los últimos dos métodos se utilizan para convertir una cadena a mayúsculas.

Los métodos toLowerCase() y toUpperCase() son originales y se implementan a partir de los métodos idénticos en java.lang.String.

Las métodos toLocaleLowerCase() y toLocaleUpperCase() se implementan basándose en una región específica (como con el método localeCompare()). En muchas regiones, los métodos específicos de la región son idénticos a los métodos genéricos. Sin embargo, algunos idiomas aplican reglas específicas de conversión de mayúsculas y minúsculas para Unicode (por ejemplo, el turco), por lo que es necesario usar métodos específicos de la región para realizar conversiones correctas.

var oStringObject = new String("Hello World");
alert(oStringObject.toLocaleUpperCase());	// muestra "HELLO WORLD"
alert(oStringObject.toUpperCase());		// muestra "HELLO WORLD"
alert(oStringObject.toLocaleLowerCase());	// muestra "hello world"
alert(oStringObject.toLowerCase()); // Salida "hello world"

En este código,toUpperCase() y toLocaleUpperCase() ambos salen "HELLO WORLD", ytoLowerCase() y toLocaleLowerCase() ambos salen "hello world". Generalmente, si no se sabe en qué codificación se ejecuta un lenguaje, es más seguro usar métodos específicos de región.

Consejo:Recuerde, todas las propiedades y métodos del objeto String se pueden aplicar a los valores String originales, ya que son pseudoobjetos.

Operador instanceof

Al usar el operador typeof con tipos de referencia almacenados, se produce un problema, ya que independientemente de qué tipo de objeto se refiera, siempre devuelve "object". ECMAScript introdujo otro operador Java, instanceof, para resolver este problema.

El operador instanceof es similar al operador typeof, se utiliza para identificar el tipo de objeto que se está procesando. A diferencia del método typeof, el método instanceof requiere que el desarrollador confirme explícitamente que el objeto es de un tipo específico. Por ejemplo:

var oStringObject = new String("hello world");
alert(oStringObject instanceof String); // Salida "true"

Este código pregunta: "¿Es el objeto oStringObject una instancia del objeto String?" El objeto oStringObject es efectivamente una instancia del objeto String, por lo que el resultado es "true". Aunque no es tan flexible como el método typeof, el método instanceof es muy útil cuando el método typeof devuelve "object".