Docsity
Docsity

Prepara tus exámenes
Prepara tus exámenes

Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity


Consigue puntos base para descargar
Consigue puntos base para descargar

Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium


Orientación Universidad
Orientación Universidad


Resumen Javascript, parte I, Transcripciones de Programación Javascript

Creditos al autor, resumen que compila los datos mas importantes sobre los coneceptos basicos de javascript mas importantes segun las aultimas recomendaciones internacionales

Tipo: Transcripciones

2017/2018

Subido el 02/11/2021

anastasia-abreu
anastasia-abreu 🇻🇪

5

(1)

1 documento

1 / 66

Toggle sidebar

Esta página no es visible en la vista previa

¡No te pierdas las partes importantes!

bg1
11/10/21 16:42
Variables
https://es.javascript.info/variables
1/14
El lenguaje JavaScript Fundamentos de JavaScript
28º julio 2021
Variables
La mayoría del tiempo, una aplicación de JavaScript necesita trabajar con información. Aquí hay 2 ejemplos:
1. Una tienda en línea – La información puede incluir los bienes a la venta y un “carrito de compras”.
2. Una aplicación de chat – La información puede incluir los usuarios, mensajes, y mucho más.
Utilizamos las variables para almacenar esta información.
Una variable es un “almacén con un nombre” para guardar datos. Podemos usar variables para almacenar golosinas, visitantes, y
otros datos.
Para generar una variable en JavaScript, se usa la palabra clave let .
La siguiente declaración genera (en otras palabras: declara o define) una variable con el nombre “message”:
Ahora podemos introducir datos en ella al utilizar el operador de asignación =:
Una variable
1let message;
1
2
let message;
ES
Comprar EPUB/PDF
Última actu alizac ión e l 28º julio 2021
11/10/21 16:42
Variables
https://es.javascript.info/variables
2/14
La cadena ahora está almacenada en el área de la memoria asociada con la variable. La podemos acceder utilizando el nombre de
la variable:
Para ser concisos, podemos combinar la declaración de la variable y su asignación en una sola línea:
También podemos declarar variables múltiples en una sola línea:
Esto puede parecer más corto, pero no lo recomendamos. Por el bien de la legibilidad, por favor utiliza una línea por variable.
La versión de líneas múltiples es un poco más larga, pero se lee más fácil:
3message = 'Hola'; // almacenar la cadena 'Hola' en la variable llamada message
1
2
3
4
let message;
message = 'Hola!';
alert(message); // muestra el contenido de la variable
1
2
3
let message = 'Hola!'; // define la variable y asigna un valor
alert(message); // Hola!
1let user = 'John', age = 25, message = 'Hola';
1
2
3
let user = 'John';
let age = 25;
let message = 'Hola';
Última actu alizac ión e l 28º julio 2021
11/10/21 16:42
Variables
https://es.javascript.info/variables
3/14
Algunas personas también definen variables múltiples en estilo multilínea:
…Incluso en este estilo “coma primero”:
Técnicamente, todas estas variantes hacen lo mismo. Así que, es cuestión de gusto personal y preferencia estética.
var en vez de let
En scripts más viejos, a veces se encuentra otra palabra clave: var en lugar de let :
La palabra clave var es casi lo mismo que let . También hace la declaración de una variable, aunque de un modo
ligeramente distinto, y más antiguo.
Existen sutiles diferencias entre let y var , pero no nos interesan en este momento. Cubriremos el tema a detalle en el
capítulo La vieja "var".
1
2
3
let user = 'John',
age = 25,
message = 'Hola';
1
2
3
let user = 'John'
, age = 25
, message = 'Hola';
Una analogía de la vida real
Última actu alizac ión e l 28º julio 2021
11/10/21 16:42
Variables
https://es.javascript.info/variables
4/14
Podemos comprender fácilmente el concepto de una “variable” si nos la imaginamos como una “caja” con una etiqueta de
nombre único pegada en ella.
Por ejemplo, podemos imaginar la variable message como una caja etiquetada "message" con el valor "Hola!" adentro:
Podemos introducir cualquier valor a la caja.
También la podemos cambiar cuantas veces queramos:
Cuando el valor ha sido alterado, los datos antiguos serán removidos de la variable:
"Hello!"
message
1
2
3
4
5
6
7
let message;
message = 'Hola!';
message = 'Mundo!'; // valor alterado
alert(message);
"World!"
"Hello!"
message
Última actu alizac ión e l 28º julio 2021
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b
pf1c
pf1d
pf1e
pf1f
pf20
pf21
pf22
pf23
pf24
pf25
pf26
pf27
pf28
pf29
pf2a
pf2b
pf2c
pf2d
pf2e
pf2f
pf30
pf31
pf32
pf33
pf34
pf35
pf36
pf37
pf38
pf39
pf3a
pf3b
pf3c
pf3d
pf3e
pf3f
pf40
pf41
pf42

Vista previa parcial del texto

¡Descarga Resumen Javascript, parte I y más Transcripciones en PDF de Programación Javascript solo en Docsity!

11/10/21 16:42 Variables

https://es.javascript.info/variables 1/

 →^ El lenguaje JavaScript^ →^ Fundamentos de JavaScript

 28º julio 2021 Variables La mayoría del tiempo, una aplicación de JavaScript necesita trabajar con información. Aquí hay 2 ejemplos:

  1. Una tienda en línea – La información puede incluir los bienes a la venta y un “carrito de compras”.
  2. Una aplicación de chat – La información puede incluir los usuarios, mensajes, y mucho más. Utilizamos las variables para almacenar esta información.

Una variable es un “almacén con un nombre” para guardar datos. Podemos usar variables para almacenar golosinas, visitantes, y otros datos. Para generar una variable en JavaScript, se usa la palabra clave let. La siguiente declaración genera (en otras palabras: declara o define ) una variable con el nombre “message”:

Ahora podemos introducir datos en ella al utilizar el operador de asignación = :

Una variable

1 let message;

let message;

 ES^ Comprar EPUB/PDF^ 

Última actualización el 28º julio 2021

11/10/21 16:42 Variables

https://es.javascript.info/variables 2/

La cadena ahora está almacenada en el área de la memoria asociada con la variable. La podemos acceder utilizando el nombre de la variable:

Para ser concisos, podemos combinar la declaración de la variable y su asignación en una sola línea:

También podemos declarar variables múltiples en una sola línea:

Esto puede parecer más corto, pero no lo recomendamos. Por el bien de la legibilidad, por favor utiliza una línea por variable. La versión de líneas múltiples es un poco más larga, pero se lee más fácil:

3 message = 'Hola'; // almacenar la cadena 'Hola' en la variable llamada message

let message;

message = 'Hola!';

alert(message); // muestra el contenido de la variable

let message = 'Hola!'; // define la variable y asigna un valor

alert(message); // Hola!

1 let user = 'John', age = 25, message = 'Hola';

let user = 'John';

let age = 25;

let message = 'Hola';

Última actualización el 28º julio 2021

11/10/21 16:42 Variables

https://es.javascript.info/variables 3/

Algunas personas también definen variables múltiples en estilo multilínea:

…Incluso en este estilo “coma primero”:

Técnicamente, todas estas variantes hacen lo mismo. Así que, es cuestión de gusto personal y preferencia estética.

var en vez de let En scripts más viejos, a veces se encuentra otra palabra clave: var en lugar de let :

La palabra clave var es casi lo mismo que let. También hace la declaración de una variable, aunque de un modo ligeramente distinto, y más antiguo. Existen sutiles diferencias entre let y var , pero no nos interesan en este momento. Cubriremos el tema a detalle en el capítulo La vieja "var".

let user = 'John',

age = 25,

message = 'Hola';

let user = 'John'

, age = 25

, message = 'Hola';

1 var mensaje = 'Hola';

Una analogía de la vida real

Última actualización el 28º julio 2021

11/10/21 16:42 Variables

https://es.javascript.info/variables 4/

Podemos comprender fácilmente el concepto de una “variable” si nos la imaginamos como una “caja” con una etiqueta de nombre único pegada en ella. Por ejemplo, podemos imaginar la variable message como una caja etiquetada "message" con el valor "Hola!" adentro:

Podemos introducir cualquier valor a la caja. También la podemos cambiar cuantas veces queramos:

Cuando el valor ha sido alterado, los datos antiguos serán removidos de la variable:

"Hello!"

message

let message;

message = 'Hola!';

message = 'Mundo!'; // valor alterado

alert(message);

"World!" "Hello!"

message

Última actualización el 28º julio 2021

11/10/21 16:42 Variables

https://es.javascript.info/variables 5/

También podemos declarar dos variables y copiar datos de una a la otra.

Declarar dos veces lanza un error Una variable debe ser declarada solamente una vez. Una declaración repetida de la misma variable es un error:

Debemos declarar una variable una sola vez y desde entonces referirnos a ella sin let.

g 1 2 3 4 5 6 7 8 9

let hello = 'Hola mundo!';

let message;

// copia 'Hola mundo' de hello a message

message = hello;

// Ahora, ambas variables contienen los mismos datos

alert(hello); // Hola mundo!

alert(message); // Hola mundo!

let message = "This";

// 'let' repetidos lleva a un error

let message = "That"; // SyntaxError: 'message' ya fue declarado

Última actualización el 28º julio 2021

11/10/21 16:42 Variables

https://es.javascript.info/variables 6/

Lenguajes funcionales Es interesante notar el hecho que lenguajes de programación funcional, como Scala o Erlang prohíben cambiar el valor de variables. En tales lenguajes, una vez la variable ha sido almacenada “en la caja”, permanece allí por siempre. Si necesitamos almacenar algo más, el lenguaje nos obliga a crear una nueva caja (generar una nueva variable). No podemos reusar la antigua. Aunque puede parecer un poco extraño a primera vista, estos lenguajes son muy capaces de desarrollo serio. Más aún, existen áreas como computación en paralelo en las cuales esta limitación otorga ciertos beneficios. Estudiar tales lenguajes (incluso sin la intención de usarlo en el futuro cercano) es recomendable para ampliar la mente.

Existen dos limitaciones de nombre de variables en JavaScript:

  1. El nombre únicamente puede incluir letras, dígitos, o los símbolos $ y _.
  2. El primer carácter no puede ser un dígito. Ejemplos de nombres válidos:

Cuando el nombre contiene varias palabras, comúnmente se utiliza camelCase. Es decir: palabras van una detrás de otra, con cada palabra iniciando con letra mayúscula: miNombreMuyLargo. Es interesante notar – el símbolo del dólar '$' y el guión bajo '_' también se utilizan en nombres. Son símbolos comunes, tal como las letras, sin ningún significado especial. Los siguientes nombres son válidos:

Nombramiento de variables

let userName;

let test123;

1 let $ = 1; // Declara una variable con el nombre "$" ^ ✍

Última actualización el 28º julio 2021

11/10/21 16:42 Variables

https://es.javascript.info/variables 7/

Ejemplos de nombres incorrectos:

La Capitalización es Importante Variables con el nombre manzana y manzANA son distintas.

Letras que no son del alfabeto inglés están permitidas, pero no se recomiendan Es posible utilizar letras de cualquier alfabeto, incluyendo el cirílico e incluso jeroglíficos, por ejemplo:

Técnicamente, no existe ningún error aquí. Tales nombres están permitidos, pero existe una tradición internacional de utilizar inglés en el nombramiento de variables. Incluso si estamos escribiendo un script pequeño, este puede tener una larga vida por delante. Puede ser necesario que gente de otros países deba leerlo en algún momento.

let _ = 2; // y ahora una variable con el nombre "_"

alert($ + _); // 3

let 1a; // no puede iniciar con un dígito

let my-name; // los guiones '-' no son permitidos en nombres

let имя = '...';

let 我 = '...';

Última actualización el 28º julio 2021

11/10/21 16:42 Variables

https://es.javascript.info/variables 8/

Nombres reservados Hay una lista de palabras reservadas, las cuales no pueden ser utilizadas como nombre de variable porque el lenguaje en sí las utiliza. Por ejemplo: let , class , return , y function están reservadas. El siguiente código nos da un error de sintaxis:

Una asignación sin utilizar use strict Normalmente, debemos definir una variable antes de utilizarla. Pero, en los viejos tiempos, era técnicamente posible crear una variable simplemente asignando un valor sin utilizar ‘let’. Esto aún funciona si no ponemos ‘use strict’ en nuestros scripts para mantener la compatibilidad con scripts antiguos.

Esto es una mala práctica que causaría errores en ‘strict mode’:

let let = 5; // no se puede le nombrar "let" a una variable ¡Error!

let return = 5; // tampoco se le puede nombrar "return", ¡Error!

// nota: no se utiliza "use strict" en este ejemplo

num = 5; // se crea la variable "num" si no existe antes

alert(num); // 5

"use strict";

num = 5; // error: num no está definida

Última actualización el 28º julio 2021

11/10/21 16:42 Variables

https://es.javascript.info/variables 13/

solución

importancia: 4 Examina el siguiente código:

Aquí tenemos una constante birthday y age es calculada desde birthday con la ayuda de cierto código (no está provisto para abreviar y porque los detalles no importan aquí). ¿Sería correcto usar mayúsculas para birthday? ¿Para age? ¿O incluso para ambos?

solución

Compartir    Mapa del Tutorial

¿const mayúsculas? 

const birthday = '18.04.1982';

const age = someCode(birthday);

const BIRTHDAY = '18.04.1982'; // make uppercase?

const AGE = someCode(BIRTHDAY); // make uppercase?

 Lección anterior Próxima lección^ 

Última actualización el 28º julio 2021

11/10/21 16:42 Variables

https://es.javascript.info/variables 14/

● ● ●

Si tiene sugerencias sobre qué mejorar, por favor enviar una propuesta de GitHub o una solicitud de extracción en lugar de comentar. Si no puede entender algo en el artículo, por favor explique. Para insertar algunas palabras de código, use la etiqueta , para varias líneas – envolverlas en la etiqueta

 , para más de 10 líneas – utilice una entorno controlado (sandbox) (plnkr, jsbin, codepen…) 

 Comentarios

© 2007—2021 Ilya Kantoracerca del proyectocontáctenos

Última actualización el 28º julio 2021

11/10/21 16:47 Tipos de datos

https://es.javascript.info/types 1/

 →^ El lenguaje JavaScript^ →^ Fundamentos de JavaScript

 2º agosto 2021 Tipos de datos Un valor en JavaScript siempre pertenece a un tipo de dato determinado. Por ejemplo, un string o un número. Hay ocho tipos de datos básicos en JavaScript. En este capítulo los cubriremos en general y en los próximos hablaremos de cada uno de ellos en detalle. Podemos almacenar un valor de cualquier tipo dentro de una variable. Por ejemplo, una variable puede contener en un momento un string y luego almacenar un número:

Los lenguajes de programación que permiten estas cosas, como JavaScript, se denominan “dinámicamente tipados”, lo que significa que allí hay tipos de datos, pero las variables no están vinculadas rígidamente a ninguno de ellos.

El tipo number representa tanto números enteros como de punto flotante.

// no hay error

let message = "hola";

message = 123456;

Number

let n = 123;

n = 12.345;

 ES^ Comprar EPUB/PDF^ 

11/10/21 16:47 Tipos de datos

https://es.javascript.info/types 2/

Hay muchas operaciones para números. Por ejemplo, multiplicación * , división / , suma + , resta - , y demás. Además de los números comunes, existen los llamados “valores numéricos especiales” que también pertenecen a este tipo de datos: Infinity , -Infinity y NaN. Infinity representa el Infinito matemático ∞. Es un valor especial que es mayor que cualquier número. Podemos obtenerlo como resultado de la división por cero:

O simplemente hacer referencia a él directamente:

NaN representa un error de cálculo. Es el resultado de una operación matemática incorrecta o indefinida, por ejemplo:

NaN es “pegajoso”. Cualquier otra operación sobre NaN devuelve NaN :

Por lo tanto, si hay un NaN en alguna parte de una expresión matemática, se propaga a todo el resultado.

1 alert( 1 / 0 ); // Infinity

1 alert( Infinity ); // Infinity

1 alert( "no es un número" / 2 ); // NaN, tal división es errónea

1 alert( "no es un número" / 2 + 5); // NaN

11/10/21 16:47 Tipos de datos

https://es.javascript.info/types 3/

Las operaciones matemáticas son seguras Hacer matemáticas es “seguro” en JavaScript. Podemos hacer cualquier cosa: dividir por cero, tratar las cadenas no numéricas como números, etc. El script nunca se detendrá con un error fatal (“morir”). En el peor de los casos, obtendremos NaN como resultado.

Los valores numéricos especiales pertenecen formalmente al tipo “número”. Por supuesto que no son números en el sentido estricto de la palabra. Veremos más sobre el trabajo con números en el capítulo Números.

En JavaScript, el tipo “number” no puede representar valores enteros mayores que (2^53 -1) (eso es 9007199254740991 ), o menor que -(2^53 -1) para negativos. Es una limitación técnica causada por su representación interna. Para la mayoría de los propósitos es suficiente, pero a veces necesitamos números realmente grandes. Por ejemplo, para criptografía o marcas de tiempo de precisión de microsegundos. BigInt se agregó recientemente al lenguaje para representar enteros de longitud arbitraria. Un valor BigInt se crea agregando n al final de un entero:

Como los números BigInt rara vez se necesitan, no los cubrimos aquí sino que les dedicamos un capítulo separado <info: bigint>. Léelo cuando necesites números tan grandes.

Problemas de compatibilidad En este momento, BigInt es compatible con Firefox / Chrome / Edge / Safari, pero no con IE.

BigInt

// la "n" al final significa que es un BigInt

const bigInt = 1234567890123456789012345678901234567890n;

11/10/21 16:47 Tipos de datos

https://es.javascript.info/types 4/

Puedes revisar la tabla de compatibilidad de BigInt en MDN para saber qué versiones de navegador tienen soporte.

Un string en JavaScript es una cadena de caracteres y debe colocarse entre comillas.

En JavaScript, hay 3 tipos de comillas.

  1. Comillas dobles: "Hola".
  2. Comillas simples: 'Hola'.
  3. Backticks (comillas invertidas): Hola. Las comillas dobles y simples son comillas “sencillas” (es decir, funcionan igual). No hay diferencia entre ellas en JavaScript. Los backticks son comillas de “funcionalidad extendida”. Nos permiten incrustar variables y expresiones en una cadena de caracteres encerrándolas en ${...} , por ejemplo:

La expresión dentro de ${...} se evalúa y el resultado pasa a formar parte de la cadena. Podemos poner cualquier cosa ahí dentro: una variable como name , una expresión aritmética como 1 + 2 , o algo más complejo.

String

let str = "Hola";

let str2 = 'Las comillas simples también están bien';

let phrase = se puede incrustar otro ${str};

let name = "John";

// incrustar una variable

alert( Hola, ${name}! ); // Hola, John!

// incrustar una expresión

alert( el resultado es ${1 + 2} ); //el resultado es 3

11/10/21 16:47 Tipos de datos

https://es.javascript.info/types 9/

● ● ● ● ● ● ● ● ● ● ● number para números de cualquier tipo: enteros o de punto flotante, los enteros están limitados por ±(2^53 -1). bigint para números enteros de longitud arbitraria. string para cadenas. Una cadena puede tener cero o más caracteres, no hay un tipo especial para un único carácter. boolean para verdadero y falso: true / false. null para valores desconocidos – un tipo independiente que tiene un solo valor nulo: null. undefined para valores no asignados – un tipo independiente que tiene un único valor “indefinido”: undefined. object para estructuras de datos complejas. symbol para identificadores únicos. El operador typeof nos permite ver qué tipo está almacenado en una variable. Dos formas: typeof x o typeof(x). Devuelve una cadena con el nombre del tipo. Por ejemplo "string". Para null devuelve "object" : esto es un error en el lenguaje, en realidad no es un objeto.

importancia: 5 ¿Cuál es la salida del script?

✔ Tareas

Comillas 

let name = "Ilya";

alert( Hola ${1} ); //?

alert( Hola ${"name"} ); //?

alert( Hola ${name} ); //?

11/10/21 16:47 Tipos de datos

https://es.javascript.info/types 10/

solución

Compartir    Mapa del Tutorial

 Lección anterior Próxima lección^ 

● ● ●

Si tiene sugerencias sobre qué mejorar, por favor enviar una propuesta de GitHub o una solicitud de extracción en lugar de comentar. Si no puede entender algo en el artículo, por favor explique. Para insertar algunas palabras de código, use la etiqueta , para varias líneas – envolverlas en la etiqueta

 , para más de 10 líneas – utilice una entorno controlado (sandbox) (plnkr, jsbin, codepen…) 

 Comentarios

© 2007—2021 Ilya Kantoracerca del proyectocontáctenos

11/10/21 16:49 Interacción: alert, prompt, confirm

https://es.javascript.info/alert-prompt-confirm 1/

 →^ El lenguaje JavaScript^ →^ Fundamentos de JavaScript

 5º julio 2021 Interacción: alert, prompt, confirm Como usaremos el navegador como nuestro entorno de demostración, veamos un par de funciones para interactuar con el usuario: alert , prompt y confirm.

Este ya lo hemos visto. Muestra un mensaje y espera a que el usuario presione “Aceptar”. Por ejemplo:

La mini ventana con el mensaje se llama * ventana modal *. La palabra “modal” significa que el visitante no puede interactuar con el resto de la página, presionar otros botones, etc., hasta que se haya ocupado de la ventana. En este caso, hasta que presionen “OK”.

La función prompt acepta dos argumentos:

alert

1 alert("Hello");

prompt

1 result = prompt(title, [default]);

 ES^ Comprar EPUB/PDF^ 

Última actualización el 5º julio 2021

11/10/21 16:49 Interacción: alert, prompt, confirm

https://es.javascript.info/alert-prompt-confirm 2/

Muestra una ventana modal con un mensaje de texto, un campo de entrada para el visitante y los botones OK/CANCELAR. title El texto a mostrar al usuario. default Un segundo parámetro opcional, el valor inicial del campo de entrada.

Corchetes en la sintaxis [...] Los corchetes alrededor de default en la sintaxis de arriba denotan que el parámetro es opcional, no requerido.

El usuario puede escribir algo en el campo de entrada de solicitud y presionar OK. Así obtenemos ese texto en result. O puede cancelar la entrada presionando Cancelar o presionando la tecla Esc obteniendo null en result. La llamada a prompt retorna el texto del campo de entrada o null si la entrada fue cancelada. Por ejemplo:

let age = prompt ('¿Cuántos años tienes?', 100);

alert(Tienes ${age} años!); //Tienes 100 años!

Última actualización el 5º julio 2021

11/10/21 16:49 Interacción: alert, prompt, confirm

https://es.javascript.info/alert-prompt-confirm 3/

En IE: proporciónale un predeterminado siempre El segundo parámetro es opcional, pero si no lo proporcionamos, Internet Explorer insertará el texto "undefined" en el prompt. Ejecuta este código en Internet Explorer para verlo:

Por lo tanto, para que las indicaciones se vean bien en IE, recomendamos siempre proporcionar el segundo argumento:

La sintaxis:

La función confirm muestra una ventana modal con una pregunta y dos botones: OK y CANCELAR. El resultado es true si se pulsa OK y false en caso contrario. Por ejemplo:

1 let test = prompt("Test");

1 let test = prompt("Test", ''); // <-- para IE

confirm

1 result = confirm(pregunta);

let isBoss = confirm("¿Eres el jefe?");

alert( isBoss ); // true si se pulsa OK

Última actualización el 5º julio 2021

11/10/21 16:49 Interacción: alert, prompt, confirm

https://es.javascript.info/alert-prompt-confirm 4/

Cubrimos 3 funciones específicas del navegador para interactuar con los usuarios: alert muestra un mensaje. prompt muestra un mensaje pidiendo al usuario que introduzca un texto. Retorna el texto o, si se hace clic en CANCELAR o Esc , retorna null. confirm muestra un mensaje y espera a que el usuario pulse “OK” o “CANCELAR”. Retorna true si se presiona OK y false si se presiona CANCEL/ Esc. Todos estos métodos son modales: detienen la ejecución del script y no permiten que el usuario interactúe con el resto de la página hasta que la ventana se haya cerrado. Hay dos limitaciones comunes a todos los métodos anteriores:

  1. La ubicación exacta de la ventana modal está determinada por el navegador. Normalmente, está en el centro.
  2. El aspecto exacto de la ventana también depende del navegador. No podemos modificarlo. Ese es el precio de la simplicidad. Existen otras formas de mostrar ventanas más atractivas e interactivas para el usuario, pero si la “apariencia” no importa mucho, estos métodos funcionan bien.

importancia: 4 Crea una página web que pida un nombre y lo muestre.

Resumen

Tareas

Una página simple

Última actualización el 5º julio 2021

11/10/21 16:52 Conversiones de Tipos

https://es.javascript.info/type-conversions 1/

 →^ El lenguaje JavaScript^ →^ Fundamentos de JavaScript

 22º marzo 2021 Conversiones de Tipos La mayoría de las veces, los operadores y funciones convierten automáticamente los valores que se les pasan al tipo correcto. Esto es llamado “conversión de tipo”. Por ejemplo, alert convierte automáticamente cualquier valor a string para mostrarlo. Las operaciones matemáticas convierten los valores a números. También hay casos donde necesitamos convertir de manera explícita un valor al tipo esperado.

Aún no hablamos de objetos En este capítulo no cubriremos los objetos. Estudiaremos los valores primitivos primero. Luego, después de haber hablado sobre objetos, veremos cómo funciona la conversión de objetos en este capítulo Conversión de objeto a valor primitivo.

La conversión a string ocurre cuando necesitamos la representación en forma de texto de un valor. Por ejemplo, alert(value) lo hace para mostrar el valor como texto. También podemos llamar a la función String(value) para convertir un valor a string:

ToString

let value = true;

alert(typeof value); // boolean

 ES^ Comprar EPUB/PDF^ 

Última actualización el 22º marzo 2021

11/10/21 16:52 Conversiones de Tipos

https://es.javascript.info/type-conversions 2/

La conversión a string es bastante obvia. El boolean false se convierte en "false" , null en "null" , etc.

La conversión numérica ocurre automáticamente en funciones matemáticas y expresiones. Por ejemplo, cuando se dividen valores no numéricos usando / :

Podemos usar la función Number(value) para convertir de forma explícita un valor a un número:

La conversión explícita es requerida usualmente cuando leemos un valor desde una fuente basada en texto, como lo son los campos de texto en los formularios, pero que esperamos que contengan un valor numérico. Si el string no es un número válido, el resultado de la conversión será NaN. Por ejemplo:

5 value = String(value); // ahora value es el string "true"

alert(typeof value); // string

ToNumber

1 alert( "6" / "2" ); // 3, los strings son convertidos a números

let str = "123";

alert(typeof str); // string

let num = Number(str); // se convierte en 123

alert(typeof num); // number

let age = Number("un texto arbitrario en vez de un número");

Última actualización el 22º marzo 2021

11/10/21 16:52 Conversiones de Tipos

https://es.javascript.info/type-conversions 3/

Reglas de conversión numérica:

Valor Se convierte en… undefined NaN null 0 true and false 1 y 0 string Se eliminan los espacios al inicio y final del texto. Si el string resultante es vacío, el resultado escontrario el número es “leído” del string. Un error devuelve NaN.^0 , en caso

Ejemplos:

Ten en cuenta que null y undefined se comportan de distinta manera aquí: null se convierte en 0 mientras que undefined se convierte en NaN.

3 alert(age); // NaN, conversión fallida

alert( Number(" 123 ") ); // 123

alert( Number("123z") ); // NaN (error al leer un número en "z")

alert( Number(true) ); // 1

alert( Number(false) ); // 0

Última actualización el 22º marzo 2021

11/10/21 16:52 Conversiones de Tipos

https://es.javascript.info/type-conversions 4/

● ●

Adición ‘+’ concatena strings Casi todas las operaciones matemáticas convierten valores a números. Una excepción notable es la suma +. Si uno de los valores sumados es un string, el otro valor es convertido a string. Luego, los concatena (une):

Esto ocurre solo si al menos uno de los argumentos es un string, en caso contrario los valores son convertidos a número.

La conversión a boolean es la más simple. Ocurre en operaciones lógicas (más adelante veremos test condicionales y otras cosas similares) pero también puede realizarse de forma explícita llamando a la función Boolean(value). Las reglas de conversión: Los valores que son intuitivamente “vacíos”, como 0 , "" , null , undefined , y NaN , se convierten en false. Otros valores se convierten en true. Por ejemplo:

alert( 1 + '2' ); // '12' (string a la derecha)

alert( '1' + 2 ); // '12' (string a la izquierda)

ToBoolean

alert( Boolean(1) ); // true

alert( Boolean(0) ); // false

alert( Boolean("hola") ); // true

alert( Boolean("") ); // false

Última actualización el 22º marzo 2021

11/10/21 16:52 Conversiones de Tipos

https://es.javascript.info/type-conversions 5/

⚠ Ten en cuenta: el string con un cero "0" es true

Algunos lenguajes (como PHP) tratan "0" como false. Pero en JavaScript, un string no vacío es siempre true.

Las tres conversiones de tipo más usadas son a string, a número y a boolean. ToString – Ocurre cuando se muestra algo. Se puede realizar con String(value). La conversión a string es usualmente obvia para los valores primitivos. ToNumber – Ocurre en operaciones matemáticas. Se puede realizar con Number(value). La conversión sigue las reglas:

Valor Se convierte en… undefined NaN null 0 true / false 1 / 0 string El string es leído “como es”, los espacios en blanco tanto al inicio como al final son ignorados. Un string vacío seconvierte en 0. Un error entrega NaN.

ToBoolean – Ocurren en operaciones lógicas. Se puede realizar con Boolean(value). Sigue las reglas:

alert( Boolean("0") ); // true

alert( Boolean(" ") ); // sólo espacios, también true (cualquier string no vacío es true

Resumen

Última actualización el 22º marzo 2021

11/10/21 16:52 Conversiones de Tipos

https://es.javascript.info/type-conversions 6/

● ●

ValorValor Se convierte en…Se convierte en… 0 , null , undefined , NaN , "" false cualquier otro valor true

La mayoría de estas reglas son fáciles de entender y recordar. Las excepciones más notables donde la gente suele cometer errores son: undefined es NaN como número, no 0. "0" y textos que solo contienen espacios como " " son true como boolean. Los objetos no son cubiertos aquí. Volveremos a ellos más tarde en el capítulo Conversión de objeto a valor primitivo que está dedicado exclusivamente a objetos después de que aprendamos más cosas básicas sobre JavaScript.

Compartir    Mapa del Tutorial

 Lección anterior Próxima lección^ 

● ● ●

Si tiene sugerencias sobre qué mejorar, por favor enviar una propuesta de GitHub o una solicitud de extracción en lugar de comentar. Si no puede entender algo en el artículo, por favor explique. Para insertar algunas palabras de código, use la etiqueta , para varias líneas – envolverlas en la etiqueta

 , para más de 10 líneas – utilice una entorno controlado (sandbox) (plnkr, jsbin, codepen…) 

 Comentarios

Última actualización el 22º marzo 2021

11/10/21 16:52 Conversiones de Tipos

https://es.javascript.info/type-conversions 7/

© 2007—2021 Ilya Kantoracerca del proyectocontáctenos

Última actualización el 22º marzo 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 5/

El unario suma o, en otras palabras, el operador suma + aplicado a un solo valor, no hace nada a los números. Pero si el operando no es un número, el unario suma lo convierte en un número. Por ejemplo:

Realmente hace lo mismo que Number(...) , pero es más corto. La necesidad de convertir cadenas en números surge con mucha frecuencia. Por ejemplo, si estamos obteniendo valores de campos de formulario HTML, generalmente son cadenas. El operador binario suma los agregaría como cadenas:

Si queremos tratarlos como números, necesitamos convertirlos y luego sumarlos:

// Sin efecto en números

let x = 1;

alert( +x ); // 1

let y = -2;

alert( +y ); // -

// Convierte los no números

alert( +true ); // 1

alert( +"" ); // 0

let apples = "2";

let oranges = "3";

alert( apples + oranges ); // "23", el binario suma concatena las cadenas

let apples = "2";

let oranges = "3";

Última actualización el 16º agosto 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 6/

Desde el punto de vista de un matemático, la abundancia de signos más puede parecer extraña. Pero desde el punto de vista de un programador no hay nada especial: primero se aplican los signos más unarios que convierten las cadenas en números, y luego el signo más binario los suma. ¿Por qué se aplican los signos más unarios a los valores antes que los binarios? Como veremos, eso se debe a su mayor precedencia.

Si una expresión tiene más de un operador, el orden de ejecución se define por su precedencia o, en otras palabras, el orden de prioridad predeterminado de los operadores. Desde la escuela, todos sabemos que la multiplicación en la expresión 1 + 2 * 2 debe calcularse antes de la suma. Eso es exactamente la precedencia. Se dice que la multiplicación tiene una mayor precedencia que la suma. Los paréntesis anulan cualquier precedencia, por lo que si no estamos satisfechos con el orden predeterminado, podemos usarlos para cambiarlo. Por ejemplo, escriba (1 + 2) * 2. Hay muchos operadores en JavaScript. Cada operador tiene un número de precedencia correspondiente. El que tiene el número más grande se ejecuta primero. Si la precedencia es la misma, el orden de ejecución es de izquierda a derecha. Aquí hay un extracto de la tabla de precedencia (no necesita recordar esto, pero tenga en cuenta que los operadores unarios son más altos que el operador binario correspondiente):

Precedencia Nombre Signo … … … 16 suma unaria +

// ambos valores convertidos a números antes del operador binario suma

alert( +apples + +oranges ); // 5

// la variante más larga

// alert( Number(apples) + Number(oranges) ); // 5

Precedencia del operador

Última actualización el 16º agosto 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 7/

Precedencia Nombre Signo 16 negación unaria - 16 exponenciación ** 14 multiplicación * 14 división / 13 suma + 13 resta - … … … 3 asignación = … … …

Como podemos ver, la “suma unaria” tiene una prioridad de 16 , que es mayor que el 13 de “suma” (suma binaria). Es por eso que, en la expresión "+apples + +oranges" , las sumas unarias funcionan antes de la adición.

Tengamos en cuenta que una asignación = también es un operador. Está listado en la tabla de precedencia con la prioridad muy baja de 3. Es por eso que, cuando asignamos una variable, como x = 2 * 2 + 1 , los cálculos se realizan primero y luego se evalúa el = , almacenando el resultado en x.

El hecho de que = sea un operador, no una construcción “mágica” del lenguaje, tiene un implicación interesante.

Asignación

let x = 2 * 2 + 1;

alert( x ); // 5

Asignación = devuelve un valor

Última actualización el 16º agosto 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 8/

Todos los operadores en JavaScript devuelven un valor. Esto es obvio para + y - , pero también es cierto para =. La llamada x = value escribe el value en x y luego lo devuelve. Aquí hay una demostración que usa una asignación como parte de una expresión más compleja:

En el ejemplo anterior, el resultado de la expresión (a = b + 1) es el valor asignado a a (es decir, 3 ). Luego se usa para evaluaciones adicionales. Código gracioso, ¿no? Deberíamos entender cómo funciona, porque a veces lo vemos en las bibliotecas de JavaScript. Pero no deberíamos escribir algo así. Tales trucos definitivamente no hacen que el código sea más claro o legible.

Otra característica interesante es la habilidad para encadenar asignaciones:

let a = 1;

let b = 2;

let c = 3 - (a = b + 1);

alert( a ); // 3

alert( c ); // 0

Asignaciones encadenadas

let a, b, c;

a = b = c = 2 + 2;

alert( a ); // 4

alert( b ); // 4

alert( c ); // 4

Última actualización el 16º agosto 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 9/

Las asignaciones encadenadas evalúan de derecha a izquierda. Primero, se evalúa la expresión más a la derecha 2 + 2 y luego se asigna a las variables de la izquierda: c , b y a. Al final, todas las variables comparten un solo valor. Una vez más, con el propósito de la legibilidad es mejor separa tal código en unas pocas líneas:

Es más fácil de leer, especialmente cuando se hace de un vistazo.

A menudo necesitamos aplicar un operador a una variable y guardar el nuevo resultado en esa misma variable. Por ejemplo:

Esta notación puede ser acortada utilizando los operadores += y *= :

Los operadores cortos “modifica y asigna” existen para todos los operadores aritméticos y de nivel bit: /= , -= , etcétera.

c = 2 + 2;

b = c;

a = c;

Modificar en el lugar

let n = 2;

n = n + 5;

n = n * 2;

let n = 2;

n += 5; // ahora n = 7 (lo mismo que n = n + 5)

n *= 2; // ahora n = 14 (lo mismo que n = n * 2)

alert( n ); // 14

Última actualización el 16º agosto 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 10/

Tales operadores tienen la misma precedencia que la asignación normal, por lo tanto se ejecutan después de otros cálculos:

Aumentar o disminuir un número en uno es una de las operaciones numéricas más comunes. Entonces, hay operadores especiales para ello: Incremento ++ incrementa una variable por 1:

Decremento -- decrementa una variable por 1:

Importante: Incremento/decremento sólo puede ser aplicado a variables. Intentar utilizarlo en un valor como 5++ dará un error.

let n = 2;

n *= 3 + 5;

alert( n ); // 16 (lado derecho evaluado primero, lo mismo que n *= 8)

Incremento/decremento

let counter = 2;

counter++; // funciona igual que counter = counter + 1, pero es más corto

alert( counter ); // 3

let counter = 2;

counter--; // funciona igual que counter = counter - 1, pero es más corto

alert( counter ); // 1

Última actualización el 16º agosto 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 11/

● ●

Los operadores ++ y -- pueden ser colocados antes o después de una variable. Cuando el operador va después de la variable, está en “forma de sufijo”: counter++. La “forma de prefijo” es cuando el operador va antes de la variable: ++counter. Ambas sentencias hacen la misma cosa: aumentar counter por 1. ¿Existe alguna diferencia? Sí, pero solamente la podemos ver si utilizamos el valor devuelto de ++/--. Aclaremos. Tal como conocemos, todos los operadores devuelven un valor. Incremento/decremento no es una excepción. La forma prefijo devuelve el nuevo valor mientras que la forma sufijo devuelve el valor anterior (antes del incremento/decremento). Para ver la diferencia, aquí hay un ejemplo:

En la línea (*) , la forma prefijo ++counter incrementa counter y devuelve el nuevo valor, 2. Por lo tanto, el alert muestra

Ahora usemos la forma sufijo:

En la línea (*) , la forma sufijo counter++ también incrementa counter pero devuelve el antiguo valor (antes de incrementar). Por lo tanto, el alert muestra 1. Para resumir:

let counter = 1;

let a = ++counter; // (*)

alert(a); // 2

let counter = 1;

let a = counter++; // (*) cambiado ++counter a counter++

alert(a); // 1

Última actualización el 16º agosto 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 12/

Si no se usa el resultado del incremento/decremento, no hay diferencia en la forma de usar:

Si queremos aumentar un valor y usar inmediatamente el resultado del operador, necesitamos la forma de prefijo:

Si queremos incrementar un valor pero usamos su valor anterior, necesitamos la forma sufijo:

let counter = 0;

counter++;

++counter;

alert( counter ); // 2, las líneas de arriba realizan lo mismo

let counter = 0;

alert( ++counter ); // 1

let counter = 0;

alert( counter++ ); // 0

Última actualización el 16º agosto 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 17/

Piensa bien, anótalos y luego compara con la respuesta. solución

importancia: 5 Aquí hay un código que le pide al usuario dos números y muestra su suma. Funciona incorrectamente. El resultado en el ejemplo a continuación es 12 (para valores de captura predeterminados). ¿Por qué? Arreglalo. El resultado debería ser 3.

solución

"4px" - 2

null + 1

undefined + 1

" \t \n" - 2

Corregir la adición 

let a = prompt("¿Primer número?", 1);

let b = prompt("¿Segundo número?", 2);

alert(a + b); // 12

Última actualización el 16º agosto 2021

11/10/21 16:54 Operadores básicos, matemáticas

https://es.javascript.info/operators 18/

Compartir    Mapa del Tutorial

 Lección anterior Próxima lección^ 

● ● ●

Si tiene sugerencias sobre qué mejorar, por favor enviar una propuesta de GitHub o una solicitud de extracción en lugar de comentar. Si no puede entender algo en el artículo, por favor explique. Para insertar algunas palabras de código, use la etiqueta , para varias líneas – envolverlas en la etiqueta

 , para más de 10 líneas – utilice una entorno controlado (sandbox) (plnkr, jsbin, codepen…) 

 Comentarios

© 2007—2021 Ilya Kantoracerca del proyectocontáctenos

Última actualización el 16º agosto 2021

11/10/21 16:56 Comparaciones

https://es.javascript.info/comparison 1/

● ● ● ● ● ●

 →^ El lenguaje JavaScript^ →^ Fundamentos de JavaScript

 11º octubre 2021 Comparaciones Conocemos muchos operadores de comparación de las matemáticas: En Javascript se escriben así: Mayor/menor que: a > b , a < b. Mayor/menor o igual que: a >= b , a <= b. Igual: a == b (ten en cuenta que el doble signo == significa comparación, mientras que un solo símbolo a = b significaría una asignación). Distinto. En matemáticas la notación es ≠ , pero en JavaScript se escribe como una asignación con un signo de exclamación delante: a != b. En este artículo, aprenderemos más sobre los diferentes tipos de comparaciones y de cómo las realiza JavaScript, incluidas las peculiaridades importantes. Al final, encontrará una buena receta para evitar problemas relacionadas con las “peculiaridades” de JavaScript.

Como todos los demás operadores, una comparación retorna un valor. En este caso, el valor es un booleano. true – significa “sí”, “correcto” o “verdad”. false – significa “no”, “equivocado” o " no verdad". Por ejemplo:

Booleano es el resultado

 ES^ Comprar EPUB/PDF^ 

Última actualización el 11º octubre 2021

11/10/21 16:56 Comparaciones

https://es.javascript.info/comparison 2/

El resultado de una comparación puede asignarse a una variable, igual que cualquier valor:

Para ver si una cadena es “mayor” que otra, JavaScript utiliza el llamado orden “de diccionario” o “lexicográfico”. En otras palabras, las cadenas se comparan letra por letra. Por ejemplo:

El algoritmo para comparar dos cadenas es simple:

  1. Compare el primer carácter de ambas cadenas.
  2. Si el primer carácter de la primera cadena es mayor (o menor) que el de la otra cadena, entonces la primera cadena es mayor (o menor) que la segunda. Hemos terminado.
  3. De lo contrario, si los primeros caracteres de ambas cadenas son los mismos, compare los segundos caracteres de la misma manera.
  4. Repita hasta el final de cada cadena.
  5. Si ambas cadenas tienen la misma longitud, entonces son iguales. De lo contrario, la cadena más larga es mayor.

alert( 2 > 1 ); // true (correcto)

alert( 2 == 1 ); // false (incorrecto)

alert( 2 != 1 ); // true (correcto)

let result = 5 > 4; // asignar el resultado de la comparación

alert( result ); // true

Comparación de cadenas

alert( 'Z' > 'A' ); // true

alert( 'Glow' > 'Glee' ); // true

alert( 'Bee' > 'Be' ); // true

Última actualización el 11º octubre 2021

11/10/21 16:56 Comparaciones

https://es.javascript.info/comparison 3/

En los ejemplos anteriores, la comparación 'Z' > 'A' llega a un resultado en el primer paso. La segunda comparación "Glow" y "Glee" necesitan más pasos, se comparan carácter por carácter:

  1. G es igual que G.
  2. l es igual que l.
  3. o es mayor que e. Detente aquí. La primera cadena es mayor.

No es un diccionario real, sino un orden Unicode El algoritmo de comparación dado arriba es aproximadamente equivalente al utilizado en los diccionarios o guías telefónicas, pero no es exactamente el mismo. Por ejemplo, las mayúsculas importan. Una letra mayúscula "A" no es igual a la minúscula "a". ¿Cuál es mayor? La "a" minúscula. ¿Por qué? Porque el carácter en minúsculas tiene un mayor índice en la tabla de codificación interna que utiliza JavaScript (Unicode). Volveremos a los detalles específicos y las consecuencias de esto en el capítulo Strings.

Al comparar valores de diferentes tipos, JavaScript convierte los valores a números. Por ejemplo:

Para valores booleanos, true se convierte en 1 y false en 0. Por ejemplo:

Comparación de diferentes tipos

alert( '2' > 1 ); // true, la cadena '2' se convierte en el número 2

alert( '01' == 1 ); // true, la cadena '01' se convierte en el número 1

alert( true == 1 ); // true

alert( false == 0 ); // true

Última actualización el 11º octubre 2021

11/10/21 16:56 Comparaciones

https://es.javascript.info/comparison 4/

● ●

Una consecuencia graciosa Es posible que al mismo tiempo: Dos valores sean iguales. Uno de ellos sea true como booleano y el otro sea false como booleano. Por ejemplo:

Desde el punto de vista de JavaScript, este resultado es bastante normal. Una comparación de igualdad convierte valores utilizando la conversión numérica (de ahí que "0" se convierta en 0 ), mientras que la conversión explícita Boolean utiliza otro conjunto de reglas.

Una comparación regular de igualdad == tiene un problema. No puede diferenciar 0 de `falso’:

Lo mismo sucede con una cadena vacía:

let a = 0;

alert( Boolean(a) ); // false

let b = "0";

alert( Boolean(b) ); // true

alert( a == b ); // true!

Igualdad estricta

1 alert( 0 == false ); // true

1 alert( '' == false ); // true

Última actualización el 11º octubre 2021

11/10/21 16:56 Comparaciones

https://es.javascript.info/comparison 9/

● (^) Para insertar algunas palabras de código, use la etiqueta , para varias líneas – envolverlas en la etiqueta

 , para más de 10 líneas – utilice una entorno controlado (sandbox) (plnkr, jsbin, codepen…) 

© 2007—2021 Ilya Kantoracerca del proyectocontáctenos

Última actualización el 11º octubre 2021

11/10/21 16:57 Ejecución condicional: if, '?'

https://es.javascript.info/ifelse 1/

 →^ El lenguaje JavaScript^ →^ Fundamentos de JavaScript

 6º julio 2021 Ejecución condicional: if, '?' Algunas veces, necesitamos ejecutar diferentes acciones basadas en diferentes condiciones. Para esto podemos usar la sentencia if y el operador condicional? , también llamado operador de “signo de interrogación”.

La sentencia if(...) evalúa la condición en los paréntesis, y si el resultado es true ejecuta un bloque de código. Por ejemplo:

Aquí la condición es una simple igualdad ( year == 2015 ), pero podría ser mucho mas complejo. Si quisiéramos ejecutar más de una sentencia, debemos encerrar nuestro bloque de código entre llaves:

La sentencia “if”

let year = prompt('¿En que año fué publicada la especificación ECMAScript-2015?', '');

if (year == 2015) alert( '¡Estás en lo cierto!' );

if (year == 2015) {

alert( "¡Es Correcto!" );

alert( "¡Eres muy inteligente!" );

 ES^ Comprar EPUB/PDF^ 

11/10/21 16:57 Ejecución condicional: if, '?'

https://es.javascript.info/ifelse 2/

● ●

Recomendamos siempre encerrar nuestro bloque de código entre llaves {} siempre que se utilice la sentencia if , inclusive si solo se va a ejecutar una sola sentencia en este caso. Hacer eso mejora la legibilidad.

La sentencia if (…) evalúa la expresión dentro de sus paréntesis y convierte el resultado en booleano. Recordemos las reglas de conversión del capítulo Conversiones de Tipos: El número 0 , un string vacío "" , null , undefined , y NaN se convierte en false. Por esto son llamados valores “falso”. El resto de los valores se convierten en true , entonces los llamaremos valores “verdadero”. Entonces, el código bajo esta condición nunca se ejecutaría:

…y dentro de esta condición siempre se ejecutará:

También podemos pasar un valor booleano pre-evaluado al if , así:

Conversión Booleana

if (0) { // 0 es falso

if (1) { // 1 es verdadero

let cond = (year == 2015); // la igualdad evalúa y devuelve un true o false

if (cond) {

11/10/21 16:57 Ejecución condicional: if, '?'

https://es.javascript.info/ifelse 3/

La sentencia if quizás contenga un bloque “else” opcional. Este se ejecutará cuando la condición sea falsa. Por ejemplo:

Algunas veces, queremos probar variantes de una condición. La clausula else if nos permite hacer esto. Por ejemplo:

La cláusula “else”

let year = prompt('¿En qué año fue publicada la especificación ECMAScript-2015?', '');

if (year == 2015) {

alert( '¡Lo adivinaste, correcto!' );

} else {

alert( '¿Cómo puedes estar tan equivocado?' ); // cualquier valor excepto 2015

Muchas condiciones: “else if”

let year = prompt('¿En qué año fue publicada la especificación ECMAScript-2015?', '');

if (year < 2015) {

alert( 'Muy poco...' );

} else if (year > 2015) {

alert( 'Muy Tarde' );

} else {

alert( '¡Exactamente!' );

11/10/21 16:57 Ejecución condicional: if, '?'

https://es.javascript.info/ifelse 4/

En el código de arriba, JavaScript primero revisa si year < 2015. Si esto es falso, continúa a la siguiente condición year >

  1. Si esta también es falsa, mostrará la última alert. Podría haber más bloques else if. Y el último else es opcional.

A veces necesitamos asignar una variable dependiendo de alguna condición. Por ejemplo:

Entonces el operador “ternario” también llamado “signo de interrogación” nos permite ejecutar esto en una forma más corta y simple. El operador está representado por un signo de interrogación de cierre?. A veces es llamado “ternario” porque el operador tiene tres operandos. Es el único operador de JavaScript que tiene esta cantidad de ellos. La Sintaxis es:

Se evalúa condition : si es verdadera entonces devuelve value1 , de lo contrario value.

Operador ternario ‘?’

let accessAllowed;

let age = prompt('¿Qué edad tienes?', '');

if (age > 18) {

accessAllowed = true;

} else {

accessAllowed = false;

alert(accessAllowed);

1 let result = condition? value1 : value2;