Introducción a JavaScript

1

¿Por qué aprender JavaScript?

2

¡Hola Mundo! en Mac

3

¡Hola Mundo! en Windows

4

Anatomía de una variable

5

Tipos de datos en JavaScript

6

Creación de strings

7

Operadores aritméticos

8

Conversión de tipos: Type Casting y Coerción

9

Conversión de tipos explícita e implícita

Estructuras de Control y Lógica

10

Operadores de comparación

11

Operadores lógicos

12

Ejecución condicional: if

13

Ejercicio: Adivina el número

14

Ejecución condicional: switch

15

Loop: for

16

Loop: for of

17

Loop: for in

18

Loop: while

19

Loop: do while

Funciones y This

20

Anatomía de una función

21

Funciones vs Métodos

22

Funciones puras e impuras

23

Arrow function y enlace léxico

24

Contextos de ejecución y scope chain

25

¿Qué es Closure?

26

Preguntas a Desarrolladores Senior: ¿Por qué aprender Desarrollo Web?

Manipulación de Arrays

27

Introducción a Arrays

28

Mutabilidad e inmutabilidad de Arrays

29

Modificación básica del final con push( ), pop( )

30

Iteración con map( ) y forEach( )

31

Filtrado y reducción con filter( ) y reduce( )

32

Búsqueda de elementos con find( ) y findIndex( )

33

Crear copias con slice( )

34

Spread operator: casos de uso

Programación Orientada a Objetos

35

Anatomía de un Objeto

36

Trabajando con objetos en JavaScript

37

Función constructora

38

¿Qué es una clase?

39

Prototipos y herencias

40

Herencia en la práctica

41

Prototipos en la práctica

42

this en JavaScript

43

Proyecto: Crea una red social

44

Proyecto: Crea una red social parte 2

Asincronía en JavaScript

45

¿Cómo funciona el JavaScript Engine?

46

Promesas en JavaScript

47

Usando Async y await en JavaScript

48

For await of

49

¿Cómo funciona la web?

50

¿Cómo funciona HTTP?

51

Método GET en JavaScript

52

Método POST en JavaScript

53

Método DELETE en JavaScript

54

Importancia del id en el método DELETE

55

ECMAScript 6 y tus siguientes pasos

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Conversión de tipos: Type Casting y Coerción

8/55
Recursos

¿Qué es la conversión de tipos en JavaScript?

La conversión de tipos es un concepto fundamental en JavaScript, un lenguaje de programación caracterizado por su flexibilidad y capacidad para adaptarse a diferentes tipos de datos durante la ejecución del código. Este proceso es esencial porque el código que escribimos como seres humanos debe ser traducido para que sea comprensible para el programa de ordenador. JavaScript, un lenguaje interpretado, maneja esta conversión de manera dinámica, lo que significa que decide cómo tratar los tipos de datos sobre la marcha, mientras el código se ejecuta.

¿Cómo funciona JavaScript como lenguaje interpretado?

JavaScript es un ejemplo clásico de un lenguaje interpretado. A diferencia de los lenguajes compilados como C o Swift, donde el código es traducido completamente antes de ejecutarse, JavaScript traduce su código conforme se ejecuta. Esto se asemeja a tener a alguien traduciendo instrucciones a medida que cocinamos, versus tener la receta ya traducida antes de empezar. Este enfoque permite a JavaScript ser altamente flexible, pero también implica que el chequeo de tipos sucede de manera dinámica.

¿Qué significa que JavaScript tenga un "tipado débil"?

El tipado débil es una de las características que distingue a JavaScript. Esto significa que JavaScript permite más flexibilidad al asignar valores a las variables. Por ejemplo, puedes asignar un número a una variable y luego asignar un string al mismo espacio de memoria sin errores. Así, JavaScript maneja situaciones inusuales, como sumar un número y un valor booleano, mediante la conversión implícita de tipos, convirtiendo los valores a un tipo compatible para seguir la ejecución.

const numero = 2;
const booleano = true;
const resultado = numero + booleano; // Esto resulta en 3

En este ejemplo, JavaScript convierte el booleano true a un número 1 para realizar la operación de suma.

¿Cuáles son los tipos de conversión en JavaScript?

JavaScript permite dos tipos de conversión: implícita y explícita.

  • Conversión implícita: JavaScript realiza automáticamente sin que el programador precise intervención, como en el caso de sumar un número con un booleano.

  • Conversión explícita: El programador decide convertir manualmente un tipo de dato a otro, por ejemplo, transformando un booleano en un string o en un número.

let booleano = true;
let booleanToString = booleano.toString(); // convierte a "true"
let booleanToNumber = Number(booleano); // convierte a 1

¿Por qué es importante entender la conversión de tipos?

Comprender la conversión de tipos en JavaScript es crucial para evitar errores durante la ejecución, especialmente cuando el lenguaje realiza conversiones implícitas que pueden llevar a resultados inesperados. Saber cuándo y cómo utilizar la conversión explícita te permitirá tener un mayor control sobre cómo se manejan los datos en tus aplicaciones, mejorando la calidad y eficacia de tu código.

La conversión de tipos es un tema importante que obliga a los desarrolladores a ser conscientes de las implicaciones de cómo se manejan los datos en un lenguaje tan dinámico como JavaScript. Dominar este concepto te permitirá navegar con mayor confianza en el mundo del desarrollo web, optimizando tus soluciones y mejorando tu experiencia de codificación. ¡Sigue explorando y perfeccionando tus habilidades!

Aportes 17

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Conversión de Tipos en JavaScript

  • La conversión de tipos en JavaScript es fundamental y una característica distintiva del lenguaje.
  • JavaScript utiliza tanto compiladores como intérpretes para traducir el código escrito por los programadores en un formato que el computador pueda entender.
  • Los lenguajes de programación se dividen en compilados (e.g., C, C++, Rust, Go, Swift) y los interpretados (e.g., JavaScript, Python, Ruby, PHP).

Lenguajes Compilados vs Interpretados

  • Lenguajes compilados: El código es traducido antes de la ejecución del programa. Ejemplos: C, C++, Rust, Go, Swift.
  • Lenguajes interpretados: El código es traducido a medida que se va ejecutando el programa. Ejemplos: JavaScript, Python, Ruby, PHP.

Analogía de Compilador e Intérprete

  • Compilador: Es como tener una receta de cocina ya traducida.
  • Intérprete: Es como tener un amigo que traduce la receta en tiempo real mientras cocinamos.

Chequeo de Tipos

  • En los lenguajes compilados, ocurre un chequeo estático de tipos antes de la ejecución.
  • En los lenguajes interpretados, ocurre un chequeo dinámico de tipos durante la ejecución del programa.

Tipado Débil en JavaScript

  • JavaScript permite cambiar el tipo de una variable en tiempo de ejecución.

  • Ejemplo:

    let variable = 2;  // tipo number
    variable = "Hola";  // tipo string
    

Conversión Implícita y Explícita

  • Conversión implícita: JavaScript convierte los tipos automáticamente durante la ejecución.
  • Conversión explícita: El programador convierte los tipos manualmente según sea necesario.

Ejemplo de Conversión Implícita

const numero = 2;
const booleano = true;
const resultado = numero + booleano;  // resultado es 3 (número + booleano se convierte a número)
console.log(resultado);  // 3

Ejemplo de Conversión Explícita

const booleano = true;
const stringBooleano = String(booleano);  // convierte booleano a string
console.log(stringBooleano);  // "true"

const numeroString = "123";
const numero = Number(numeroString);  // convierte string a número
console.log(numero);  // 123

Errores Comunes en JavaScript

  • JavaScript ejecuta el código línea por línea y los errores pueden surgir en tiempo de ejecución.

  • Ejemplo de un error:

    const titulo = 'Mi título;  // falta cerrar comilla simple
    console.log(titulo);  // Error: Uncaught SyntaxError: Invalid or unexpected token
    

Próximos Pasos

  • Explorar y practicar con conversiones de tipos tanto implícitas como explícitas en JavaScript.
  • Consultar la documentación oficial de JavaScript para entender mejor cómo y cuándo ocurren las conversiones de tipos.
  • Implementar ejemplos en tus proyectos para consolidar el conocimiento sobre la conversión de tipos.
Efectivamente falta la clase en donde explica desde el editor de código. Les comparto lo que anote de la versión anterior del curso: ```js /* Explicit Type Casting */ // Convertir string a entero const string = '42' const integer = parseInt(string) console.log(integer, typeof integer) // Convertir de string a decimal const stringDecimal = '3.14' const decimal = parseFloat(stringDecimal) console.log(decimal, typeof decimal) // Convertir de decimal a binario const binary = '1010' const decimalBinary = parseInt(binary, 2) console.log(decimalBinary, typeof decimalBinary) /* Implicit Type Casting */ // Sumar string con un entero const sum = '5' + 3 console.log(sum) // -> 53 // Sumar un string con un booleano const sumWhitBoolean = '5' + true console.log(sumWhitBoolean) // --> 5true // Sumar un entero con un booleano const sumWhitBooleannumber = 5 + true console.log(sumWhitBooleannumber) // --> 6 // Sumar un valor nulo con un NaN (Not a Number) const sumNulls = null + NaN console.log(sumNulls) // --> NaN ```/\* Explicit Type Casting\*/ // Convertir string a enteroconst string = '42'const integer = parseInt(string)console.log(integer, typeof integer) // Convertir de string a decimalconst stringDecimal = '3.14'const decimal = parseFloat(stringDecimal)console.log(decimal, typeof decimal) // Convertir de decimal a binarioconst binary = '1010'const decimalBinary = parseInt(binary, 2)console.log(decimalBinary, typeof decimalBinary) /\*    Implicit Type Casting   \*/ // Sumar string con un enteroconst sum = '5' + 3console.log(sum) // -> 53 // Sumar un string con un booleanoconst sumWhitBoolean = '5' + trueconsole.log(sumWhitBoolean) // --> 5true // Sumar un entero con un booleanoconst sumWhitBooleannumber = 5 + trueconsole.log(sumWhitBooleannumber) // --> 6 // Sumar un valor nulo con un NaN (Not a Number)const sumNulls = null + NaNconsole.log(sumNulls) // --> NaN
por favor falta la clase que anuncia en este video.
Les traigo un aporte de una pagina web donde encontre información de la conversión: **Conversión de tipos** En JavaScript existen dos tipos de coacción: * Explícita: Es cuando convertimos un valor a otro de manera apropiada (String, Number, etc) * Implícita: Cuando se convierten los valores de manera “automática”, y comúnmente es cuando aplicamos los operadores de valores diferentes (true + false, “hola” + 2 + 3, etc), y también cuando aplicamos if(value) {}, donde se hace coacción es el valor a un booleano. Sin importar si es explícita o implícita la coerción, así sean primitivos u objetos, SIEMPRE se van a convertir en los siguientes 3 tipos: * Cadena (string) * Booleano (boolean) * Numérico (Number) ### **Cadena (string)** Para hacer coerción explícita debemos usar String() y para aplicar la coerción implícita es usando el operador + ![]()![](https://static.platzi.com/media/user_upload/image-365416b7-729e-4432-ab99-37da82a36b2c.jpg) ![]()**Booleano (boolean)** Para hacer coerción explícita debemos usar Boolean() y para aplicar la coerción implícita es usando los operadores lógicos ||, &&, !. ![](https://static.platzi.com/media/user_upload/image-ae610f0f-9310-449d-bc22-3126dc9b133f.jpg) ### **Numérico (number)** Para hacer coerción explícita debemos usar Number() y para aplicar la coerción implícita tenemos que tomar en cuenta el operador: * Operadores de comparación (>, <, <=, >=) * Operadores bitwise (|, &, ^, ~) * Operadores aritméticos (-, +, \*, /, %), el operador + no activa la conversión numérica cuando es una cadena (el resultado lo concatena) * Operador de igualdad flexible (==, !=), == no aplica la conversión numérica cuando ambos son cadenas. ![](https://static.platzi.com/media/user_upload/image-a91c5dda-3306-43d2-9208-d8108a8f2da2.jpg)
Al parecer esta clase quedo incompleta... solo presenta el punto teórico y anuncia al final que se va a ver su operación en código, pero salta el nuevo video secuencial a otro tema. Error de continuidad
Como han dicho por aca, aparentemente hay un error de continuidad con la clase. Sin embargo por si les es util, estos eran mis apuntes de esta clase, en lo que lo solucionan. ![](https://static.platzi.com/media/user_upload/image-2179d78a-ea76-43bb-a91c-704bc6f3780f.jpg) ![]()![]()![](https://static.platzi.com/media/user_upload/image-8d44d2b6-2964-4086-949c-c20c72e2d5ae.jpg)
y aqui la razon de utilizar TypeScript
En JavaScript, la **coerción de tipos** es el proceso en el que el lenguaje convierte automáticamente un valor de un tipo a otro. Esto sucede, por ejemplo, cuando sumas un número y una cadena de texto; JavaScript convierte el número en una cadena para poder realizar la operación. Por otro lado, la **conversión de tipos** es cuando tú, como programador, decides convertir explícitamente un valor de un tipo a otro. Esto lo haces usando funciones como `String()`, `Number()`, o `Boolean()`
C# es un lenguaje de programación de tipado estático y fuerte. Esto significa que el tipo de cada variable debe ser declarado explícitamente al momento de su creación y no puede cambiar a lo largo de la ejecución del programa. A diferencia de JavaScript, que tiene un tipado dinámico y débil, donde los tipos de datos pueden cambiar y ser convertidos implícitamente. C# se utiliza comúnmente para desarrollar aplicaciones de escritorio, web y móviles, ofreciendo un control más estricto sobre los tipos de datos, lo que puede ayudar a prevenir errores en tiempo de ejecución.
Java que tipo de lenguaje sería
En JavaScript, al convertir un número de binario a decimal, se utiliza `parseInt` con una base especificada. En este caso, la base 2 indica que el número que se está convirtiendo está en sistema binario. Esto es crucial porque `parseInt` necesita saber en qué sistema numérico está representado el número original para realizar la conversión correctamente. Si se omite la base, `parseInt` asumirá la base 10 por defecto, lo que daría lugar a un resultado incorrecto.
Muchas gracias Estefany como siempre tus clases son increibles en serio comparto el reto del ejercicio ![](https://static.platzi.com/media/user_upload/image-be86e419-8ad4-417c-bea2-e1893037f94f.jpg)
//explicita Explicit type casting const string = '42' const integer = parseInt(string) //parseInt convierte literal a numero entero. String es una secuencia de caracteres para representar texto. console.log(integer) console.log(typeof integer) let numero = 5.6789; console.log(numero.toFixed(2)); // "5.68" console.log(Math.floor(numero)); // 5 redondeo hacia abajo console.log(Math.ceil(numero)); // 6 redondeo hacia arriba console.log(Math.round(4.7)); // Devuelve 5 redondea hacia el mas cercano. //float tambien se usa para numero decimal const stringDecimal = '3.14' //las comillas hacen que sea literal no numero const float = parseFloat(stringDecimal) //convierte cadena de texto a numero decimal. console.log(float) console.log(typeof float) //que nos diga que tipo de string es const binary = '1010' //trabajamos numeros binarios const decimal = parseInt(binary, 2) console.log(decimal) console.log(typeof decimal) //Implicit type Casting const suma = '5' + 3 //concatena los dos numeros, no suma sino los une console.log(suma) //si queremos sumar un string con un booleano, tambien los junta no suma. const sumaConBooleano = '5' + true console.log(sumaConBooleano) const sumaConNumybooleano = 3 + true console.log(sumaConNumybooleano) const sumaConNumybooleanof = 3 + false //igual suma console.log(sumaConNumybooleanof) console.log('--------------------------------') const stringValor = '10' console.log (stringValor) const numeroValor = 10 console.log (numeroValor) const valorBooleano = true console.log (valorBooleano) console.log('--------------------------------') console.log('Veamos los resultados: partiendo de stringValor ') console.log(stringValor + stringValor) //cuando haya string siempre va a concatenar console.log(stringValor + numeroValor) //cuando haya string siempre va a concatenar console.log(stringValor + valorBooleano) //cuando haya string siempre va a concatenar console.log('Veamos los resultados: partiendo de numeroValor ') console.log(numeroValor + stringValor)//cuando haya string siempre va a concatenar console.log(numeroValor + numeroValor)//aca suma no hay string console.log(numeroValor + valorBooleano) //aca suma no hay string console.log('Veamos los resultados: partiendo de valorBooleano ') console.log(valorBooleano + stringValor)//cuando haya string siempre va a concatenar console.log(valorBooleano + numeroValor) //aca suma no hay string console.log(valorBooleano + valorBooleano) //aca suma no hay string
![](https://static.platzi.com/media/user_upload/image-3af92767-05e3-4836-b1b8-ed35bf68c3eb.jpg)![](https://static.platzi.com/media/user_upload/image-a1ffff16-b33e-4c1d-ad09-0f150490f53f.jpg)
Les dejo toda la practica que hice ojalá les sirva: //explicita Explicit type casting const string = '42' const integer = parseInt(string) //parseInt convierte literal a numero entero. String es una secuencia de caracteres para representar texto. console.log(integer) console.log(typeof integer) let numero = 5.6789; console.log(numero.toFixed(2)); // "5.68" console.log(Math.floor(numero)); // 5 redondeo hacia abajo console.log(Math.ceil(numero)); // 6 redondeo hacia arriba console.log(Math.round(4.7)); // Devuelve 5 redondea hacia el mas cercano. //float tambien se usa para numero decimal const stringDecimal = '3.14' //las comillas hacen que sea literal no numero const float = parseFloat(stringDecimal) //convierte cadena de texto a numero decimal. console.log(float) console.log(typeof float) //que nos diga que tipo de string es const binary = '1010' //trabajamos numeros binarios const decimal = parseInt(binary, 2) console.log(decimal) console.log(typeof decimal) //Implicit type Casting const suma = '5' + 3 //concatena los dos numeros, no suma sino los une console.log(suma) //si queremos sumar un string con un booleano, tambien los junta no suma. const sumaConBooleano = '5' + true console.log(sumaConBooleano) const sumaConNumybooleano = 3 + true console.log(sumaConNumybooleano) const sumaConNumybooleanof = 3 + false //igual suma console.log(sumaConNumybooleanof) console.log('--------------------------------') const stringValor = '10' console.log (stringValor) const numeroValor = 10 console.log (numeroValor) const valorBooleano = true console.log (valorBooleano) console.log('--------------------------------') console.log('Veamos los resultados: partiendo de stringValor ') console.log(stringValor + stringValor) //cuando haya string siempre va a concatenar console.log(stringValor + numeroValor) //cuando haya string siempre va a concatenar console.log(stringValor + valorBooleano) //cuando haya string siempre va a concatenar console.log('Veamos los resultados: partiendo de numeroValor ') console.log(numeroValor + stringValor)//cuando haya string siempre va a concatenar console.log(numeroValor + numeroValor)//aca suma no hay string console.log(numeroValor + valorBooleano) //aca suma no hay string console.log('Veamos los resultados: partiendo de valorBooleano ') console.log(valorBooleano + stringValor)//cuando haya string siempre va a concatenar console.log(valorBooleano + numeroValor) //aca suma no hay string console.log(valorBooleano + valorBooleano) //aca suma no hay string
Aqui mi resumen de esta clase, complementando con el curso anterior, estos son mis apuntes: ![](https://static.platzi.com/media/user_upload/image-f8626458-6b55-440c-8ff8-b1e52efdf4bf.jpg) Como lo explica en el video, como JavaScript es un lenguaje interpretado, es decir que se va traduciendo al momento de ejecutarse, la conversión implicita toma el primer valor y en base a eso interpreta lo siguiente, es decir, si primero hay un string y luego signo de + y un número, la salida en terminal es que concatena ambos terminos. Esta clase explica muy bien de forma teorica, las definiciones para una conversión implícita y explícita, aunque si estaria bien complementarlo con un ejercicio práctico.
Mis Anotaciones ![](file:///C:/Users/ALEJANDRO/OneDrive/Im%C3%A1genes/Screenshots/Screenshot%202024-07-30%20132016.png)