Introducción a JavaScript
Fundamentos de JavaScript para Principiantes
Instalación y Configuración de JavaScript en Visual Studio Code
Instalación y configuración de Visual Studio Code y Node.js en Windows
Variables y Buenas Prácticas en JavaScript
Tipos de Datos en JavaScript: Primitivos y Complejos
Manipulación de Strings en JavaScript: Escritura, Concatenación y Substrings
Números y Operaciones Matemáticas en JavaScript
Conversión de Tipos en JavaScript: Implícita y Explícita
Conversión de Tipos en JavaScript: Explícita e Implícita
Estructuras de Control y Lógica
Operadores de Comparación en JavaScript: Igualdad y Desigualdad
Operadores Lógicos en Programación: AND, OR y NOT
Estructuras Condicionales: Uso de IF, ELSE y ELSE IF en JavaScript
Juego de Adivinanza: Programación con Estructuras Condicionales
Estructura y uso del condicional Switch en programación
Ciclo For: Iteración de Listas y Uso de Console.log en JavaScript
Iteración con for-of en JavaScript para arrays y strings
Iteración sobre Objetos con forIn en JavaScript
Uso del ciclo while para iteración en programación
Ciclos doWhile: Estructura y Diferencias con While
Funciones y This
Funciones en JavaScript: Cómo Calcular Precios con Descuentos
Diferencias entre Funciones y Métodos en JavaScript
Funciones Puras e Impuras en Programación: Conceptos y Ejemplos
Arrow Functions y Enlace Léxico en JavaScript
Scope y Contextos de Ejecución en JavaScript
Closures y Ámbito Léxico en JavaScript
Fundamentos del Desarrollo Web: Frontend y Backend
Manipulación de Arrays
Arrays: Propiedades, Acceso y Creación en Programación
Mutabilidad e inmutabilidad en arrays: conceptos y ejemplos prácticos
Métodos push y pop para modificar arrays en JavaScript
Métodos map y forEach en JavaScript: Uso y Ejemplos Prácticos
Métodos Filter y Reduce en JavaScript: Uso y Ejemplos Prácticos
Métodos find y findIndex en JavaScript: Uso y ejemplos prácticos
Uso del método slice para extraer porciones de un array en JavaScript
Uso del Spread Operator en JavaScript: Copia, Combinación y Más
Programación Orientada a Objetos
Programación Orientada a Objetos en JavaScript: Conceptos y Práctica
Creación y Manipulación de Objetos en JavaScript
Función constructora y gestión de instancias en JavaScript
Clases en JavaScript: Creación y Uso de Objetos con Sintaxis Moderna
Programación Orientada a Objetos en JavaScript: Clases y Prototipos
Prototipos y Herencia en JavaScript: Construcción y Uso Práctico
Métodos y herencia prototípica en JavaScript
Uso de "this" en Clases y Funciones Constructoras
Validación de Usuarios en una Red Social: Algoritmo Básico
Implementación de la Función Sign-In y Validación de Usuario
Asincronía en JavaScript
Programación Síncrona y Asíncrona en JavaScript
Promesas en JavaScript: Asincronía y Manejo de Estados
Uso de Async/Await para Promesas Asíncronas en JavaScript
Peticiones asíncronas con for await en JavaScript
Fundamentos de HTTP: Cliente-Servidor y Métodos de Petición
Peticiones HTTP en Frontend: Uso de Fetch y Análisis en Network
Peticiones HTTP en JavaScript: Fetch, GET, POST y DELETE
Envío de Datos al Servidor con JavaScript y Fetch API
Eliminar Posts con JavaScript y Delegación de Eventos
Manejo de IDs en JavaScript para eliminar artículos del DOM
Actualizaciones y Nuevas Funciones en JavaScript
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Conversión de Tipos en JavaScript: Explícita e Implícita
9/55Recursos
¿Qué es el typecasting explícito en JavaScript?
Typecasting en JavaScript se refiere a convertir tipos de datos de manera explícita o implícita. Comencemos explorando la conversión explícita de tipos, uno de los métodos más comunes para manejar diferentes tipos de datos en nuestros programas.
Podemos convertir un string a un tipo numérico usando funciones como parseInt() y parseFloat(). Por ejemplo, podemos tener un string con un número "42" y convertirlo a un entero así:
const integer = parseInt("42");
console.log(typeof integer); // number
De manera similar, para convertir un string decimal como "3.14" a un número flotante:
const float = parseFloat("3.14");
console.log(typeof float); // number
JavaScript no distingue entre números enteros y decimales en cuanto al tipo de dato, ambos son considerados como number.
¿Cómo se convierte de binario a decimal?
Es posible convertir un número binario a decimal utilizando parseInt() con la base adecuada. Aquí un ejemplo práctico:
const binary = "1010";
const decimal = parseInt(binary, 2);
console.log(decimal); // 10
Este código convierte el número binario "1010" a su representación decimal que es 10.
¿Qué es el typecasting implícito en JavaScript?
JavaScript puede realizar conversiones de tipo sin intervención explícita del programador, esto se conoce como typecasting implícito. La suma de un string con un número ilustra este caso:
const resultado = "5" + 3;
console.log(resultado); // 53
En este ejemplo, JavaScript convierte el número 3 a un string y lo concatena con "5", dando como resultado "53".
¿Qué sucede con los booleanos?
Al combinar booleanos y otros tipos de datos, JavaScript también realiza conversiones. Por ejemplo:
const sumaConBoolean = "3" + true;
console.log(sumaConBoolean); // "3true"
Aquí el booleano true es convertido a string y luego concatenado. Sin embargo, si sumamos booleanos con números:
const sumaConNumero = 2 + true;
console.log(sumaConNumero); // 3
El booleano true es transformado a 1, resultando en una suma numérica.
Prueba tus conocimientos sobre typecasting
Para solidificar el aprendizaje, considera resolver el siguiente ejercicio:
Tienes el código:
const numero = "596";
const numeroConvertido = parseInt(numero);
console.log(typeof numero); // ?
console.log(typeof numeroConvertido); // ?
¿Cuáles son los tipos de datos que resultarán de los console.log? Las opciones son:
- A) string y number
- B) string y string
- C) number y string
La respuesta correcta es A, porque el numero es inicialmente un string y después del parseInt, numeroConvertido se convierte en un number. Continúa explorando y practicando con code snippets para perfeccionar tus habilidades en typecasting en JavaScript.
¡Sigue asi! tu comprensión de estos conceptos básicos te permitirá escribir código más eficiente y adaptativo.
Aportes 82
Preguntas 0
Ordenar por:
**Truco:** Cómo saber si JavaScript concatena o suma:
* Si hay al menos un `string`, JavaScript concatena.
* Si no hay ningún `string`, JavaScript realiza una suma.
Gracias por subir esta clase. Las conversiones son importantes y ampliamente utilizadas. Es bueno saber que platzi lee nuestros comentarios y atiende a nuestras peticiones.
Respuesta: A.
El tipo de value de *numero* es **string** ya que se encuentra en comillas simples.
Y el tipo de value de *numeroConvertido* es **number** ya que cuenta con un E<u>xplicit Type Casting</u> (parseInt) la cual se usa para convertir un value tipo string a un value number int.
Excelente clase, me gustó mucho!👌
parseInt()
Convierte un argumento de tipo cadena y devuelve un entero de la base especificada.
typeof
El operador typeof devuelve una cadena que indica el tipo del operando sin evaluarlo.
parseFloat()
La función parseFloat() analiza un argumento (si es necesario, lo convierte en una cadena) y devuelve un número de coma flotante.
Donde no hay string JS suma
numero + numero = suma
numero + boleano = suma
boleano + numero = suma
boleano + boleano = suma
Donde hay string concatena(une)
string + string = unir
string + numero = unir
string + boleano = unir
numero + string = unir
boleano + string = unir
Respuesta es: A.
String, number: el String es un tipo de dato que representa texo.
Number: Es un tipo de dato que representa números.
No entendi porque el 2 a la hora de convertir a binario.
```js
/*
Truco: Cómo saber si JavaScript concatena o suma:
Si hay al menos un string, JavaScript concatena.
Si no hay ningún string, JavaScript realiza una suma.
*/
const stringValue = "10";
const numberValue = 10;
const booleanValue = true;
console.log("----- stringValue -------");
console.log(stringValue + stringValue); // 1010 concatena
console.log(stringValue + numberValue); // 1010 concatena
console.log(stringValue + booleanValue );// 10true concatena
console.log("----- numberValue -------");
console.log(numberValue + stringValue); // 1010 concatena
console.log(numberValue + numberValue); // 20 suma
console.log(numberValue + booleanValue); // 11 suma
console.log("----- booleanValue -------");
console.log(booleanValue + stringValue); // true10 concatena
console.log(booleanValue + numberValue); // 11 suma
console.log(booleanValue + booleanValue); // 2 suma
```
Respuesta del Quiz
ES la opcion A
const numero = '596' ' // String
const numeroConvertido = parseInt(numero) //Numero
Respuesta A
string
number
La respuesta es A
la respuesta es la A: por que el primer valor esta entre comillas lo que lo vuelve un string pero después hace la conversion a un numero
const numero = '540'const numeroConvertido = parseInt(numero)console.log(typeof numero)console.log(typeof numeroConvertido)
// string
// number
**Regla**
* Si hay **al menos un string** y el operador es `+` → **concatena**
* Si todos son números o booleanos → **suma**
* Si hay un string y es una resta, multiplicacion o division→ **hace operación matemática**
**Funciones útiles**
* `parseInt()`Convierte string a entero
* `parseFloat()`Convierte string a número decimal
* `Number()`Convierte string o booleano a número
* `String()`Convierte cualquier dato a string
* `.toString()`Método para convertir datos a string
* `typeof`Devuelve el tipo del dato (ej: `'string'`, `'number'`)
La respuesta correcta es la A
La respuesta correcta para el quiz es efectivamente la opción A: "string y number". El primer valor es un string porque está entre comillas simples y el segundo, al ser convertido con `parseInt`, se convierte en un número. Esto demuestra cómo JavaScript maneja la conversión de tipos y el typecasting. Es fundamental entender estas diferencias para evitar errores en el código.
const numero = '596'const numeroConvertido = parseInt(numero)
console.log(typeof numero)console.log(typeof numeroConvertido)
repsuesta:
//string/numero
\*Tener cuidado con error de sintaxis
```js
// ===============================
// CONVERSIÓN EXPLÍCITA DE TIPOS
// ===============================
const string = "42";
// Usamos parseInt para convertir el string "42" a un número entero
const integer = parseInt(string);
console.log(integer); // Imprime: 42
console.log(typeof integer); // Imprime: "number" -> el tipo de dato ha cambiado
// También podemos convertir strings que parecen decimales con parseFloat
const strinDecimal = "3.14";
// parseFloat convierte el string "3.14" en un número flotante
const float = parseFloat(strinDecimal);
console.log(float); // Imprime: 3.14
console.log(typeof float); // Imprime: "number"
// Si tenemos un número en formato binario (base 2) como string
const binary = "1010";
// parseInt permite indicar la base (en este caso base 2 para binario)
const decimal = parseInt(binary, 2);
console.log(decimal); // Imprime: 10 (que es el valor decimal de 1010 binario)
console.log(typeof decimal); // Imprime: "number"
// ===============================
// CONVERSIÓN IMPLÍCITA DE TIPOS
// ===============================
// Cuando se suma un string y un número, JavaScript convierte el número en string y concatena
const sum = "5" + 3;
console.log(sum); // Imprime: "53" -> concatenación de string + número
// Cuando se suma un string con un booleano, también se convierte todo en string
const sumItBoolean = "3" + true;
console.log(sumItBoolean); // Imprime: "3true" -> string + string
// Pero si sumamos un número con un booleano, se convierte el booleano a número:
// true -> 1 y false -> 0
const sumWithNumber = 2 + true;
console.log(sumWithNumber); // Imprime: 3 (2 + 1)
// ===============================
// COMBINANDO DIFERENTES TIPOS
// ===============================
const stringValue = "10"; // string
const numberValue = 10; // number
const booleanValue = true; // boolean (true equivale a 1 en contexto numérico)
console.log("--------------");
// === PRUEBAS CON DIFERENTES COMBINACIONES ===
// String + String = Concatenación
console.log(stringValue + stringValue); // "1010"
// String + Number = El número se convierte a string y se concatena
console.log(stringValue + numberValue); // "1010"
// String + Boolean = El booleano se convierte a string y se concatena
console.log(stringValue + booleanValue); // "10true"
// Number + String = El número se convierte a string y se concatena
console.log(numberValue + stringValue); // "1010"
// Number + Number = Suma
console.log(numberValue + numberValue); // 20
// Number + Boolean = Suma (true se convierte a 1)
console.log(numberValue + booleanValue); // 11
// Boolean + String = El booleano se convierte a string y se concatena
console.log(booleanValue + stringValue); // "true10"
// Boolean + Number = Suma (true se convierte a 1)
console.log(booleanValue + numberValue); // 11
// Boolean + Boolean = Suma (true + true = 1 + 1)
console.log(booleanValue + booleanValue); // 2
```
**Respuesta al Quiz**
Opcion A (string, number)
Lo de esta clase parece algo sencillo, pero es un dolor de cabeza muchas veces, incluso en entrevistas colocan ejercicios que sus resultados cambian por estas cosas.
Me gusto la clase.
la respuesta correcta es la . A
**La respuesta del QUIZ: Opción A.**
* La constante *numero* es un string, pues su contenido está entre comillas simples.
* La constante *numeroConvertido* utiliza <u>parseInt</u> que convierte a un entero (number).
La respuesta es la A
numero es una variable de tipo string
y numeroConvertido al usar parseInt esto permite convertirlo a number
Por ende la respuesta es **String y number**
Para confirmar.
number + boolean (true) suma 1
number + boolean (false) suma 0
**La respuesta es la A**
* **String**
* **Number**
Conversion de tipos implicita - Implicit Type Casting
Si hay un string presente y hay un operador de suma javascript hara una concatenacion de strings, y convertira cualquier valor que no sea string a string
Si no hay strings, y solo numeros o booleanos y hay un operador de suma javascript hara una suma aritmetica
En el caso de que haya string pero operadores aritmeticos que no sean suma, ejemplo \*, - o /, javascript ejecutara una operacion aritmetica
Cureosando con ChatGPT me pregunte, que pasaria si ejecuto este codigo:
const string = '42m'
const integer = parseInt(string)
Descubri que ParseInt solo leera hasta el ultimo caracter numerico, si hay mas numeros despues de la letra se ignoraran, y si el string empieza por una letra, el valor sera NaN
La respuesta es la A
typeof numero = string
typeof numeroConvertido = number
**QUIZ**
Respuesta (A)
* "numero" al estar entre comillas simples nos indica que es un STRING
* "numeroConvertido" al usar la propiedad parseInt(numero) toma la variable que era string y la convierte a NUMBER
R/: A la variable numero es string por que tiene las comillas simples '596', en la variable numeroConvertido convierte el string con parseInt a number.
TRUCO: Cuando hay un string concatena.
tengo una pregunta con respecto a Typeof.
sabemos que si decimos nombreDeFuncion() solo por tener parentesis sabemos que es una funcion.
si tenemos string.lenght al tener el punto (entiendo yo) que es un atributo de una variable en este caso entiendo que el sistema lo toma como string y tiene los atributos de los strings ya definidos, pero entonces ¿ que seria typeof?
si me equivoco en algo estoy abierta a correcciones, gracias :)
Respuesta: A
El tipo de la primera variable es string porque escribe el número 596 entre comillas, lo que lo convierte en un string.
El tipo de la segunda variable es número, porque al usar parseInt, toma la primera variable y la convierte en número.
La Respuesta es la A.
porque la variable numero está declarando un string '596'.
La segunda linea, está convirtiendo ese string a number. por lo tanto al hacer un console.log, el resultado es string/number.
Respuesta correcta es la A: String y Number
Respeuesta A: string, number
**JavaScript concatena cuando hay un string, de lo contrario; suma.**
y si se suman dos booleanos tambien es el mismo principio true JS lo roma como si fuera 1 y false como si fuera 0
Encontre tres principios
* string mas number siempre se concatenarán
* string mas boolean siempre se concatenarán
* boolean mas number se sumaran dando true como si fuera 1 y false como si fuera 0
La respuesta es A.
la respuesta correcta es : A
string + number
CONCATENACION.
Respuesta correcta la A
Explicación:
aunque la constante de nombre numero tenga asignado un valor como un numero '596' es un valor considerado un string porque esta encerrado entre comillas simples.
Por otro lado la constante de nombre numeroConvertido contiene la funcion llamada "parseInt" convirtiendo la cadena que contiene dentro en un numero. En caso de que la cadena no pudiera haberse convertido en un numero (por ejemplo "hola") el resultado seria NaN.
La respuesta correcta: A (string, number)
La respuesta es la A
los string se colocan entre comillas. Ya que el primer valor es un string y el segundo valor numero (parseInt) el resultado es A (string + number).
```javascript
// Resumen de la clase sobre Conversión de tipos en JavaScript
// Conversión explícita
const stringNumber = "42";
const integer = parseInt(stringNumber); // Convierte a entero
console.log(integer); // 42
console.log(typeof integer); // "number"
const stringDecimal = "3.14";
const float = parseFloat(stringDecimal); // Convierte a flotante
console.log(float); // 3.14
console.log(typeof float); // "number"
// Conversión implícita
const sum1 = "5" + 3; // Concatenación, resultado: "53"
const sum2 = 2 + true; // Suma, resultado: 3
```
Este código ilustra la diferencia entre la conversión de tipos explícita e implícita en JavaScript.
La respuesta correcta es A: el primer valor '596' es un string, y el segundo número, después de la conversión con `parseInt`, es un número. Esto se debe a que los strings están entre comillas y la función `parseInt` convierte el string a un número. Así que efectivamente, el resultado de `typeof` para el primer valor será "string" y para el segundo será "number".
No me sabía de eso de Js, osea, siempre que tengamos un strign Js va a concatenar, en dado caso que no haya ninguno, solo suma.
recordemos que con string concatena siempre y las otras operaciones procesa el resultado arimetico
La respuesta correcta es la: **A**
La respuesta correcta es la A
La respuesta es A:
ya que el valor de la variable `numero` tiene comillas simples, lo que representa el tipo de dato texto.
Por otro lado, declaramos la función `parseInt`, que convierte el valor de la variable en un número entero. Por lo tanto, este valor representa el tipo de dato numérico.
number y string
const ssuma ="596";
const strfing = parseInt(ssuma) ;
console.log( strfing );
console.log( typeof strfing );
console.log(typeof ssuma );
la respuesta correcta es A
Respuesta A
La respuesta es la A
La respuesta del quiz sería A, string number.
Es la A
muy buena explicación
la respuesta al quiz es la: A que seria string y number
La respuesta correcta es la A:
numero = string
numeroConvertido = number
console.log(typeof numero)
//string
console.log(typeof numeroConvertido)
//integer
Respuesta A
La respuesta es A ya que al principio solo imprimimos en pantalla el type of de numero que es un string y en el segundo console.log tenemos una conversion de string a number con parseInt
Lo que se hace en el minuto 4:40 les dejo un mini-código para que vean como solucionar ese problema si algún día tienen que trabajar con datos```js
function sum(a, b){
a = parseInt(a)
b = parseInt(b)
let suma = a + b
console.log(suma)
}
sum('5', 5)
```El resultado va a ser '10' y no '55'
Hay un error de concepto en la explicación de **cómo pasar un número a sistema binario**. En realidad, lo que la profe hizo fue pasar un numero binario y convertirlo a base diez (lo inverso).
const decimal = parseInt(binary, 2)
El "2" es la base de la variable "binary". El "parseInt lo está convirtiendo a decimal. Nos damos cuenta en el resultado que 10 en decimal es 1010 binario.
Estaría bueno saber cómo pasar a binario un número dado base diez.
Saludos!
REspuesta A
Les dejo este pequeño código para no escribir tantos console.log y con algunas notas adicionales :D
`const`` stringValue ``=`` ``'10';const`` numberValue ``=`` ``10;const`` boolValue ``=`` true``;const`` values ``=`` ``[stringValue,`` ``numberValue,`` ``boolValue]`
`for`` (let`` ``i`` ``=`` ``0; i < 3; i++) { ``for`` (let`` ``j`` ``=`` ``0; j < 3; j++) { const`` res ``=`` ``values[i]`` ``+`` ``values[j] ``console.log```(`Result: ${res} result type: ${typeof res} we are added ${values[i]} + ${values[j]} Types: ${typeof values[i]} + ${typeof values[j]} `); }}``
Respuesta (A string- number)
"596" -596
En respuesta al Quiz,
**A: String**
**Number**
JS lo que evidencio que hace, es que se guía de la primera instrucción y acorde a lo que haya, convierte o "asume" que lo que va a su derecha es igual a esa "primera instrucción"
La respuesta es inciso A.
## Conversión de Tipos en JavaScript
* La conversión de tipos en JavaScript puede ser explícita o implícita.
* La conversión explícita implica que el programador convierte manualmente el tipo de dato.
* Ejemplos comunes de conversión explícita incluyen `parseInt`, `parseFloat`, y `String`.
## Conversión Explícita de Tipos en JavaScript
* **Convertir un string a entero**:const strNumber = "42";
const integer = parseInt(strNumber);
console.log(integer); // 42
console.log(typeof integer); // "number"
* **Convertir un string a número flotante**:const strDecimal = "3.14";
const float = parseFloat(strDecimal);
console.log(float); // 3.14
console.log(typeof float); // "number"
* **Convertir un binario a decimal**:const binaryStr = "1010";
const decimal = parseInt(binaryStr, 2);
console.log(decimal); // 10
console.log(typeof decimal); // "number"
## Conversión Implícita de Tipos en JavaScript
* JavaScript realiza conversiones de tipos automáticamente en tiempo de ejecución.
* Estas conversiones pueden ser sorprendentes y causar errores inesperados si no se comprenden bien.
### Ejemplos de Conversión Implícita
* **Concatenación de un string y un número**:const result = "5" + 3;
console.log(result); // "53"
console.log(typeof result); // "string"
* **Suma de un número y un booleano**:const sum = 2 + true;
console.log(sum); // 3
console.log(typeof sum); // "number"
## Reglas de Conversión en JavaScript
* Si hay un string involucrado en una operación de suma, JavaScript convierte todo a string y concatena.
* Si no hay strings involucrados, JavaScript realiza la operación aritmética normalmente.
### Ejemplo de Combinaciones de Tipos
const stringValue = "10";
const numberValue = 10;
const booleanValue = true;
console.log(stringValue + stringValue); // "1010"
console.log(stringValue + numberValue); // "1010"
console.log(stringValue + booleanValue); // "10true"
console.log(numberValue + stringValue); // "1010"
console.log(numberValue + numberValue); // 20
console.log(numberValue + booleanValue); // 11
console.log(booleanValue + stringValue); // "true10"
console.log(booleanValue + numberValue); // 11
console.log(booleanValue + booleanValue); // 2
## Próximos Pasos
* Experimentar con diferentes tipos de datos y conversiones en JavaScript para entender mejor cómo funciona el typecasting.
* Profundizar en la documentación de JavaScript para conocer más detalles sobre las funciones de conversión disponibles.
* Practicar con ejemplos y ejercicios para reforzar el conocimiento de la conversión de tipos.
## Ejercicio y Quiz
const numero = "596";
const numeroConvertido = parseInt(numero);
console.log(typeof numero); // "string"
console.log(typeof numeroConvertido); // "number"
* ¿Cuál es la salida de estos `console.log`?
* A: "string" y "number"
* B: "string" y "string"
* C: "number" y "string"
La respuesta correcta es **A**: "string" y "number".
### Reflexión
* JavaScript es un lenguaje de tipado débil, lo que significa que puede cambiar el tipo de una variable en tiempo de ejecución.
* Conocer las reglas de conversión de tipos en JavaScript es esencial para evitar errores inesperados en el código.
* Practicar y experimentar con diferentes escenarios de conversión ayuda a comprender mejor cómo funciona el typecasting en JavaScript.
La respuesta es la opción A
La respuesta del quiz que considero es: La Opcion "A", ya que la variable "numero" es una cadena de caracteres ya que lo indica el símbolo de comillas simples "' '" y luego se esta convirtiendo a Entero o Integer y ese valor entero esta siendo almacenado en la variable "numeroConvertido".
La respuesta es "A" string number
es la A string/number
Respuesta correcta: A = string, number
:)
```js
// Explicit type casting
const string = '42'
const integer = parseInt(string)
console.log (integer)
console.log (typeof integer)
const stringDecimal = '3.14'
const float = parseFloat (stringDecimal)
console.log (float)
console.log (typeof float)
const binary = '1010'
const decimal = parseInt(binary,2)
//de binario a decimal
console.log (decimal)
console.log (typeof decimal)
//Implicit Type Casting
const sum = '6' + 9
console.log (sum)
const sumwBoolean = '6' + true
console.log (sumwBoolean)
const sumWNumber = 2 + true
console.log (sumWNumber)
console.log("_____________________")
const stringValue = '10'
const numberValue = 10
const booleanValue = true
console.log (stringValue + stringValue)
console.log (stringValue + numberValue )
console.log (stringValue + booleanValue )
console.log (numberValue + stringValue )
console.log (numberValue + numberValue )
console.log (numberValue + booleanValue )
console.log (booleanValue + stringValue )
console.log (booleanValue + numberValue )
console.log (booleanValue + booleanValue ) //suma
//con string JavaS concatena
//cuando hay numero, suma
//EJERCICIO
const numero = '596'
const numeroConvertido = parseInt(numero)
console.log (typeof numero) //string
console.log (typeof numeroConvertido) //number
```
la respuesta al quiz es la opción A
no utilicen esos nombres : string, integer , float
son palabras reservadas en otros lenguajes de programación y puede resultar confuso, puedes usar cualquier otro nombre relacionado pero no esos nombres, es un consejo para los cursos.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?