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
Viendo ahora - 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
11:21 min - 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
Proyecto: Juego de cartas
Resumen
¿Cómo implementar un juego de cartas usando JavaScript?
Crear un juego de cartas en JavaScript no solo es divertido, sino que también es una excelente manera de aplicar habilidades de programación a un problema del mundo real. Este tutorial te mostrará cómo implementar algunas operaciones básicas para un juego de cartas: barajar el mazo y repartir cartas entre los jugadores.
¿Cómo definir el mazo de cartas?
El primer paso es crear un array que represente el mazo de cartas. Este array puede contener números, nombres simbólicos o representaciones gráficas:
const deck = ['As de corazones', 'Rey de tréboles', 'Reina de diamantes', 'Jota de picas', '10 de corazones', '9 de tréboles', '8 de diamantes', '7 de picas', '6 de corazones', '5 de tréboles', '4 de diamantes', '3 de picas', '2 de corazones', 'As de tréboles', 'Rey de diamantes', 'Reina de picas', 'Jota de corazones', '10 de tréboles', '9 de diamantes', '8 de picas', '7 de corazones', '6 de tréboles', '5 de diamantes', '4 de picas', '3 de corazones', '2 de tréboles', 'As de diamantes', 'Rey de picas', 'Reina de corazones', 'Jota de tréboles', '10 de diamantes', '9 de picas', '8 de corazones', '7 de tréboles', '6 de diamantes', '5 de picas', '4 de corazones', '3 de tréboles', '2 de diamantes', 'As de picas', 'Rey de corazones', 'Reina de tréboles', 'Jota de diamantes', '10 de picas', '9 de corazones', '8 de tréboles', '7 de diamantes', '6 de picas', '5 de corazones', '4 de tréboles', '3 de diamantes', '2 de picas'];
¿Cómo barajar el mazo?
Barajar el mazo es una operación que implica reorganizar las cartas de manera aleatoria. Esto se puede lograr implementando el algoritmo de Fisher-Yates:
function shuffleDeck(deck) { for (let i = deck.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [deck[i], deck[j]] = [deck[j], deck[i]]; } }
¿Cómo repartir cartas a los jugadores?
Para repartir las cartas, primero debes decidir cuántas cartas recibirá cada jugador. Esto se puede hacer con la función splice(), que modifica el array original:
function dealCards(deck, numberOfCards) { return deck.splice(0, numberOfCards); } // Ejemplo de uso: const player1Hand = dealCards(deck, 3); const player2Hand = dealCards(deck, 3);
¿Cómo utilizar la función Splice?
El método splice() es crucial aquí, ya que:
- Elimina elementos del array original.
- Retorna un nuevo array con los elementos eliminados.
Esta funcionalidad es ideal para repartir cartas, ya que permite asignar partes del mazo a cada jugador y adaptarse a la cantidad de cartas disponible.
¿Cómo ejecutar y probar el código?
Asegúrate de barajar el mazo antes de intentar repartir las cartas:
shuffleDeck(deck); const player1 = dealCards(deck, 3); const player2 = dealCards(deck, 3); console.log('Player 1:', player1); console.log('Player 2:', player2);
Si ejecutas estas funciones en un entorno de Node.js o en el navegador, deberías ver la mano de cartas de cada jugador presentada al azar.
Consideraciones finales
Asegúrate de manejar adecuadamente los errores, como cuando no hay suficientes cartas para repartir entre todos los jugadores. También, considera aumentar el mazo para hacerlo más realista, especialmente si tienes más de dos jugadores o si cada jugador recibe más de tres cartas. Con estas ideas y herramientas, estás listo para crear un juego de cartas en JavaScript que pueda variar desde lo más simple hasta lo más complejo. ¡Anímate a seguir personalizando y mejorando tu implementación!