JS 👀📝
,

JavaScript – Variables y tipos de datos

JavaScript es un lenguaje dinámico, y no utiliza tipado, si quisiéramos usar tipado deberíamos de tomar en consideración usar TypeScript.

¿Qué encontraras aquí?

En esta entrada pretendo documentar mis conocimientos sobre variables y tipos de datos que estas pueden almacenar.

Variables

Las variables en JavaScript pueden ser inicializadas sin un valor y asignarlo después:

let nombre;

También podemos inicializar múltiples variables a la vez:

let categoria = 'home',
    marca     = 'Amazon',
    calidad   = 7;

El no tener tipado significa que una variable puede almacenar distintos valores, desde un numero, un string, un char… etc. Las variables siempre se podrán reasignar de valor, por lo que el dato que contiene una variable puede mutar de tipado por ejemplo:

let years = 31; // almacenaría el valor como de tipo int.

years ="31";    // el valor a pasado de tipo int a string.

Las variables no se pueden iniciar con numeros pero si con la barra baja antes de su nombre o numero:

//Erroneas:
let 99dias;
var 2022;
const 01_ ="HOLA";

//ADMITIDAS:
var dia13;
let _013;
let nombreProducto;
var nombre_produco;
const _precio_final_producto = 120;

Ademas las variables no se pueden repetir en el mismo nivel, es decir, no se puede declarar 2 variables con un nombre identico, solo se permite repetir nombres cuando estan a otro nivel, como dentro de un objeto, una funcion, un condicional, etc…

Existen 3 tipos de variables en JavaScript:

Var

var es una sintaxis anterior a ECMASCRIPT, aun funcional para crear variables pero ya no tan usada en JavaScript mas moderno.

Let

let es la sintaxis moderna que nos proporciona ECMASCRIPT para declarar nuestras variables, funciona como var, permitiendo reasignar el valor, modificar el tipado, etc.

Const

const funciona como las demás variables excepto en que su valor y tipado es constante, es decir no puede ser reasignado. Las constantes siempre se deven inicializar con un valor.

const precio = 20;
console.log(precio);

Tipo de datos

Un valor en JavaScript siempre pertenece a un tipo de dato determinado. Por ejemplo, un string o un número.

Hay ocho tipos de datos básicos en JavaScript.

String

Representa una cadena de caracteres y debe colocarse entre comillas.

En JavaScript, hay 3 tipos de comillas.

  • Comillas dobles: “Hola”;
  • Comillas simples: ‘Hola’;
  • Backticks (comillas invertidas): `Hola`;

Las comillas dobles y simples son comillas “sencillas” (es decir, funcionan igual). No hay diferencia entre ellas en JavaScript.

Los backticks son comillas de “funcionalidad extendida”. Nos permiten incrustar variables y expresiones en una cadena de caracteres encerrándolas en ${…}, por ejemplo:

let name = "John";

// incrustar una variable
alert( `Hola, ${name}!` ); // Hola, John!

// incrustar una expresión
alert( `el resultado es ${1 + 2}` ); //el resultado es 3

Number

Representa a los números tanto enteros como flotantes.

Además de los números comunes, existen los llamados “valores numéricos especiales” que también pertenecen a este tipo de datos: Infinity, -Infinity y NaN.

Infinity

Representa el Infinito matemático ∞. Es un valor especial que es mayor que cualquier número.

alert( 1 / 0 ); // Infinity
alert( Infinity ); // Infinity

NaN

Representa un error de cálculo. Es el resultado de una operación matemática incorrecta o indefinida. Ademas cualquier operacion con un valor NaN nos devolvera NaN

alert( "no es un número" / 2 ); // NaN, tal división es errónea

alert( NaN + 1 ); // NaN
alert( 3 * NaN ); // NaN
alert( "not a number" / 2 - 1 ); // NaN

BigInt

Se agregó recientemente al lenguaje para representar enteros de longitud arbitraria.

Un valor BigInt se crea agregando n al final de un entero:

// la "n" al final significa que es un BigInt
const bigInt = 1234567890123456789012345678901234567890n;

Boolean

Un valor Boolean solo puede representar “true” y “false”

let nameFieldChecked = true; // sí, el campo name está marcado
let ageFieldChecked = false; // no, el campo age no está marcado

Los valores booleanos también son el resultado de comparaciones:

let isGreater = 4 > 1;

alert( isGreater ); // verdadero (el resultado de la comparación es "sí")

Null

Null representa “nada”, “vacío” o “valor desconocido”.

let age = null; // age es desconocido o esta vacio por alguna razon.

Undefinded

Significa valor no asignado, si una variable es declarada pero no tiene ningun valor asignado, esta devolvera undefined

let age;
alert(age); // muestra "undefined"

let newAge = undefined;
alert(newAge); // "undefined"

Normalmente se utiliza el tipo null para asignar un valor “vacio” o “desconocido” a una variable, mientras que undefined es un valor inicial reservado para los valores que no han sido asignados.

Object & Symbol

Los objetos se utilizan para almacenar colecciones de datos y entidades más complejas.

El tipo symbol (símbolo) se utiliza para crear identificadores únicos para los objetos.

Operador typeof

El operador typeof devuelve el tipo de valor que se esta almacenando en una variable. 

console.log(typeof 42);
// expected output: "number"

console.log(typeof 'blubber');
// expected output: "string"

console.log(typeof true);
// expected output: "boolean"

console.log(typeof undeclaredVariable);
// expected output: "undefined"


// Numbers
typeof 37 === 'number';
typeof 3.14 === 'number';
typeof 42 === 'number';
typeof Math.LN2 === 'number';
typeof Infinity === 'number';
typeof NaN === 'number'; // Despite being "Not-A-Number"
typeof Number('1') === 'number';      // Number tries to parse things into numbers
typeof Number('shoe') === 'number';   // including values that cannot be type coerced to a number

typeof 42n === 'bigint';


// Strings
typeof '' === 'string';
typeof 'bla' === 'string';
typeof `template literal` === 'string';
typeof '1' === 'string'; // note that a number within a string is still typeof string
typeof (typeof 1) === 'string'; // typeof always returns a string
typeof String(1) === 'string'; // String converts anything into a string, safer than toString

// Booleans
typeof true === 'boolean';
typeof false === 'boolean';
typeof Boolean(1) === 'boolean'; // Boolean() will convert values based on if they're truthy or falsy
typeof !!(1) === 'boolean'; // two calls of the ! (logical NOT) operator are equivalent to Boolean()

// Symbols
typeof Symbol() === 'symbol'
typeof Symbol('foo') === 'symbol'
typeof Symbol.iterator === 'symbol'

// Undefined
typeof undefined === 'undefined';
typeof declaredButUndefinedVariable === 'undefined';
typeof undeclaredVariable === 'undefined';

// Objects
typeof { a: 1 } === 'object';

// use Array.isArray or Object.prototype.toString.call
// to differentiate regular objects from arrays
typeof [1, 2, 4] === 'object';

typeof new Date() === 'object';
typeof /regex/ === 'object'; // See Regular expressions section for historical results

// The following are confusing, dangerous, and wasteful. Avoid them.
typeof new Boolean(true) === 'object';
typeof new Number(1) === 'object';
typeof new String('abc') === 'object';

// Functions
typeof function() {} === 'function';
typeof class C {} === 'function';
typeof Math.sin === 'function';

Quieres saber mas?

Desarrollo web
JavaScript – Variables y tipos de datos

Post navigation