Autor: fernandoruizrico

La tecnología nos ofrece formas increíbles de explorar el mundo sin salir de casa. A través de vídeos en 360° y realidad virtual, podemos experimentar desde emocionantes montañas rusas hasta tranquilos paisajes naturales. Esta colección de enlaces te llevará en un viaje virtual inmersivo, ofreciéndote experiencias únicas desde diferentes rincones del planeta y más allá. Prepárate para sumergirte en aventuras visuales y auditivas como nunca antes.

Canales de YouTube y Vimeo sobre Realidad Virtual

• 360: Descubre maravillas del mundo en vídeos de 360°.
• AirPano VR: Experimenta vistas aéreas espectaculares en realidad virtual.
• VR Planet: Viaja a destinos exóticos con contenido VR único.
• Vicinity360: Experiencias únicas de realidad virtual en 360º.
• mvr: Diversidad de experiencias en realidad virtual.
• Black Studios XR: Sumérgete en experiencias inmersivas en XR.
• VR360 Cinema: Disfruta de películas y cortometrajes en formato 360°.
• 360 Horizons: Explora paisajes y horizontes impresionantes en 360°.
• Virtual Reality 360 Video Channel: Una variedad de contenido emocionante en 360°.
• Vimeo 360 VR: Una plataforma con vídeos creativos y artísticos en formato 360° y VR.

Naturaleza y paisajes

• China: Ver vídeo. Te muestra la cultura y tradiciones milenarias de China. Recorre sus ciudades vibrantes, monumentos históricos y paisajes impresionantes.
• Paisajes del mundo: Ver vídeo. Te presenta una selección de los paisajes más impresionantes del planeta. Déjate sorprender por la belleza natural de nuestro mundo.
• Pandemia alrededor del mundo: Ver vídeo. Documenta el impacto global de la pandemia de COVID-19. Conoce las diferentes medidas tomadas por los países para combatir el virus.
• Isla Hamilton: Ver vídeo. Te invita a descubrir la belleza natural de la isla Hamilton en Australia. Disfruta de sus playas paradisíacas, arrecifes de coral y exuberante vegetación.
• Cascada del Salto del Ángel: Ver vídeo. Visión panorámica del Salto Ángel, la cascada más alta del mundo. Hasta este momento, nadie había podido capturar el Salto Ángel en formato de vídeo 360°.
• Formaciones rocosas de Manpupuner: Ver vídeo. Rusia ofrece una gran variedad de magníficos monumentos naturales, como las formaciones rocosas de Manpupuner, los ídolos de piedra en el distrito Troitsko-Pechorsky de la República de Komi. En 2008, las formaciones fueron reconocidas como una de las Siete Maravillas de Rusia.
• Cueva Chauvet: Ver vídeo. Te invita a explorar las pinturas rupestres de la Cueva Chauvet en Francia. Admira estas impresionantes obras de arte prehistórico.
• África: Ver vídeo. Te lleva a un safari por las vastas llanuras de África. Observa la increíble diversidad de animales salvajes que habitan este continente.
• Antártida: Ver vídeo. Explora una colonia de pingüinos y focas mientras se aproxima una tormenta.
• Polo Sur: Ver vídeo. Te lleva a un viaje al Polo Sur, el lugar más austral de la Tierra. Experimenta la inmensidad y el frío extremo de este continente helado.
• Mago David Blaine vuela a 7.500m.: Ver vídeo. Muestra el proceso de preparación para conseguir realizar tal hazaña. Percibirás los riesgos que implica y apreciarás la increíble satisfacción de Blaine al conseguir superar este reto ascendiendo a esa increíble altitud.
• Escalada: Ver vídeo. Serás consciente de la preparación física y mental necesaria para la escalada. Además experimentarás las dificultades y peligros a los que se enfrentan los escaladores, y también serás partícipe de la emoción de llegar a la cima.

Animales

• Tiburones: Ver vídeo 1 | Ver vídeo 2. Sumérgete en el fascinante mundo de los tiburones. Conoce diferentes especies, sus características y su papel en el ecosistema marino.
• Leones: Ver vídeo. Crecer es una lucha, especialmente si eres un joven león. En esta película de realidad virtual de National Geographic, te encontrarás cara a cara con Gibson y su madre, mientras luchan contra el macho alfa de su manada. ¿Dejar la seguridad de la manada es la única esperanza de supervivencia de Gibson?
• Tiburón martillo: Ver vídeo. Sumérgete en este video de 360° y enfréntate cara a cara con un curioso tiburón martillo gigante.
• Ballenas: Ver vídeo. Te presenta la majestuosidad de las ballenas, los animales más grandes del planeta. Observa estos increíbles cetáceos en su hábitat natural.
• Criaturas marinas: Ver vídeo. Descubre las increíbles criaturas que habitan en las profundidades del océano.
• Monstruos del océano: Ver vídeo. Explora diferentes zonas del océano, desde la superficie hasta la fosa abisal, mostrando una gran variedad de animales poco conocidos, como el pez ojo de barril, el calamar gigante y el tiburón duende.
• Oso perezoso: Ver vídeo. Explora la jungla costarricense mientras una perezosa de tres dedos se abre camino desde el suelo hasta el dosel de la selva.

Espacio

• Paseo espacial: Ver vídeo. Lánzate al vacío desde 400 kilómetros sobre la Tierra con este galardonado paseo espacial en realidad virtual, inspirado en el programa de entrenamiento de la NASA y las asombrosas experiencias de sus astronautas.
• Viaje por el universo: Ver vídeo. Te embarca en una fascinante aventura espacial. Explora las estrellas, planetas y galaxias que conforman nuestro universo.
• Eclipse solar desde el espacio: Ver vídeo. Te ofrece una vista única del eclipse solar desde la perspectiva de la Estación Espacial Internacional.
• Alunizaje: Ver vídeo. Sumérgete en la misión espacial Apolo 11 de la NASA en 360 grados. Experimenta el lanzamiento del cohete y el alunizaje en realidad virtual.
• Sonda de la NASA en Saturno: Ver vídeo. Te muestra las imágenes y descubrimientos de la sonda Cassini durante su viaje a Saturno.
• Agujero de gusano: Ver vídeo. Explora la posibilidad de la existencia de agujeros de gusano, como atajos a través del espacio-tiempo.

Parques de atracciones

• Montaña rusa real: Ver vídeo. Te lleva a través de las subidas, bajadas, giros y vueltas de la montaña rusa, permitiéndote sentir la adrenalina y la emoción de la experiencia.
• Montaña rusa virtual: Ver vídeo. Te lleva a un emocionante viaje a través de una montaña rusa. Siente la adrenalina mientras subes, bajas y giras en este trepidante recorrido.
• Parque acuático: Ver vídeo. Un tobogán a gran velocidad en una isla tropical llena de sorpresas.
• Montaña rusa virtual de Bob Esponja: Ver vídeo. Montaña rusa en 360 grados con el mundo submarino temático de Bob Esponja de Nickelodeon, inspirado en el nuevo juego Battle for Bikini Bottom Rehydrated.

Experiencias musicales

• Banda sonora de Avatar: Escuchar. La Orquesta Sinfónica Nacional Danesa te presenta la Suite Avatar en VR y con audio espacial en el concierto Galaxymphony.
• Ópera de Sídney: Escuchar. La Ópera de Sídney es un ícono australiano y uno de los centros de artes escénicas más activos del mundo. Encontrarás actuaciones, contenido detrás de escena e historias de los espacios bajo las velas. Con más de 40 espectáculos a la semana en la Ópera de Sídney, hay algo para todos los gustos.
• Quinta sinfonía de Beethoven: Escuchar. Una experiencia filarmónica con la Orquesta Filarmónica de Róterdam, Países Bajos. Te ofrece 6 puntos de vista diferentes, tanto para tus ojos como para tus oídos, situándote en el centro de la orquesta, como si fueras uno de los músicos. Cada ubicación cuenta con un paisaje sonoro único, lo que convierte esta experiencia de la famosa Quinta de Beethoven en algo completamente nuevo.
• Novena sinfonía de Beethoven: Escuchar. Ludwig van Beethoven, Sinfonía n.° 9 (1.er movimiento) / Director: Sir Simon Rattle, Orquesta Filarmónica de Berlín / Ensayo grabado en vídeo de 360 grados en la Filarmónica de Berlín.
• Orquesta BBC: Escuchar. Siente toda la emoción con una vista de 360° de la Orquesta Sinfónica BBC interpretando «En la gruta del Rey de la montaña» de Edvard Grieg, grabada en los estudios Maida Vale de Londres.
• Mahler No. 9: Escuchar. Orquesta Sinfónica de Aachen, dirigida por Kazem Abdullah. Sinfonía No. 9 de Gustav Mahler. Eurogress Aachen.
• Orquesta de Filadelfia: Escuchar. La Orquesta de Filadelfia interpreta «En la gruta del rey de la montaña» de la Suite No. 1 de Peer Gynt de Edvard Grieg, bajo la dirección del Director Musical Yannick Nézet-Séguin en el Auditorio Stern / Escenario Perelman del Carnegie Hall.
• Take on me, de a-ha: Escuchar. Grupo de música «a-ha» inmortalizado a través de la realidad virtual, en esta grabación de la última parte de su gira en Oslo Spektrum.

Videojuegos e ilusiones ópticas

• Ilusiones ópticas (en español): Ver vídeo. Te sorprenderá con una colección de ilusiones que desafiarán tu percepción. Prepárate para ver cosas que no son lo que parecen.
• Spiderman gameplay: Ver vídeo. Gameplay del videojuego de Spiderman – Lejos de casa.
• Mario Kart: Ver vídeo. Super Mario es una serie de juegos de plataforma creada por Nintendo y protagonizada por su mascota, Mario.
• Subway surfers: Ver vídeo. Animación en 360° de Subway Surfers.
• Among US: Ver vídeo. Gameplay del videojuego Among US.
• Bob Esponja: Ver vídeo. Disfruta de los primeros 13 minutos del nuevo juego de Bob Esponja en 360 grados.
• Dinosaurio de Google Chrome: Ver vídeo. El juego del dinosaurio de Google Chrome, también conocido como «Chrome Dino Run» o «T-Rex Run», es un juego simple pero desafiante que se encuentra oculto en el navegador Chrome. Se activa cuando no hay conexión a internet o cuando se produce un error de red.
• Fortnite (evento Galactus): Ver vídeo. Revive el épico evento Galactus en Fortnite, donde los jugadores se unieron para luchar contra una amenaza cósmica.

Otros

• Vuelo visto desde la cabina: Ver vídeo. Acompaña al Capitán Joe, al Primer Oficial Dean y al videógrafo Swayne en este video totalmente interactivo. La Isla North Eleuthera nunca había recibido un avión tan grande, por lo que este vuelo vacío le dio a los equipos de tierra la oportunidad de trabajar con el nuevo E-175 por primera vez antes del servicio regular de pasajeros.
• Bob Esponja en el Crustáceo Crujiente: Ver vídeo. Ahora puedes entrar al Crustáceo Crujiente en el primer video oficial de 360° de Bob Esponja. Experimenta cómo es la vida de los habitantes de Fondo de Bikini, e intenta encontrar todos los objetos escondidos de tus episodios favoritos de Bob Esponja.
• Espantapájaros: Ver vídeo. Crea una atmósfera de suspense y terror mediante efectos de sonido espeluznantes en una situación en la que te sientes atrapado.
• Sala de cine con formatos de sonido: Ver vídeo. Te permite experimentar los diferentes formatos de sonido en las salas de cine, pudiendo percibir cómo impactan en la experiencia del espectador.

Conclusión

Este viaje virtual a través de videos en 360° y realidad virtual te ha llevado desde las profundidades del océano hasta el espacio exterior, desde emocionantes aventuras hasta serenas experiencias musicales. La tecnología de realidad virtual nos permite explorar mundos de manera que antes solo podíamos imaginar. Esperamos que hayas disfrutado de estas experiencias inmersivas tanto como nosotros.

Los condicionales son estructuras esenciales en programación que dirigen la ejecución de código según situaciones específicas. Actúan como puntos de bifurcación en el flujo del programa, permitiendo que se ejecuten diferentes secciones de código en función de si se cumple o no una evaluación lógica. Estas estructuras son fundamentales para la toma de decisiones automatizadas y la adaptación del comportamiento del programa a distintos escenarios.

Estructura «if»

El condicional if se utiliza para ejecutar un bloque de código si una condición es verdadera. La condición es una expresión que se evalúa como true o false. Si la condición es verdadera, el bloque de código dentro de las llaves {} se ejecuta. Si es falsa, el bloque se omite:

if (condición) {
  // Código a ejecutar si la condición es verdadera
}

Por ejemplo, con el siguiente código podemos verificar si una persona es mayor de edad:

let edad = 20;

if (edad >= 18) {
  console.log("Eres mayor de edad.");
}

Estructura «if…else»

La estructura if...else se utiliza para ejecutar un bloque de código si la condición es verdadera y otro bloque si es falsa:

if (condición) {
  // Código a ejecutar si la condición es verdadera
} else {
  // Código a ejecutar si la condición es falsa
}

Por ejemplo, podemos decidir cómo saludar a alguien en función de la hora que sea:

let hora = 20;

if (hora < 12) {
  console.log("Buenos días.");
} else {
  console.log("Buenas tardes o noches.");
}

Estructura «if…else if…else»

En bloque if...else if...else se usa para manejar múltiples condiciones en secuencia. Si la primera condición es falsa, se evalúan las condiciones siguientes en orden.

Supongamos que tenemos diferentes condiciones y queremos ejecutar un bloque de código específico dependiendo de cuál de esas condiciones sea verdadera. En lugar de usar varios bloques if independientes, podemos usar la estructura if...else if...else para hacerlo de manera más organizada:

if (condición1) {
  // Código a ejecutar si condición1 es verdadera
} else if (condición2) {
  // Código a ejecutar si condición2 es verdadera
} else if (condición3) {
  // Código a ejecutar si condición3 es verdadera
} else {
  // Código a ejecutar si ninguna condición es verdadera
}

Esta sería la descripción paso a paso de cómo se ejecuta esta estructura:

1. El programa evalúa la condición1. Si es verdadera, ejecuta el bloque de código dentro de ese if y luego sale del bloque if...else if...else.
2. Si condición1 es falsa, pasa a evaluar condición2. Si es verdadera, ejecuta el bloque de código dentro de ese else if y luego sale del bloque if...else if...else.
3. Si tanto condición1 como condición2 son falsas, pasa a evaluar condición3. Si es verdadera, ejecuta el bloque de código dentro de ese else if y luego sale del bloque if...else if...else.
4. Si ninguna de las condiciones anteriores es verdadera, se ejecuta el bloque de código dentro del else.

Por ejemplo, podemos utilizar el siguiente código para evaluar el trabajo de un estudiante:

let puntuacion = 8;
let calificacion;

if (puntuacion >= 9) {
  calificacion = "Sobresaliente";
} else if (puntuacion >= 7) {
  calificacion = "Notable";
} else if (puntuacion >= 6) {
  calificacion = "Bien";
} else if (puntuacion >= 5) {
  calificacion = "Suficiente";
} else {
  calificacion = "Suspenso";
}

// Salida: "Calificación: Notable"
console.log(`Calificación: ${calificacion}`);

Estructura «switch»

El switch es una estructura de control en JavaScript que se utiliza para tomar decisiones basadas en múltiples casos posibles. A diferencia de las estructuras if...else if...else, el switch se utiliza cuando necesitamos realizar diferentes acciones dependiendo del valor de una única expresión. Resulta especialmente útil cuando tenemos muchos posibles valores y queremos evitar una serie larga de else if:

switch (expresión) {
  case valor1:
    // Código a ejecutar si la expresión coincide con valor1
    break;
  case valor2:
    // Código a ejecutar si la expresión coincide con valor2
    break;
  // Más casos...
  default:
    // Código a ejecutar si ningún caso coincide
}

• expresión: Una expresión cuyo valor se comparará con los diferentes casos.
• valor1, valor2, etc.: Los posibles valores que puede tener la expresión.
• break: Esta palabra clave es importante. Cuando se encuentra un break, el programa sale del bloque switch y continúa con el código después del bloque.

Por ejemplo, podemos utilizar el siguiente código para imprimir el día de la semana partiendo de un número del 1 al 7:

let dia = 3;
let nombreDia;

switch (dia) {
  case 1:
    nombreDia = "Lunes";
    break;
  case 2:
    nombreDia = "Martes";
    break;
  case 3:
    nombreDia = "Miércoles";
    break;
  // ...
  default:
    nombreDia = "Día no válido";
}

// Salida: "Hoy es Miércoles"
console.log(`Hoy es ${nombreDia}`);

En el ejemplo anterior, el programa compara el valor de dia con cada caso dentro del switch y asigna el nombre del día correspondiente. Si dia es igual a 3, se ejecuta el bloque de código bajo case 3.

Operador ternario

El operador ternario nos permite compactar la forma de escribir condicionales. La idea principal es que, en lugar de usar un bloque if...else para asignar valores a una variable en función de una condición, usemos el operador ternario para lograrlo con menos código mediante la siguiente sintaxis:

variable = condición ? valorSiVerdadero : valorSiFalso;

• condición: Una expresión que se evalúa como verdadera o falsa.
• valorSiVerdadero: El valor que se asignará a la variable si la condición es verdadera.
• valorSiFalso: El valor que se asignará a la variable si la condición es falsa.

Por ejemplo, podemos utilizar el siguiente código para verificar si un número es par o impar:

let numero = 7;
let esPar = numero % 2 === 0 ? "Es par." : "Es impar.";
console.log(esPar);

En el ejemplo anterior utilizamos la condición numero % 2 === 0 para verificar si el número es par. Si la condición es verdadera, se asigna el valor "Es par." a la variable esPar; si la condición es falsa, se asigna el valor "Es impar.".

Operadores de comparación

Los operadores de comparación son símbolos especiales que se utilizan para comparar dos valores y determinar la relación entre ellos, evaluando si una condición es verdadera o falsa. En esencia, nos permiten hacer preguntas sobre los valores para tomar decisiones basadas en comparaciones numéricas, de cadenas de texto y otros tipos de datos.

Operador de igualdad (==)

El operador de igualdad == se utiliza para comparar si dos valores son iguales. Realiza una conversión de tipo antes de realizar la comparación, lo que significa que puede comparar valores de diferentes tipos.

Por ejemplo, en el siguiente código comparamos dos valores: numero1 es un número y numero2 es una cadena de texto que representa el número 5. Aunque los tipos son diferentes, el operador == realiza una conversión de tipo y considera que son iguales, por lo que se imprimirá «Los números son iguales»:

var num1 = 5;
var num2 = "5";

if (num1 == num2) {
  console.log("Los números son iguales.");
} else {
  console.log("Los números son diferentes.");
}

Operador de igualdad estricta (===)

El operador de igualdad estricta === se utiliza para comparar si dos valores son iguales y del mismo tipo. No realiza conversión de tipo antes de la comparación.

En el siguiente ejemplo, aunque los valores son iguales, el operador === tiene en cuenta el tipo de dato y no realiza conversión de tipo. Dado que numero1 es un número y numero2 es una cadena de texto, la comparación devuelve falso y se imprimirá «Los números son diferentes»:

var num1 = 5;
var num2 = "5";

if (num1 === num2) {
  console.log("Los números son iguales.");
} else {
  console.log("Los números son diferentes.");
}

Operador de desigualdad (!=)

El operador de desigualdad != se utiliza para comparar si dos valores son distintos. Realiza una conversión de tipo antes de la comparación.

En el siguiente ejemplo comparamos el valor de la variable edad con la cadena de texto «18». Aunque los tipos son diferentes, el operador != realiza una conversión de tipo y considera que son iguales, por lo que se imprimirá «La edad es 18»:

var edad = 18;
if (edad != "18") {
  console.log("La edad es diferente de 18.");
} else {
  console.log("La edad es 18.");
}

Operador de desigualdad estricta (!==)

El operador de desigualdad estricta !== se utiliza para comparar si dos valores son diferentes o no son del mismo tipo. No realiza conversión de tipo antes de la comparación.

En el siguiente ejemplo, aunque los valores son iguales, el operador !== tiene en cuenta el tipo de dato y no realiza ninguna conversión. Dado que numero es un número y la cadena de texto «10» es de un tipo diferente, la comparación devuelve verdadero y se imprimirá «El número no es igual a 10 o no es del mismo tipo»:

var num = 10;
if (num !== "10") {
  console.log("El número no es igual a 10 o no es del mismo tipo.");
} else {
  console.log("El número es igual a 10 y del mismo tipo.");
}

Operadores de comparación numérica

Los operadores de comparación numérica (<, >, <=, >=) se utilizan para comparar valores numéricos.

En el siguiente ejemplo comparamos dos valores numéricos: x e y. El primer if verifica si x es mayor que y, el segundo if verifica si x es menor que y, y si ninguna de estas condiciones es verdadera, se asume que x es igual a y:

var x = 10;
var y = 5;

if (x > y) {
  console.log("x es mayor que y.");
} else if (x < y) {
  console.log("x es menor que y.");
} else {
  console.log("x es igual a y.");
}

Operadores de comparación de cadenas de texto

Los operadores de comparación también se pueden utilizar para comparar cadenas de texto alfabéticamente.

En el siguiente ejemplo comparamos dos cadenas de texto (palabra1 y palabra2), utilizando la posición alfabética para determinar el orden. Si palabra1 viene antes en el diccionario que palabra2, se imprimirá «palabra1 viene antes en el diccionario»; si es lo contrario, se imprimirá «palabra2 viene antes en el diccionario»; y si ambas palabras son iguales, se imprimirá «Las palabras son iguales»:

var palabra1 = "manzana";
var palabra2 = "banana";

if (palabra1 < palabra2) {
  console.log("palabra1 viene antes en el diccionario.");
} else if (palabra1 > palabra2) {
  console.log("palabra2 viene antes en el diccionario.");
} else {
  console.log("Las palabras son iguales.");
}

Operadores lógicos

Los operadores lógicos son herramientas esenciales en programación utilizadas para combinar y evaluar condiciones booleanas. Estos operadores, como AND, OR y NOT, permiten construir expresiones más complejas al unir o negar condiciones simples. AND devuelve verdadero si dos condiciones son verdaderas, OR devuelve verdadero si al menos una condición es verdadera, y NOT invierte el valor de una condición verdadera o falsa. Estos operadores son fundamentales para controlar cómo se ejecuta el código en función de condiciones múltiples y permiten tomar decisiones condicionales más avanzadas:

if (condición1 && condición2) {
  // Bloque de código si ambas condiciones son verdaderas
}

if (condición1 || condición2) {
  // Bloque de código si al menos una de las condiciones es verdadera
}

Operador && (AND)

El operador lógico &&, también conocido como AND, se utiliza para evaluar si dos condiciones son verdaderas al mismo tiempo. Devuelve true solo si ambas condiciones son true.

Por ejemplo, con el siguiente código podemos verificar al mismo tiempo si una persona tiene al menos 18 años y si además tiene carnet de conducir. Si ambas condiciones son verdaderas, se imprimirá «Puedes conducir»; de lo contrario, se imprimirá «No puedes conducir»:

var edad = 25;
var tieneCarnet = true;

if (edad >= 18 && tieneCarnet) {
  console.log("Puedes conducir.");
} else {
  console.log("No puedes conducir.");
}

Operador || (OR)

El operador lógico ||, también conocido como OR, se utiliza para evaluar si al menos una de las dos condiciones es verdadera. Devuelve true si al menos una condición es true.

Por ejemplo, con el siguiente código podemos verificar si una persona es estudiante o empleado. Si al menos una de las condiciones es verdadera, se imprimirá «Tienes acceso al edificio»; de lo contrario, se imprimirá «No tienes acceso al edificio»:

var esEstudiante = false;
var esEmpleado = true;

if (esEstudiante || esEmpleado) {
  console.log("Tienes acceso al edificio.");
} else {
  console.log("No tienes acceso al edificio.");
}

Operador ! (NOT)

El operador lógico !, también conocido como NOT, se utiliza para negar una condición. Si la condición es verdadera, ! la convierte en falsa, y si es falsa, la convierte en verdadera.

Por ejemplo, con el siguiente código verificamos si una persona está autenticada o no. Si la condición es verdadera (es decir, no está autenticada), se imprimirá «Debes iniciar sesión»; de lo contrario, se imprimirá «Bienvenido».

var estaAutenticado = false;

if (!estaAutenticado) {
  console.log("Debes iniciar sesión.");
} else {
  console.log("Bienvenido.");
}

Combinando operadores

Podemos combinar diferentes operadores para formar condiciones más complejas. Es importante tener en cuenta el orden de evaluación y usar paréntesis para agrupar condiciones cuando sea necesario.

Prioridad de los operadores

La prioridad de los operadores en JavaScript determina el orden en que se evalúan las expresiones. Los operadores de mayor prioridad se evalúan antes que los de menor prioridad. Si necesitamos cambiar este orden, podemos usar paréntesis para agrupar las expresiones. A continuación mostramos la prioridad de algunos operadores (los de igualdad o comparación se evaluarán antes que los lógicos):

1. Operadores de comparación: ==, !=, ===, !==, <, >, <=, >=
2. Operadores lógicos: &&, ||

Por ejemplo, con el siguiente código evaluamos la temperatura y si hace un día soleado. Si ambas condiciones son verdaderas, se imprimirá «Hace calor y está soleado». Si al menos una de las condiciones es verdadera, se imprimirá «Hace calor o está soleado». Si ninguna de las condiciones es verdadera, se imprimirá «No hace calor y no está soleado»:

var temperatura = 28;
var estaSoleado = true;

if (temperatura > 25 && estaSoleado) {
  console.log("Hace calor y está soleado.");
} else if (temperatura > 25 || estaSoleado) {
  console.log("Hace calor o está soleado.");
} else {
  console.log("No hace calor y no está soleado.");
}

A continuación exponemos otro ejemplo para determinar en este caso el tipo de un triángulo. Supongamos que tenemos las longitudes de los lados del triángulo y debemos decidir si es equilátero, isósceles o escaleno. Para ello podemos combinar operadores de comparación y lógicos para implementar las siguientes condiciones:

• Si todos los lados son iguales, el triángulo es equilátero.
• Si todos los lados son diferentes, el triángulo es escaleno.
• Si ninguna de las condiciones anteriores se cumple, el triángulo es isósceles.

var ladoA = 5;
var ladoB = 5;
var ladoC = 6;

if (ladoA === ladoB && ladoB === ladoC) {
  console.log("El triángulo es equilátero.");
} else if (ladoA !== ladoB && ladoB !== ladoC && ladoA !== ladoC) {
  console.log("El triángulo es escaleno.");
} else {
  console.log("El triángulo es isósceles.");
}

Uso de paréntesis

A continuación vamos a mostrar un ejemplo en el que resulta necesario utilizar paréntesis para agrupar las condiciones. Supongamos que estamos desarrollando una aplicación que requiere contraseñas seguras. Para ello todas la contraseñas deben tener al menos 8 caracteres de longitud y deben contener al menos uno de los caracteres especiales «@» o «#». Si ambas condiciones se cumplen, la contraseña se considera segura:

var contraseña = "P@ssw0rd";

if ((contraseña.length >= 8) && (contraseña.includes("@") || contraseña.includes("#"))) {
  console.log("Contraseña segura.");
} else {
  console.log("La contraseña no cumple con los requisitos de seguridad.");
}

Vamos a desglosar el ejemplo para entenderlo mejor. Comenzaremos matizando los dos requisitos que se deben cumplir para que una contraseña sea segura:

1. La longitud de la contraseña debe ser al menos 8 caracteres.
2. La contraseña debe contener al menos uno de los caracteres especiales «@» o «#».

Ahora, veamos cómo los paréntesis ayudan a controlar el orden de evaluación:

1. (contraseña.length >= 8) evalúa si la longitud de la contraseña es al menos 8 caracteres.
2. (contraseña.includes("@") || contraseña.includes("#")) evalúa si la contraseña contiene al menos uno de los caracteres especiales «@» o «#».

Ambas condiciones deben cumplirse para que la contraseña sea segura. Sin embargo, si no usáramos paréntesis para agrupar estas condiciones, podríamos tener problemas con el orden de evaluación. Veamos el ejemplo sin paréntesis:

if (contraseña.length >= 8 && contraseña.includes("@") || contraseña.includes("#")) {
  // ...
}

En este caso, JavaScript evaluaría primero contraseña.length >= 8 && contraseña.includes("@"), y luego evaluaría contraseña.includes("#"), lo cual no es lo que deseamos.

Al usar paréntesis para agrupar las condiciones relacionadas, aseguramos que se evalúen como una unidad coherente. Esto nos garantiza que se cumplan ambos requisitos para considerar la contraseña segura.

En resumen, los paréntesis son esenciales para controlar el orden de evaluación y garantizar que las condiciones se combinen de la manera correcta, especialmente cuando estamos combinando operadores lógicos (&& y ||) con operadores de comparación en condiciones más complejas.

Test

Comprueba tus conocimientos con este test sobre condicionales y otros conceptos relacionados con esta unidad.

Un array es una estructura de datos que permite almacenar y organizar múltiples elementos relacionados bajo un solo nombre. Los elementos dentro de un array pueden ser de cualquier tipo de dato, como por ejemplo números, cadenas, objetos y funciones. Los arrays son una parte esencial de la programación, ya que permiten manejar y manipular colecciones de datos de manera eficiente.

Elementos e índices

Podemos imaginar un array como una caja con compartimentos numerados, donde cada compartimento puede contener un valor. Cada valor se llama «elemento» y se almacena en una posición específica identificada con un «índice». Los índices comienzan desde 0, lo que significa que el primer elemento tiene un índice de 0, el segundo tiene un índice de 1, y así sucesivamente.

Creación de arrays

Podemos crear un array utilizando la sintaxis de corchetes [], dentro de los cuales colocamos los elementos separados por comas:

let numeros = [1, 2, 3, 4, 5];
let colores = ["rojo", "verde", "azul"];
let mixto = [10, "texto", true, null, { nombre: "Juan" }];

Acceso a elementos

Podemos acceder a los elementos de un array utilizando su índice, que comienza desde 0. Por ejemplo, con el código que mostramos a continuación, en el array frutas, el elemento en el índice 0 es «manzana», el elemento en el índice 1 es «pera», y así sucesivamente:

let frutas = ["manzana", "pera", "naranja", "sandía"];

console.log(frutas[0]); // Salida: "manzana"
console.log(frutas[1]); // Salida: "pera"
console.log(frutas[2]); // Salida: "naranja"

Propiedad length

Cada array tiene una propiedad length que indica la cantidad de elementos que contiene:

let colores = ["rojo", "verde", "azul"];

console.log(colores.length); // Salida: 3

Modificación de elementos

Podemos modificar elementos de un array asignando nuevos valores a sus índices. Por ejemplo, a continuación mostramos el código necesario para cambiar el valor del segundo elemento en el array colores:

let colores = ["rojo", "verde", "azul"];

colores[1] = "amarillo";

console.log(colores); // Salida: ["rojo", "amarillo", "azul"]

Métodos de arrays

JavaScript proporciona una gran variedad de métodos incorporados para trabajar con arrays. Estos métodos nos permiten realizar operaciones como añadir, eliminar, filtrar, mapear y más, de manera muy eficiente y legible. A continuación enumeramos algunos de los métodos más importantes.

push() y pop()

• push(): Agrega elementos al final del arreglo.
• pop(): Elimina el último elemento del arreglo.

let colores = ["rojo", "verde"];

colores.push("azul");
console.log(colores); // Salida: ["rojo", "verde", "azul"]

colores.pop();
console.log(colores); // Salida: ["rojo", "verde"]

shift() y unshift()

• unshift(): Agrega elementos al inicio del arreglo.
• shift(): Elimina el primer elemento del arreglo.

let numeros = [2, 3, 4];

numeros.unshift(1);
console.log(numeros); // Salida: [1, 2, 3, 4]

numeros.shift();
console.log(numeros); // Salida: [2, 3, 4]

splice()

• Permite agregar, eliminar o reemplazar elementos en una posición específica.

let numeros = [1, 2, 3, 4, 5];

// Reemplaza 2 y 3 con 6 y 7
numeros.splice(1, 2, 6, 7);

console.log(numeros); // Salida: [1, 6, 7, 4, 5]

slice()

• Retorna una copia superficial de una porción del arreglo, sin modificar el arreglo original.

let colores = ["rojo", "verde", "azul"];

let subColores = colores.slice(1, 3);

console.log(subColores); // Salida: ["verde", "azul"]

Iteración a través de arrays

Podemos recorrer elementos de un array utilizando bucles como for, while, forEach, for...of, etc.:

let numeros = [1, 2, 3, 4, 5];
for (let i = 0; i < numeros.length; i++) {
  console.log(numeros[i]); // Imprime cada número
}

let colores = ["rojo", "verde", "azul"];
colores.forEach(function(color) {
  console.log(color); // Imprime cada color
});

Métodos de búsqueda y manipulación

indexOf() y lastIndexOf()

• indexOf(): Encuentra la primera posición de un elemento en el arreglo.
• lastIndexOf(): Encuentra la última posición de un elemento en el arreglo.

let numeros = [1, 2, 3, 2, 4, 5];

console.log(numeros.indexOf(2));      // Salida: 1
console.log(numeros.lastIndexOf(2));  // Salida: 3

includes()

• Verifica si un elemento existe en el arreglo.

let colores = ["rojo", "verde", "azul"];

console.log(colores.includes("verde")); // Salida: true
console.log(colores.includes("amarillo")); // Salida: false

join()

• Combina todos los elementos de un array en una cadena utilizando un separador:

let colores = ["rojo", "verde", "azul"];

let cadena = colores.join(", ");

console.log(cadena); // Salida: "rojo, verde, azul"

concat()

• Combina dos o más arreglos en uno nuevo.

let numeros = [1, 2, 3];
let otrosNumeros = [4, 5, 6];

let combinados = numeros.concat(otrosNumeros);

console.log(combinados); // Salida: [1, 2, 3, 4, 5, 6]

Ordenamiento de arrays

sort()

• Ordena los elementos de un arreglo en su lugar, utilizando la conversión a cadenas y la comparación de Unicode.

let frutas = ["naranja", "manzana", "plátano"];

frutas.sort();

console.log(frutas); // Salida: ["manzana", "naranja", "plátano"]

reverse()

• Invierte el orden de los elementos en el arreglo.

let numeros = [1, 2, 3, 4, 5];

numeros.reverse();

console.log(numeros); // Salida: [5, 4, 3, 2, 1]

Creación y manipulación funcional

map()

• Crea un nuevo arreglo con los resultados de aplicar una función a cada elemento del arreglo original.

let numeros = [1, 2, 3];

let duplicados = numeros.map(function(numero) {
  return numero * 2;
});

console.log(duplicados); // Salida: [2, 4, 6]

filter()

• Crea un nuevo arreglo con todos los elementos que pasen una prueba (función proporcionada).

let numeros = [1, 2, 3, 4, 5, 6];

let pares = numeros.filter(function(numero) {
  return numero % 2 === 0;
});

console.log(pares); // Salida: [2, 4, 6]

reduce()

• Aplica una función a un acumulador y a cada elemento en el arreglo (de izquierda a derecha) para reducirlo a un solo valor.

let numeros = [1, 2, 3, 4, 5];

let suma = numeros.reduce(function(acumulador, numero) {
  return acumulador + numero;
}, 0);

console.log(suma); // Salida: 15

Arreglos multidimensionales

Los arrays en JavaScript pueden contener otros arrays, lo que se conoce como arrays multidimensionales. Esto es útil cuando necesitamos trabajar con estructuras de datos más complejas, como por ejemplo matrices:

let matriz = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
];

console.log(matriz[1][2]); // Salida: 6

Copia de arrays

La asignación directa de un array a otra variable simplemente copia la referencia, no los valores. Para crear una copia independiente, podemos utilizar el operador de propagación ..., el método slice() o concat().

let original = [1, 2, 3];
let copiaSpread = [...original];
let copiaSlice = original.slice();
let copiaConcat = original.concat();

console.log(copiaSpread); // [1, 2, 3]
console.log(copiaSlice);  // [1, 2, 3]
console.log(copiaConcat); // [1, 2, 3]

Consideraciones adicionales

• Los arrays en JavaScript son dinámicos, lo que significa que puedes agregar o eliminar elementos en cualquier momento.
• Los índices negativos no están permitidos en arrays (a diferencia de algunos lenguajes de programación como python).

Conclusión

Los arreglos en JavaScript son herramientas fundamentales para trabajar con colecciones de datos de manera organizada y eficiente. Puedes acceder, modificar y utilizar los elementos de un arreglo a través de índices, y aprovechar los métodos integrados para realizar operaciones comunes. Los arreglos te permiten gestionar datos de manera más estructurada, lo que es esencial para desarrollar aplicaciones más robustas y funcionales.

Test

Comprueba tus conocimientos con este test sobre arrays y otros conceptos relacionados con esta unidad.

Los bucles son estructuras fundamentales en la programación que permiten ejecutar repetidamente un bloque de código hasta que se cumpla una condición específica. En JavaScript, hay varias formas de implementar bucles, cada una con sus propias características y usos. A continuación mostramos explicaciones y ejemplos detallados para que puedas entender cómo funcionan los bucles en JavaScript.

Tipos de bucles en JavaScript

Bucle «while»

El bucle while repite un bloque de código mientras una condición especificada sea verdadera. La condición se verifica antes de cada iteración:

while (condición) {
  // Código a ejecutar en cada iteración
}

Por ejemplo:

let contador = 0;
while (contador < 5) {
  console.log(contador); // Imprime los números del 0 al 4
  contador++;
}

• Condición (contador < 5): La condición se verifica antes de cada iteración. Mientras contador sea menor que 5, el bucle continuará ejecutándose.
• Bloque de código: Dentro del bucle, se imprime el valor actual de contador y luego se incrementa en 1.

Bucle «do…while»

El bucle do...while es similar al while, pero garantiza que el bloque de código se ejecute al menos una vez, ya que la condición se verifica después de cada iteración:

do {
  // Código a ejecutar en cada iteración
} while (condición);

Por ejemplo:

let x = 0;
do {
  console.log(x); // Imprime 0 (al menos una vez)
  x++;
} while (x < 0);

• Bloque de código: Dentro del bucle, se imprime el valor actual de x y luego se incrementa en 1.
• Condición (x < 0): Después de cada iteración, se verifica la condición. Aunque x es 1 en la primera iteración y no cumple la condición, el bloque de código se ejecuta al menos una vez.

Bucle «for»

El bucle for es una estructura común utilizada para repetir un bloque de código un número específico de veces. Consiste en tres partes: la inicialización, la condición y la actualización:

for (inicialización; condición; actualización) {
  // Código a ejecutar en cada iteración
}

Por ejemplo:

for (let i = 0; i < 5; i++) {
  console.log(i); // Imprime los números del 0 al 4
}

• Inicialización (let i = 0): Se define una variable i e inicia a 0 antes de comenzar el bucle.
• Condición (i < 5): La condición se verifica antes de cada iteración. Mientras i sea menor que 5, el bucle continuará ejecutándose.
• Actualización (i++): Después de cada iteración, se incrementa el valor de i en 1.

Control de bucles

break

La sentencia break se utiliza para finalizar prematuramente un bucle antes de que se cumpla la condición. Por ejemplo, en el siguiente código, cuando i es igual a 5, se ejecuta break, lo que detiene el bucle for y sale del mismo:

for (let i = 0; i < 10; i++) {
  if (i === 5) {
    break; // Termina el bucle cuando i llega a 5
  }
  console.log(i); // Imprime los números del 0 al 4
}

continue

La sentencia continue se utiliza para saltar una iteración y continuar con la siguiente. Por ejemplo, en el siguiente código, cuando i es igual a 2, se ejecuta continue, lo que salta la iteración actual y pasa a la siguiente:

for (let i = 0; i < 5; i++) {
  if (i === 2) {
    continue; // Salta la iteración cuando i es 2
  }
  console.log(i); // Imprime los números 0, 1, 3, 4
}

Bucles anidados

Es posible anidar bucles dentro de otros bucles para realizar tareas más complejas. Los bucles anidados ejecutan el bucle interno completamente para cada iteración del bucle externo. Por ejemplo:

for (let i = 0; i < 3; i++) {
  for (let j = 0; j < 2; j++) {
    console.log(i, j); // Imprime todas las combinaciones de i y j
  }
}

• El bucle exterior for itera tres veces (i = 0, 1, 2).
• Para cada iteración del bucle exterior, el bucle interior for se ejecuta dos veces (j = 0, 1).
• Se imprimen todas las combinaciones posibles de i y j.

Bucles con arrays y objetos

Podemos recorrer todos los elementos de una colección de datos usando un bucle «for» con un contador para incrementar el índice de cada elemento y la propiedad length para comprobar la cantidad total de elementos. Por ejemplo, en el siguiente código imprimimos todos los elementos del array frutas utilizando un bucle for:

let frutas = ["manzana", "banana", "naranja"];

for (let i = 0; i < frutas.length; i++) {
  console.log(frutas[i]); // Imprime los elementos del array
}

• El bucle for itera a través de los índices del array frutas.
• Se utiliza la propiedad length del array para definir la condición de terminación del bucle.
• frutas[i] accede al elemento en el índice i y lo imprime en cada iteración.

Sin embargo, JavaScript nos proporciona otro tipo de bucles que resultan más adecuados para iterar sobre colecciones de datos. Tanto el bucle for...of como el bucle for...in tienen ventajas y casos de uso específicos en comparación con un bucle for tradicional en JavaScript. A continuación añadimos una explicación de cuándo y por qué podríamos preferir usar for...of o for...in en lugar de un bucle for estándar.

Bucle «for…of»

Este tipo de bucle está diseñado específicamente para iterar sobre elementos de colecciones iterables, como arrays y cadenas. A continuación enumeramos algunas razones para usar for...of:

1. Sintaxis más clara: La sintaxis es más sencilla y fácil de entender que un bucle for tradicional.
2. No necesita utilizar índices: No es necesario utilizar un contador de índices separado, lo que reduce los errores potenciales.
3. Iteración en orden: Itera sobre los elementos en el orden en que aparecen en la colección, lo que lo hace especialmente útil para trabajar con arrays.
4. Soporte para iterables: Podemos usarlo con cualquier objeto iterable, no solo con arrays. Esto incluye cadenas, mapas y conjuntos.

let colores = ["rojo", "verde", "azul"];

for (let color of colores) {
  console.log(color); // Imprime los elementos del array
}

Bucle «for…in»

Este bucle está diseñado para trabajar con objetos, ya que nos aporta las siguientes ventajas:

1. Iteración sobre las propiedades de un objeto: Nos permite recorrer todas las propiedades de un objeto.
2. Acceso a las propiedades de objetos genéricos: Nos permite trabajar con objetos genéricos cuyas propiedades no son conocidas de antemano.
3. Manipulación de propiedades: Podemos modificar o realizar operaciones en las propiedades del objeto mientras iteramos sobre ellas.

const persona = {
  nombre: 'Alicia',
  edad: 30,
  trabajo: 'Ingeniera'
};

for (const propiedad in persona) {
  console.log(`${propiedad}: ${persona[propiedad]}`); // Imprime las propiedades y los valores
}

En resumen, el bucle for...in es adecuado cuando necesitamos iterar sobre las propiedades de un objeto, especialmente si las propiedades son dinámicas o desconocidas de antemano.

Bucle «forEach»

Los bucles forEach nos proporcionan una forma aún más legible y adecuada para iterar a través de los elementos de un array en JavaScript. En el siguiente ejemplo podemos apreciar la diferencia respecto a un bucle for tradicional:

let frutas = ["manzana", "banana", "naranja"];

for (let indice = 0; indice < frutas.length; indice++) {
  console.log(`Índice ${indice}: ${frutas[indice]}`); // Imprime los elementos del array
}

frutas.forEach(function(fruta, indice) {
  console.log(`Índice ${indice}: ${fruta}`); // Imprime los elementos del array
});

// Salida:
// Índice 0: manzana
// Índice 1: banana
// Índice 2: naranja

Estas son algunas de las razones por las cuales podríamos preferir usar el bucle forEach en lugar de un bucle for tradicional:

1. Enfocado a la iteración: El bucle forEach está diseñado específicamente para la iteración sobre los elementos de una colección (por ejemplo, un array). Esto hace que el código sea más expresivo y se centre en la tarea de iterar, en lugar de en la manipulación de índices.
2. Menos propenso a errores: Al eliminar la necesidad de rastrear índices manualmente, reducimos la probabilidad de errores comunes, como errores de límites de índice y problemas de incremento/decremento incorrecto.
3. No se necesita lógica de salida: En un bucle for tradicional debemos incluir lógica adicional para controlar la salida del bucle. En un bucle forEach esta funcionalidad se incluye de manera automática.

En general, los bucles forEach nos proporcionarán una sintaxis más clara y concisa, ya que no necesitamos inicializar y actualizar manualmente un contador de índices, ni tampoco debemos incluir una lógica de salida del bucle, lo que puede hacer que el código sea más legible y menos propenso a errores.

Uso de funciones flecha en bucles «forEach»

En lugar de utilizar una función anónima tradicional, también podemos utilizar funciones flecha (=>) para hacer el código más conciso, como se observa en el siguiente ejemplo:

let frutas = ["manzana", "banana", "naranja"];

frutas.forEach((fruta, indice) => {
  console.log(`Índice ${indice}: ${fruta}`);
});

Modificando elementos en bucles «forEach»

No sólo podemos usar un bucle forEach para consultar todos los elementos de un array, sino que también podemos realizar modificaciones sobre cada uno de ellos. Bastará con utilizar el índice para acceder a los valores correspondientes y realizar las operaciones oportunas, como se observa en el siguiente ejemplo:

let numeros = [1, 2, 3, 4, 5];

numeros.forEach(function(numero, indice, array) {
  array[indice] = numero * 2;
});

console.log(numeros); // Salida: [2, 4, 6, 8, 10]

Limitaciones del bucle «forEach»

Si bien el bucle forEach tiene muchas ventajas, es importante señalar que también tiene algunas limitaciones en comparación con un bucle for tradicional. Por ejemplo, no podemos realizar saltos anticipados utilizando break o continue directamente en un bucle forEach. A continuación mostraremos posibles alternativas para conseguir el mismo comportamiento.

Utilizando return dentro de un bucle «forEach»

En el siguiente bucle for se puede observar el uso de la instrucción continue para realizar un salto condicional cuando se encuentra cierto valor:

const array = [1, 2, 3, 4, 5];

for (let i = 0; i < array.length; i++) {
  const item = array[i];

  if (item === 3) {
    console.log("Saltando a la siguiente iteración");
    continue; // Esto omite la ejecución de la iteración actual
  }

  console.log(item);
}
// Salida: 1 2 4 5

Aunque el bucle forEach no tiene un equivalente directo a la palabra clave continue, podemos lograr un comportamiento similar utilizando una estructura de control if para omitir la ejecución de ciertas iteraciones del bucle. En el siguiente ejemplo utilizamos return para salir anticipadamente de la iteración actual y continuar con la siguiente iteración cuando el valor del elemento es igual a 3:

const array = [1, 2, 3, 4, 5];

array.forEach(item => {
  if (item === 3) {
    console.log("Saltando esta iteración");
    return; // Esto omite la ejecución de la iteración actual, similar a un continue
  }

  console.log(item);
});
// Salida: 1 2 4 5

Debemos tener en cuenta que el uso de return dentro de una función forEach simplemente finaliza la función de la iteración actual, lo que resulta en un efecto similar a continue. Sin embargo, esta no es una característica específica de forEach, sino una aplicación de cómo funciona return en funciones en general.

Usando un bucle «some» en vez de «forEach»

A continuación mostramos un bucle for donde se puede observar el uso de la instrucción break para finalizar el bucle cuando se encuentra el valor deseado:

const array = [1, 2, 3, 4, 5];

for (let i = 0; i < array.length; i++) {
  const item = array[i];

  if (item === 3) {
    console.log("Saltando el bucle");
    break; // Esto finaliza el bucle for
  }

  console.log(item);
}
// Salida: 1 2

Si queremos salir anticipadamente de un bucle cuando estamos iterando sobre un array, podemos usar el método some() para lograr el comportamiento deseado. En el siguiente ejemplo, si se encuentra un valor igual a 3, se muestra un mensaje y se devuelve true, lo que finaliza el bucle. Si no se encuentra el valor, la iteración continúa:

const array = [1, 2, 3, 4, 5];

array.some(item => {
  if (item === 3) {
    console.log("Saliendo del bucle");
    return true; // Esto finaliza el bucle
  }

  console.log(item);
  return false; // Continúa iterando
});
// Salida: 1 2

Usos comunes de forEach

• Realizar operaciones en cada elemento de un array.
• Imprimir elementos de un array con formato personalizado.
• Invocar llamadas a funciones para cada elemento de un array.

En resumen, el bucle forEach es una herramienta útil para iterar a través de elementos de un array de manera más simple y legible. Resulta especialmente útil para realizar operaciones en cada elemento sin necesidad de un contador de índice. Sin embargo, si necesitamos más control sobre la iteración, como detenerla anticipadamente o realizar modificaciones complejas en el array, es posible que prefiramos utilizar otros tipos de bucles. La elección entre usar un bucle tradicional y un bucle forEach dependerá del contexto y de las necesidades específicas en cada situación.

Test

Comprueba tus conocimientos con este test sobre bucles y otros conceptos relacionados con esta unidad.