Diferencia entre revisiones de «Objetos en JavaScript»

De Manuais Informática - IES San Clemente.
Ir a la navegación Ir a la búsqueda
(Clase String)
(Clase Number)
(No se muestran 14 ediciones intermedias del mismo usuario)
Línea 378: Línea 378:
 
* '''Propiedades y métodos del objeto String.'''
 
* '''Propiedades y métodos del objeto String.'''
 
: Para crear un objeto String lo podremos hacer de la siguiente forma:
 
: Para crear un objeto String lo podremos hacer de la siguiente forma:
<source lang="javascript">
+
: <source lang="javascript">
 
var  miCadena = new  String("texto de la cadena");
 
var  miCadena = new  String("texto de la cadena");
  
Línea 391: Línea 391:
  
 
: '''Propiedades del objeto String'''
 
: '''Propiedades del objeto String'''
: {| border="1" cellspacing="0" cellpadding="2" | Propiedades del objeto String
+
: {| border="1" cellspacing="0" cellpadding="2"
 
 
 
! style="background:#ffdead;" | Propiedad
 
! style="background:#ffdead;" | Propiedad
 
! style="background:#ffdead;" | Descripción
 
! style="background:#ffdead;" | Descripción
Línea 400: Línea 399:
 
|}
 
|}
  
Métodos del objeto String
+
: '''Métodos del objeto String'''
Métodos
+
: {| border="1" cellspacing="0" cellpadding="2"
Descripción
+
! style="background:#ffdead;" | Método
charAt()
+
! style="background:#ffdead;" | Descripción
Devuelve el carácter especificado por la posición que se indica entre paréntesis.
+
|-
charCodeAt()
+
| charAt()
Devuelve el Unicode del carácter especificado por la posición que se indica entre paréntesis.
+
| Devuelve el carácter especificado por la posición que se indica entre paréntesis.
concat()
+
|-
Une una o más cadenas y devuelve el resultado de esa unión.
+
| charCodeAt()
fromCharCode()
+
| Devuelve el Unicode del carácter especificado por la posición que se indica entre paréntesis.
Convierte valores Unicode a caracteres.
+
|-
indexOf()
+
| concat()
Devuelve la posición de la primera ocurrencia del carácter buscado en la cadena.
+
| Une una o más cadenas y devuelve el resultado de esa unión.
lastIndexOf()
+
|-
Devuelve la posición de la última ocurrencia del carácter buscado en la cadena.
+
| fromCharCode()
match()
+
| Convierte valores Unicode a caracteres.
Busca una coincidencia entre una expresión regular y una cadena y devuelve las coincidencias o null si no ha encontrado nada.
+
|-
replace()
+
| indexOf()
Busca una subcadena en la cadena y la reemplaza por la nueva cadena especificada.
+
| Devuelve la posición de la primera ocurrencia del carácter buscado en la cadena.
search()
+
|-
Busca una subcadena en la cadena y devuelve la posición dónde se encontró.
+
| lastIndexOf()
slice()
+
| Devuelve la posición de la última ocurrencia del carácter buscado en la cadena.
Extrae una parte de la cadena y devuelve una nueva cadena.
+
|-
split()
+
| match()
Divide una cadena en un array de subcadenas.
+
| Busca una coincidencia entre una expresión regular y una cadena y devuelve las coincidencias o null si no ha encontrado nada.
substr()
+
|-
Extrae los caracteres de una cadena, comenzando en una determinada posición y con el número de caracteres indicado.
+
| replace()
substring()
+
| Busca una subcadena en la cadena y la reemplaza por la nueva cadena especificada.
Extrae los caracteres de una cadena entre dos índices especificados.
+
|-
toLowerCase()
+
| search()
Convierte una cadena en minúsculas.
+
| Busca una subcadena en la cadena y devuelve la posición dónde se encontró.
toUpperCase()
+
|-
Convierte una cadena en mayúsculas.
+
| slice()
 +
| Extrae una parte de la cadena y devuelve una nueva cadena.
 +
|-
 +
| split()
 +
| Divide una cadena en un array de subcadenas.
 +
|-
 +
| substr()
 +
| Extrae los caracteres de una cadena, comenzando en una determinada posición y con el número de caracteres indicado.
 +
|-
 +
| substring()
 +
| Extrae los caracteres de una cadena entre dos índices especificados.
 +
|-
 +
| toLowerCase()
 +
| Convierte una cadena en minúsculas.
 +
|-
 +
| toUpperCase()
 +
| Convierte una cadena en mayúsculas.
 +
|-
 +
|}
  
Ejemplos de uso:
+
: Ejemplos de uso:
 +
: <source lang="javascript">
 
var cadena="El parapente es un deporte de riesgo medio";
 
var cadena="El parapente es un deporte de riesgo medio";
  
Línea 442: Línea 460:
 
document.write(cadena.indexOf('pente')+ "<br/>");
 
document.write(cadena.indexOf('pente')+ "<br/>");
 
document.write(cadena.substring(3,16)+ "<br/>");
 
document.write(cadena.substring(3,16)+ "<br/>");
 +
</source>
 +
 +
=== Clase Boolean ===
 +
El objeto '''Boolean''' se utiliza para convertir un valor no Booleano, a un valor Booleano (''true'' o ''false'').
 +
 +
'''Propiedades del objeto Boolean:'''
 +
{| border="1" cellspacing="0" cellpadding="2"
 +
 +
! style="background:#ffdead;" | Propiedad
 +
! style="background:#ffdead;" | Descripción
 +
|-
 +
| Constructor
 +
| Devuelve la función que creó el objeto Boolean.
 +
|-
 +
| Prototype
 +
| Te permitirá añadir propiedades y métodos a un objeto.
 +
|}
 +
 +
'''Métodos del objeto Boolean:'''
 +
{| border="1" cellspacing="0" cellpadding="2"
 +
 +
! style="background:#ffdead;" | Método
 +
! style="background:#ffdead;" | Descripción
 +
|-
 +
| toString()
 +
|Convierte un valor Boolean a una cadena y devuelve el resultado.
 +
|-
 +
| valueOf()
 +
|Devuelve el valor primitivo de un objeto Boolean.
 +
|}
 +
 +
Algunos ejemplos de uso:
 +
<source lang="javascript">
 +
let bool = new Boolean(1);
 +
document.write(bool.toString());
 +
document.write(bool.valueOf());
 +
</source>
 +
 +
=== Clase Number ===
 +
El objeto '''Number''' se usa muy raramente, ya que para la mayor parte de los casos, JavaScript satisface las necesidades del día a día con los valores numéricos que almacenamos en variables. Pero el objeto ''Number'' contiene alguna información y capacidades muy interesantes para programadores más serios.
 +
 +
Lo primero, es que el objeto ''Number'' contiene propiedades que nos indican el rango de números soportados en el lenguaje. El número más alto es  1.79E<sup>+308</sup>; el número más bajo es  2.22E<sup>-308</sup>. Cualquier número mayor que el número más alto, será considerado como infinito positivo, y si es más pequeño que el número más bajo, será considerado infinito negativo.
 +
 +
Los números y sus valores están definidos internamente en JavaScript, como valores de doble precisión y de 64 bits.
 +
 +
El objeto ''Number'', es un objeto envoltorio para valores numéricos primitivos.
 +
 +
Los objetos ''Number'' son creados con '''new Number()'''.
 +
 +
'''Propiedades del objeto Number:'''
 +
Propiedad
 +
Descripción
 +
constructor
 +
Devuelve la función que creó el objeto Number.
 +
MAX_VALUE
 +
Devuelve el número más alto disponible en JavaScript.
 +
MIN_VALUE
 +
Devuelve el número más pequeño disponible en JavaScript.
 +
NEGATIVE_INFINITY
 +
Representa a infinito negativo (se devuelve en caso de overflow).
 +
POSITIVE_INFINITY
 +
Representa a infinito positivo  (se devuelve en caso de overflow).
 +
prototype
 +
Permite añadir nuestras propias propiedades y métodos a un objeto.
 +
 +
Métodos del objeto Number:
 +
Método
 +
Descripción
 +
toExponential(x)
 +
Convierte un número a su notación exponencial.
 +
toFixed(x)
 +
Formatea un número con x digitos decimales después del punto decimal.
 +
toPrecision(x)
 +
Formatea un número a la longitud x.
 +
toString()
 +
Convierte un objeto Number en una cadena.
 +
    • Si se pone 2 como parámetro se mostrará el número en binario.
 +
    • Si se pone 8 como parámetro se mostrará el número en octal.
 +
    • Si se pone 16 como parámetro se mostrará el número en hexadecimal.
 +
valueOf()
 +
Devuelve el valor primitivo de un objeto Number.
 +
 +
Algunos ejemplos de uso:
 +
var num = new Number(13.3714);
 +
document.write(num.toPrecision(3)+"<br />");
 +
document.write(num.toFixed(1)+"<br />");
 +
document.write(num.toString(2)+"<br />");
 +
document.write(num.toString(8)+"<br />");
 +
document.write(num.toString(16)+"<br />");
 +
document.write(Number.MIN_VALUE);
 +
document.write(Number.MAX_VALUE);
  
  
 
[[JavaScript|Volver]]
 
[[JavaScript|Volver]]

Revisión del 00:01 31 oct 2020

Los objetos son estructuras de información capaces de contener propiedades y métodos. ECMA-262 define objeto como "una colección sin ordenar de propiedades que contienen un valor primitivo, un objeto o una función".

Todo objeto se define mediante una clase, que puede definirse como "la receta del objeto". Cuando un programa utiliza una clase para crear un objeto, el objeto resultante se denomina instancia de la clase.

  • Objetos nativos
Son cualquier objeto proporcionado por una implementación de JavaScript independiente del entorno anfitrión. Son los siguientes: object, function, array, string, boolean, number, date, regexp, error, evalerror, rangeerror, referenceerror, syntaxerror, typeerror, urierror.
  • Objetos incorporados
Son cualquier objeto proporcionado por una implementación de JavaScript, independientemente del entorno anfitrión, que está presente al iniciarse la ejecución de un programa de JavaScript. Son los siguientes: global, math.
  • Objetos anfitrión

Cualquier objeto que no sea nativo se considera anfitrión. Todos los objetos BOM y DOM se consideran objetos anfitrión y se analizarán en un apartado posterior.

Definir clases y objetos

La posibilidad de utilizar objetos predefinidos es sólo una parte de cualquier lenguaje orientado a objetos. Las verdaderas prestaciones se obtienen al crear clases y objetos propios para usos específicos.

  • La clase
En JavaScript las clases son funciones, para comprobarlo veremos luego un ejemplo donde definimos una clase "Coche" utilizando la expresión function y la expresión class.
  • El objeto
Para crear un nuevo objeto se utiliza la declaración new, asignando el resultado (que es de tipo obj) a una variable para tener acceso más tarde. En el siguiente ejemplo se define, como ya se dijo, una clase llamada "Coche" y una instancia llamada "coche1".
  • El constructor
El constructor es llamado en el momento de la creación de la instancia (el momento en que se crea la instancia del objeto). El constructor es un método de la clase. En JavaScript no hay necesidad de definir explícitamente un método constructor. Cada acción declarada en la clase es ejecutada en el momento de la creación de la instancia.
El constructor se usa para establecer las propiedades del objeto o para llamar a los métodos para preparar el objeto para su uso.
  • Las propiedades
Las propiedades son variables contenidas en la clase, cada instancia del objeto tiene dichas propiedades. Las propiedades deben establecerse a la propiedad prototipo de la clase, para que la herencia funcione correctamente.
Para trabajar con propiedades dentro de la clase se utiliza la palabra reservada this, que se refiere al objeto actual. El acceso (lectura o escritura) a una propiedad desde fuera de la clase se hace con la sintaxis: NombreDeLaInstancia.Propiedad (desde dentro de la clase la sintaxis es this.Propiedad).
En el siguiente ejemplo definimos varias propiedades de la clase Coche.
  • Los métodos
Los métodos siguen la misma lógica que las propiedades, la diferencia es que son funciones y se definen como funciones. Llamar a un método es similar a acceder a una propiedad, pero se agrega () al final del nombre del método, pero, posiblemente vaya acompañado de argumentos.
En el siguiente ejemplo se define y utiliza el método mostrarColor() para la clase Coche, en él se define una clase Coche con varias propiedades y un método. Luego se crea un objeto coche1 a partir de una instancia de ella.

Definimos la clase "Coche" con la expresión function

	function Coche(sColor, iPuertas, iKmpl) {
		this.color = sColor; 			//Color coche
		this.puertas = iPuertas; 		//Número de puertas coche
		this.kmpl = iKmpl; 			//Kms recorridos por litro
		this.conductores = new Array(); //Lista conductores coche
	}

	Coche.prototype.mostrarColor = function() {
		alert(this.color);
	}

	//Inicializar un coche de prueba
	var coche1 = new Coche("rojo", 4, 20);
	coche1.conductores = ["Andrea", "Ana", "Miguel"];
	//Leemos una propiedad
	console.log("El coche es de color " + coche1.color);
	console.log("Lo conducen : " + coche1.conductores.join(", "));
	//Llamamos al método
	coche1.mostrarColor();

Definimos la clase “Coche” con la expresión class

Las clases de javascript, introducidas en ECMAScript 2015, son una mejora sintáctica sobre la herencia basada en prototipos de JavaScript. La sintaxis de las clases no introduce un nuevo modelo de herencia orientada a objetos en JavaScript. Las clases de JavaScript proveen una sintaxis mucho más clara y simple para crear objetos y definir la herencia.

Las clases son "funciones especiales", teniendo la sintaxis de una clase dos componentes: expresiones de clases y declaraciones de clases.

Para declarar una clase, se utiliza la palabra reservada class y un nombre para la clase, que en el siguiente ejemplo será "Coche".

Una importante diferencia entre las declaraciones de funciones y las declaraciones de clases es que las declaraciones de funciones son alojadas (hoisted) y las declaraciones de clases no lo son. Es decir, en primer lugar se necesita declarar la clase y luego acceder a ella, de otro modo el ejemplo de código siguiente arrojará un ReferenceError:

	class Coche {
		constructor (sColor, iPuertas, iKmpl) {
		  this.color = sColor; //Color coche
		  this.puertas = iPuertas; //Número de puertas coche
		  this.kmpl = iKmpl; 	//Kms recorridos por litro consumido
		  this.conductores = new Array(); //Lista conductores coche
		}
		//Método
		mostrarColor() {
		  alert(this.color);
		}
	}

	//Inicializar un coche
	var coche1 = new Coche("rojo", 4, 20);
	coche1.conductores = ["Andrea", "Ana", "Miguel"];
	//Leemos una propiedad
	console.log("El coche es de color " + coche1.color);
	console.log("Lo conducen : " + coche1.conductores.join(", "));
	//Llamamos al método
	coche1.mostrarColor();

Anular referencias a objetos

En JavaScript no se puede acceder a la representación física del objeto, sólo a referencias del mismo. Saber también que JavaScript cuenta con una rutina de recolección de elementos sin utilizar, por lo que no es necesario destruir específicamente los objetos para liberar memoria. Cuando no quedan referencias a un objeto, se dice que se han anulado las referencias al mismo. Luego, al ejecutar el recolector de elementos sin utilizar, todos los objetos con referencias anuladas se destruyen.

Pueden anularse las referencias a objetos de forma manual, si se establecen todas en null. Es interesante realizar esta acción con objetos sin utilizar para así liberar memoria.

var miObjeto = new Object;
//Al terminar de trabajar con el objeto
miObjeto = null;

Los getters y los setters

Podemos ver un nuevo ejemplo donde se define la clase Vec que representa un vector en dos dimensiones. Esta clase tiene dos propiedades x e y de tipo float. También tendrá dos métodos, sumar y restar, que pide otro vector como parámetro y devuelve un nuevo vector que es "suma" o "resta" de los dos. Por último, también debe tener una tercera propiedad, pero de tipo "getter" que calcule la longitud del vector (distancia hasta el punto (0,0)) == sqrt(x*x + y*y)

    class Vec {
      constructor (fX, fY) {
        this.x = fX;
        this.y = fY;
      }
      //Propiedad getter
      get longitud() {
        return Math.sqrt(this.x*this.x + this.y*this.y);
      }
      //Métodos
      //Sumar Vectores
      sumarVec(otroVec) {
        var sumaX = this.x + otroVec.x;
        var sumaY = this.y + otroVec.y;
        var vectorSuma = new Vec(sumaX, sumaY);
        return vectorSuma;
      }

      //Restar Vectores
      restarVec(otroVec) {
        var restaX = this.x - otroVec.x;
        var restaY = this.y - otroVec.y;
        var vectorResta = new Vec(restaX, restaY);
        return vectorResta;
      }
    }
    //Comprobamos que todo va bien
    var vector1 = new Vec(1,1);
    var vector2 = new Vec(10,10);
    console.log(vector1);
	//longitud es una propiedad no una función
      console.log(vector1.longitud); 

    var vSuma = vector1.sumarVec(vector2);
    console.log(vSuma);
    console.log(vSuma.longitud);

    var vResta = vector1.restarVec(vector2);
    console.log(vResta);
    console.log(vResta.longitud);

Herencia

La herencia es una manera de crear una clase como una versión especializada de una o más clases (JavaScript sólo permite herencia simple). La clase "especializada" comúnmente se llama hija o secundaria, y la otra clase se le llama padre o primaria. En JavaScript la herencia se logra mediante la asignación de una instancia de la clase primaria a la clase secundaria, y luego se hace la especialización.

Veamos un ejemplo donde se definen formas geométricas.

Existen dos tipos de formas: las elipses (con forma redonda) y los polígonos (con un número concreto de lados). Los círculos son un tipo de elipse con un centro; los triángulos, rectángulos y pentágonos son tipos de polígonos con distintos lados. Un cuadrado es un rectángulo con sus cuatro lados iguales. De este modo podemos definir una relación de herencia perfecta.
El diagrama UML podría ser el siguiente:
En este ejemplo, sólo nos centraremos en la creación de la clase Poligono y de las subclases Triangulo y Rectangulo.
La clase Poligono tendrá la propiedad lados y el método getArea().
//Definición de la clase Poligono
class Poligono {
	constructor(iLados) {
		this.lados = iLados; }
	//Métodos
	getArea() { return 0; }
}
Vemos que el método getArea() devuelve 0 porque es simplemente un marcador de posición de los métodos de las posteriores subclases que se vayan a crear.
Ahora creamos la subclase Triangulo. Esta clase tiene tres lados, de forma que esta clase tiene que reemplazar la propiedad lados de la clase Poligono y establecerla en 3. También es necesario reemplazar getArea() para que utilice la fórmula del área del triángulo, que es "1/2 x base x altura".
El método obtendrá esos dos datos de las dos propiedades base y altura.
Así, el código de la clase Triangulo será el siguiente:
//Definición de la clase Triangulo subclase de Poligono
class Triangulo extends Poligono {
	constructor(iBase, iAltura, iLados) {
		super(iLados);
		this.lados = 3;
		this.base = iBase;
		this.altura = iAltura; }
	getArea() { return 0.5 * this.base * this.altura; }
}
De igual modo, definimos el código de la clase Rectangulo:
//Definición de la clase Rectangulo
class Rectangulo extends Poligono {
    constructor (iLargo, iAncho, iLados) {
        super (iLados);
        this.lados = 4;
        this.largo = iLargo;
        this.ancho = iAncho; }
    getArea() { return this.largo * this.ancho; }
}

Por fin, comprobamos que el código está bien escrito:

var triangulo1 = new Triangulo(12, 4);
var rectangulo1 = new Rectangulo(22, 10);

console.log(triangulo1.getArea());
console.log(triangulo1.lados);
console.log(rectangulo1.getArea());
console.log(rectangulo1.lados);

Objetos nativos en Javascript

ECMA-262 define los objetos nativos como "cualquier objeto proporcionado por una implementación de ECMAScript independiente del entorno anfitrión". Así, tenemos las siguientes clases: Object, Function, Array, String, Boolean, Number, Date y RegExp.

Algunos ya los vimos y, ahora, vamos a echar ahora una ojeada a algunos más de estos objetos nativos de JavaScript, ésto es, aquellos que JavaScript nos da, listos para su utilización en nuestra aplicación.

Clase Array

En ECMAScript, al contrario que en Java, existe una clase Array. Podemos crear un objeto Array del siguiente modo:

var aValores = new Array()

Otro modo de definirlo sería:

var aValores = [];

Sabiendo con antelación el número de elementos del array:

var aValores = new Array(10)

Para acceder a cada una de las posiciones del array, lo haremos utilizando corchetes, tanto para escribir:

var aColores = new Array();
var aColores[0] = "rojo";
var aColores[1] = "verde";
var aColores[2] = "azul";

como para leer el dato:

console.log(aColores[1]); //verde

Si queremos crear el array ya con una cantidad de valores conocidos:

var aColores = new Array("rojo", "verde", "azul");

Y, claro está, también:

var aColores = ["rojo", "verde", "azul"];

Para descubrir el tamaño total del array, lo haremos con su propiedad length:

console.log(aColores.length); //3

Los arrays pueden tener un total de 4.294.967.295 elementos (¿sufientes?).

Podemos crear una cadena a partir del array, utilizando para ello el método join() y, como parámetro, el separador que nos interese:

var aColores = ["rojo", "verde", "azul"];
sColores = aColores.join(","); //rojo, verde, azul

También el objeto String cuenta con un método para convertirse en Array.

sColores = "rojo, verde, azul";
var aColores = sColores.split(",");

El objeto Array también tiene el método concat(), que nos permite añadir, al final, el contenido de un array en otro. Y el método slice(), para extraer varios elementos del array.

Para añadir y eliminar elementos del final del array, existen los métodos push() y pop().

Para manipular el "primer elemento", en vez de el último, también posee la clase Array el método shift(), que lo elimina y, unshift() que añade un elemento en esa primera posición.

Para manipular el orden de los elementos, la clase Array tiene dos métodos. El método reverse(), que invierte la posición de todos los elementos. Y, el método sort() que los organiza en modo ascendente como si fuesen "cadenas de texto".

Sin duda, el método más complicado de la clase Array es splice(), que nos permite manipular elementos "en el medio" del array:

//Eliminar los dos primeros elementos
unArray.splice(0,2); 
//Añadir esas cadenas en la posición 2
unArray.splice(2, 0, "rojo", "verde"); 
//Eliminar un elemento en la posición 2 y añadir dos cadenas ahí
unArray.splice(2, 1, "rojo", "verde");

El método filter() crea un nuevo array con todos los elementos que cumplan la condición implementada por la función dada.

var aColores = ["rojo", "verde", "azul", "violeta"];
var result = aColores.filter(color => color.length > 4);
console.log(result); //["verde","violeta"]

El método map() crea un nuevo array con los resultados de la llamada a la función indicada aplicados a cada uno de sus elementos.

var numeros = [1, 5, 10, 15];
var doublesNumeros = numeros.map(function(x) {
      return x * 2;
 });
 console.log(numeros); //[1, 5, 10, 15]
 console.log(doublesNumeros); //[2, 10, 20, 30]

El método reduce() ejecuta una función reductora sobre cada elemento de un array, devolviendo como resultado un único valor.

//Ejemplo que suma todos los elementos de un array
var numeros = [1, 5, 10, 15];
var total = numeros.reduce(function(a, b){ return a + b; }, 0);
//El último parámetro "0" será el valor inicial...
console.log(total); // 31

Clase String

Una cadena String consta de uno o más caracteres de texto, rodeados de comillas simples o dobles; da igual cuales usemos ya que se considerará una cadena de todas formas, pero en algunos casos resulta más cómodo el uso de unas u otras.

Por ejemplo, si queremos meter el siguiente texto dentro de una cadena de JavaScript:

<input  type="checkbox"  name="coche"  />Audi

podremos emplear las comillas dobles o simples:

var cadena = '<input  type="checkbox"  name="coche"  />Audi';
var cadena = "<input  type='checkbox'  name='coche'  />Audi";

Si queremos emplear comillas dobles al principio y fin de la cadena, y que en el contenido aparezcan también comillas dobles, tendríamos que escaparlas con \" , por ejemplo:

var cadena = "<input  type=\"checkbox\"  name=\"coche\"  />Audi";

Cuando estamos hablando de cadenas muy largas, podríamos concatenarlas con +=, por ejemplo:

var  nuevoDocumento  =  "";
nuevoDocumento  +=  "<!DOCTYPE  html>";
nuevoDocumento  +=  "<html>"  ;
nuevoDocumento  +=  "<head>";
nuevoDocumento  +=  '<meta  http-equiv="content-type"';
nuevoDocumento  +=  'content="text/html;charset=utf-8">';

Si queremos concatenar el contenido de una variable dentro de una cadena de texto emplearemos el símbolo + :

nombreEquipo  =  prompt("Introduce el nombre de tu equipo:","");
var  mensaje= "El  "  +  nombreEquipo +  "  ha sido el campeón de la Copa del Rey!";
alert(mensaje);
  • Caracteres especiales o caracteres de escape
La forma en la que se crean las cadenas en JavaScript, hace que cuando tengamos que emplear ciertos caracteres especiales en una cadena de texto, tengamos que escaparlos, empleando el símbolo \ seguido del carácter.
Vemos aquí un listado de los caracteres especiales, o de escape:
Símbolos Explicación
\" Comillas dobles
\’ Comilla simple
\\ Barra inclinada
\b Retroceso
\t Tabulador
\n Nueva Línea
\r Salto de Línea
\f Avance de página
  • Propiedades y métodos del objeto String.
Para crear un objeto String lo podremos hacer de la siguiente forma:
var  miCadena = new  String("texto de la cadena");

//O también se podría hacer:
var miCadena = "texto de la cadena";

//Es decir, cada vez que tengamos una cadena de texto, 
//en realidad es un objeto String que tiene propiedades y métodos:
cadena.propiedad;
cadena.metodo( [parámetros] );
Propiedades del objeto String
Propiedad Descripción
length Contiene la longitud de una cadena.
Métodos del objeto String
Método Descripción
charAt() Devuelve el carácter especificado por la posición que se indica entre paréntesis.
charCodeAt() Devuelve el Unicode del carácter especificado por la posición que se indica entre paréntesis.
concat() Une una o más cadenas y devuelve el resultado de esa unión.
fromCharCode() Convierte valores Unicode a caracteres.
indexOf() Devuelve la posición de la primera ocurrencia del carácter buscado en la cadena.
lastIndexOf() Devuelve la posición de la última ocurrencia del carácter buscado en la cadena.
match() Busca una coincidencia entre una expresión regular y una cadena y devuelve las coincidencias o null si no ha encontrado nada.
replace() Busca una subcadena en la cadena y la reemplaza por la nueva cadena especificada.
search() Busca una subcadena en la cadena y devuelve la posición dónde se encontró.
slice() Extrae una parte de la cadena y devuelve una nueva cadena.
split() Divide una cadena en un array de subcadenas.
substr() Extrae los caracteres de una cadena, comenzando en una determinada posición y con el número de caracteres indicado.
substring() Extrae los caracteres de una cadena entre dos índices especificados.
toLowerCase() Convierte una cadena en minúsculas.
toUpperCase() Convierte una cadena en mayúsculas.
Ejemplos de uso:
var cadena="El parapente es un deporte de riesgo medio";

document.write("Longitud de la cadena: "+ cadena.length + "<br/>");
document.write(cadena.toLowerCase()+ "<br/>");
document.write(cadena.charAt(3)+ "<br/>");
document.write(cadena.indexOf('pente')+ "<br/>");
document.write(cadena.substring(3,16)+ "<br/>");

Clase Boolean

El objeto Boolean se utiliza para convertir un valor no Booleano, a un valor Booleano (true o false).

Propiedades del objeto Boolean:

Propiedad Descripción
Constructor Devuelve la función que creó el objeto Boolean.
Prototype Te permitirá añadir propiedades y métodos a un objeto.

Métodos del objeto Boolean:

Método Descripción
toString() Convierte un valor Boolean a una cadena y devuelve el resultado.
valueOf() Devuelve el valor primitivo de un objeto Boolean.

Algunos ejemplos de uso:

let bool = new Boolean(1);
document.write(bool.toString()); 
document.write(bool.valueOf());

Clase Number

El objeto Number se usa muy raramente, ya que para la mayor parte de los casos, JavaScript satisface las necesidades del día a día con los valores numéricos que almacenamos en variables. Pero el objeto Number contiene alguna información y capacidades muy interesantes para programadores más serios.

Lo primero, es que el objeto Number contiene propiedades que nos indican el rango de números soportados en el lenguaje. El número más alto es 1.79E+308; el número más bajo es 2.22E-308. Cualquier número mayor que el número más alto, será considerado como infinito positivo, y si es más pequeño que el número más bajo, será considerado infinito negativo.

Los números y sus valores están definidos internamente en JavaScript, como valores de doble precisión y de 64 bits.

El objeto Number, es un objeto envoltorio para valores numéricos primitivos.

Los objetos Number son creados con new Number().

Propiedades del objeto Number: Propiedad Descripción constructor Devuelve la función que creó el objeto Number. MAX_VALUE Devuelve el número más alto disponible en JavaScript. MIN_VALUE Devuelve el número más pequeño disponible en JavaScript. NEGATIVE_INFINITY Representa a infinito negativo (se devuelve en caso de overflow). POSITIVE_INFINITY Representa a infinito positivo (se devuelve en caso de overflow). prototype Permite añadir nuestras propias propiedades y métodos a un objeto.

Métodos del objeto Number: Método Descripción toExponential(x) Convierte un número a su notación exponencial. toFixed(x) Formatea un número con x digitos decimales después del punto decimal. toPrecision(x) Formatea un número a la longitud x. toString() Convierte un objeto Number en una cadena.

   • Si se pone 2 como parámetro se mostrará el número en binario.
   • Si se pone 8 como parámetro se mostrará el número en octal.
   • Si se pone 16 como parámetro se mostrará el número en hexadecimal.

valueOf() Devuelve el valor primitivo de un objeto Number.

Algunos ejemplos de uso: var num = new Number(13.3714); document.write(num.toPrecision(3)+"
"); document.write(num.toFixed(1)+"
"); document.write(num.toString(2)+"
"); document.write(num.toString(8)+"
"); document.write(num.toString(16)+"
"); document.write(Number.MIN_VALUE); document.write(Number.MAX_VALUE);


Volver