Contenido del curso
Primeros Pasos
- 5

¡Hola Mundo!
06:13 min - 6

Anatomía de una variable
09:23 min - 7

Tipos de datos: Mutabilidad e inmutabilidad
10:55 min - 8

Paso por valor
11:06 min - 9

Paso por referencia
07:00 min - 10

Creación de strings
11:33 min - 11

Concatenación de strings
08:31 min - 12

Manipulación de strings
12:13 min - 13

Tipo de dato primitivo: number
09:30 min - 14

Conversión a Booleanos
05:08 min - 15

Tipos de datos primitivos: null, undefined, symbol y bigint
07:28 min - 16

Conversión de tipos: Type Casting y Coercion
04:38 min - 17

Conversión de tipos explícita e implícita
12:20 min - 18

Proyecto: Crea un perfil para redes sociales con JavaScript
07:23 min
Funciones y This
- 19

Anatomía de una función
11:39 min - 20

Preguntas a Desarrolladores Senior: ¿Por qué aprender Desarrollo Web?
02:11 min - 21

Funciones vs Métodos
10:01 min - 22

Funciones puras e impuras
11:22 min - 23

Identificador this
11:38 min - 24

Métodos bind, call y apply
10:09 min - 25

Funciones flecha y enlace léxico
10:31 min - 26

Implicaciones de duplicar código
03:19 min - 27

Funciones constructoras
10:41 min - 28

10 Tipos de funciones
01:39 min - 29

Objeto window y modo estricto
07:37 min - 30

Tipos de binding
01:11 min - 31

Expresiones vs Sentencias
04:02 min - 32

Proyecto: Crea biografías de personajes con JavaScript
12:51 min
Lógica y ciclos
- 33

Operadores de comparación
06:12 min - 34

Operadores lógicos
04:33 min - 35

Ejecución condicional: if
07:45 min - 36

Proyecto: Adivina el número
09:36 min - 37

Ejecución condicional: ternario
05:24 min - 38

Ejecución condicional: switch
12:08 min - 39

Loop: for
07:31 min - 40

Loop: forEach
03:57 min - 41

Loop: for of
04:26 min - 42

Loop: for in
07:38 min - 43

Loop: while
03:56 min - 44

Loop: do while
03:13 min - 45

Proyecto: Juego adivina la palabra
15:56 min
Fundamentos de arrays y modificación
- 46

Introducción a Arrays
09:09 min - 47

Mutabilidad e inmutabiliad de Arrays
07:56 min - 48

Modificación básica del final con push(), pop()
04:33 min - 49

Ejercicio: Stack de libros
16:03 min - 50

Modificación del principio con shift(), unshift()
10:21 min - 51

Modificación avanzada con splice(), reverse(), sort(), fill()
16:37 min - 52

Proyecto: Juego de cartas
15:37 min - 53

Preguntas a Desarrolladores Senior: Estrategias y métodos de estudio
01:10 min
Iteración de Arrays
- 54

Iteración con map() y forEach()
12:53 min - 55

Filtrado y reducción con filter() y reduce()
11:34 min - 56

Ejercicio: Calificación promedio aprobatoria
05:27 min - 57

Búsqueda de elementos con find() y findIndex()
03:52 min - 58

Ejercicio: Encuentra al ganador de una rifa
Viendo ahora - 59

Proyecto: Análisis de transacciones
10:55 min - 60

Proyecto: Análisis de transacciones parte 2
08:01 min
Métodos específicos y Operaciones
- 61

Unir y entrelazar con concat(), spread operator y join()
12:05 min - 62

Verificación y evaluación con every() y some()
05:15 min - 63

Métodos de búsqueda con includes(), indexOf() y lastIndexOf()
07:05 min - 64

Ejercicio: Encontrando los índices
11:09 min - 65

Crear copias con slice()
05:28 min - 66

Spread operator: casos de uso
07:11 min
Arrays multidimencionales
Clases y Objetos
- 71

Anatomia de un Objeto
06:48 min - 72

Trabajando con objetos
12:52 min - 73

Función constructora
14:31 min - 74

¿Qué es una clase?
06:17 min - 75

Prototipos y herencias
02:15 min - 76

Herencia en la práctica
15:38 min - 77

Prototipos en la práctica
10:42 min - 78

this en JavaScript
05:36 min - 79

Proyecto: Crea una red social
12:25 min - 80

Proyecto: Crea una red social parte 2
09:00 min
Ejercicio: Encuentra al ganador de una rifa
Resumen
Buscar elementos dentro de un arreglo es una tarea frecuente en programación, y JavaScript ofrece métodos específicos que facilitan esta labor. A través de un ejercicio práctico de verificación de ganadores de una rifa, se exploran dos métodos fundamentales: find y findIndex, aplicados sobre un arreglo de objetos con datos reales como nombre y número de tiquete.
¿Cómo estructurar una lista de participantes ganadores?
El primer paso consiste en definir una constante llamada winningParticipants que almacena un arreglo de objetos [0:52]. Cada objeto representa a un participante con tres propiedades: un id, un name y un ticketNumber. Esta estructura permite agrupar múltiples datos relacionados dentro de un mismo elemento.
javascript const winningParticipants = [ { id: 1, name: "Jennifer", ticketNumber: "001" }, { id: 15, name: "Michael", ticketNumber: "008" }, { id: 15, name: "Emily", ticketNumber: "013" }, { id: 47, name: "Charlie", ticketNumber: "047" } ];
Cada participante es un objeto literal con pares clave-valor. Esta forma de organizar datos resulta muy útil cuando se necesita acceder a propiedades específicas mediante la notación de punto.
¿Cómo buscar un ganador por nombre usando find?
El método find recorre el arreglo y devuelve el primer elemento que cumple la condición indicada [2:30]. Se crea una función findWinnerByName que recibe un nombre como parámetro y lo compara con la propiedad name de cada participante.
javascript function findWinnerByName(name) { const winner = winningParticipants.find( participant => participant.name === name ); return winner || "No winner found with this name"; }
El operador lógico || actúa como alternativa: si find no encuentra coincidencias, retorna undefined, y entonces se devuelve la cadena de texto indicando que no hay ganador [3:28]. Este patrón de valor por defecto es muy común para manejar resultados vacíos sin que el programa falle.
¿Cómo localizar un ganador por número de tiquete con findIndex?
A diferencia de find, el método findIndex no retorna el elemento sino su posición dentro del arreglo [4:10]. Se crea la función findIndexWinnerByTicket que recibe el ticketNumber como parámetro.
javascript function findIndexWinnerByTicket(ticketNumber) { const index = winningParticipants.findIndex( participant => participant.ticketNumber === ticketNumber ); return index !== -1 ? index : "No winner found with that ticket number"; }
Cuando findIndex no encuentra el elemento, retorna -1 [5:20]. Por eso se valida con !== -1: si es diferente de menos uno, el participante existe y se devuelve su índice. Si no, se retorna el mensaje de error. El operador ternario simplifica esta lógica en una sola línea.
¿Cómo mostrar la información del ganador?
Se define una función displayWinnerInformation que recibe al ganador y valida que sea diferente de undefined, de null y del mensaje de no encontrado [6:35].
javascript function displayWinnerInformation(winner) { if (winner !== undefined && winner !== null && winner !== "No winner found") { console.log("Winner information:", winner); } else { console.log("No winner found"); } }
Esta triple validación garantiza que solo se imprima información cuando realmente exista un ganador válido.
¿Qué resultados arroja la ejecución?
Al buscar por nombre con "Emily", el programa retorna el objeto completo con su id, name y ticketNumber [8:00]. Al buscar por un tiquete inexistente como "005", devuelve el mensaje de que no se encontró ganador. Cambiando a "008", el resultado es el índice 1, confirmando que Michael ocupa esa posición en el arreglo [9:05].
javascript const winnerByName = findWinnerByName("Emily"); const indexWinnerByTicket = findIndexWinnerByTicket("008");
displayWinnerInformation(winnerByName); console.log("Index of winner by ticket number:", indexWinnerByTicket);
La diferencia práctica entre ambos métodos es clara: find entrega el objeto completo, mientras que findIndex entrega la posición numérica. Elegir uno u otro depende de si necesitas los datos del elemento o su ubicación dentro del arreglo. ¿Qué otros métodos de búsqueda en arreglos has utilizado en tus proyectos?