JavaScript para QA: variables y tipos de datos

¡Introducción breve! JavaScript fue introducido en 1995 para agregar funcionalidades a páginas web, generando aplicaciones con las que puedes interactuar de forma directa, sin tener que recargar el navegador para cada acción. Además, a pesar de su nombre similar, no está relacionado con Java.

El estándar ECMAScript define su funcionamiento, siendo JavaScript y ECMAScript términos intercambiables. Aunque su flexibilidad puede ser desafiante para los principiantes, permite un estilo de programación dinámico y creativo. Con versiones desde ECMAScript 1 hasta la actualidad, su constante evolución exige que los navegadores mantengan el paso. JavaScript se extiende más allá de los navegadores, utilizándose en bases de datos y entornos de servidor a través de plataformas como Node.js.

Var, Let y Const

var: Declara una variable a nivel de función o global, opcionalmente inicializándola con un valor. Como tienen un ámbito de función, estas variables pueden ser accedidas desde cualquier lugar dentro de la función en la que están declaradas.

let: Declara una variable local con ámbito de bloque, opcionalmente inicializándola con un valor. Las variables let tienen un ámbito limitado al bloque en el que están definidas, lo que significa que solo pueden ser accedidas dentro de ese bloque.

const: Declara una constante con ámbito de bloque, similar a let. La diferencia principal es que el valor de una constante no puede ser cambiado después de ser asignado. Sin embargo, si una constante es un objeto o un array, sus propiedades o elementos pueden ser actualizados o removidos.

¡Advertencia!: En JS actualmente no se utiliza var para declarar variables, lo dejo aquí para que puedas reconocerlo en caso de que leas el código de un compañero QA (probablemente, no pragmático).

Esto es debido al ámbito de función de var, que puede tener resultados no previsibles al momento de escribir el programa y sus errores serían difíciles de depurar. Mientras que let con su ámbito de bloque, al igual que const, esto ayuda a prevenir problemas de alcance, haciendo un código más entendible y mantenible (El siguiente QA que toque tu automatización lo agradecerá).

Operadores de asignación

Los operadores de asignación se utilizan para asignar valores a variables en JavaScript.

var a;
const b = 0;
let c = 'soy una cadena';
console.log(a); // undefined
console.log(b); // 0
console.log(c); // soy una cadena

Tipos de datos

Los tipos de datos primitivos son aquellos que no son objetos y no tienen métodos o propiedades. Hay 7 tipos de datos primitivos:

• string
• number
• bigint
• boolean
• undefined
• symbol
• null

Los valores primitivos se representan directamente en el nivel más bajo de la implementación del lenguaje. Algunos detalles sobre ellos son:

String: Representa valores de texto.

Number: Representa valores numéricos.

Boolean: Representa valores lógicos (verdadero/falso).

Undefined: Representa variables sin un valor asignado.

Null: Representa un puntero a un objeto no existente o inválido.

Nota: El “Hoisting” en JavaScript se refiere al proceso en el que el intérprete parece mover la declaración de funciones, variables o clases al inicio de su ámbito, antes de la ejecución del código.

const string = 'Hola pragmático!';
const symb = Symbol();
const boolean = true;
const nullValue = null;
const p; // undefined;j

Tipos de Datos Complejos

Objeto: Estructura que almacena pares clave-valor.

Literales de objetos: {}, {nombre: “Odin”}.

Objetos especiales: Date; envoltorios: Number, Map, JSON, Array.

Ejemplo:

let dia1 = {
  hombreArdilla: false,
  eventos: ["trabajo", "tocó árbol", "pizza", "correr"],
};
console.log(dia1.hombreArdilla);
// → false
console.log(dia1.lobo);
// → undefined
dia1.lobo = false;
console.log(dia1.lobo);
// → false

Arreglo:

Objeto que permite almacenar una colección de múltiples elementos bajo un solo nombre de variable. Los arreglos en JavaScript son redimensionables y pueden contener una mezcla de diferentes tipos de datos.

Los arreglos en JavaScript no son asociativos, los elementos del arreglo deben ser accedidos utilizando enteros como índices. Como en otros lenguajes, los arreglos en JavaScript tienen índice cero: el primer elemento de un arreglo está en el índice 0, el segundo está en el índice 1, y así sucesivamente.

let listaDeNumeros = [2, 3, 5, 7, 11];
console.log(listaDeNumeros[2]);
// → 5
console.log(listaDeNumeros[0]);
// → 2
console.log(listaDeNumeros[2–1]);
// → 3

Operadores

Operadores Aritméticos:

Realizan operaciones matemáticas.

console.log(2 + 3); // Suma: 5
console.log(2–1); // Resta: 1
console.log(2 * 5); // Multiplicación: 10
console.log(5 / 2); // División: 2.5
console.log(10 % 3); // Módulo: 1 (El resto de la división de 10 por 3)
console.log(2 ** 3); // Exponenciación: 8 (2 elevado a la potencia de 3)

Operadores de Asignación:

Asignan valores a las variables.

let a = 5;
a += 5;

console.log(a); // 10 (a ahora es igual a 10)
let b = 10;
b -= 3;
console.log(b); // 7 (b ahora es igual a 7)
let c = 2;
c *= 4;
console.log(c); // 8 (c ahora es igual a 8)
let d = 20;
d /= 5;
console.log(d); // 4 (d ahora es igual a 4)
let e = 7;
e %= 3;
console.log(e); // 1 (e ahora es igual a 1)

Nota: El operador + y el += también se utilizan para concatenar cadenas.

const saludo = "¡Hola!";
const persona = "pragmático";
console.log(saludo + " " + persona); // ¡Hola! pragmático

Operadores de Comparación:

Los operadores de comparación se utilizan en declaraciones lógicas para determinar si los valores son iguales o diferentes.

const a = 1;
const b = 3;
const c = 5;
const d = "5";
console.log(a > b); // false
console.log(a < b); // true
console.log(a == b); // false
console.log(c == d); // true
console.log(c === d); // false

Operadores Lógicos Binarios

Realizan operaciones lógicas en valores booleanos y devuelven un valor booleano.

const a = true;
const b = false;
const c = true;
console.log(a || b); // true
console.log(a && b); // false
console.log(!c); // false

El Operador typeof

El operador typeof es un operador unario que permite obtener el tipo dato de una variable, objeto, función o expresión.

El operador typeof es útil para realizar comprobaciones de tipo y para tomar decisiones basadas en el tipo de datos de una variable o valor en tiempo de ejecución.

console.log(typeof "Odin"); // string
console.log(typeof 2); // number
console.log(typeof NaN); // number
console.log(typeof false); // boolean
console.log(typeof [1, 2, 3, 4, 5, 6, 7, 9, 10]); // object
console.log(typeof { nombre: "Odin", edad: 3 }); // object
console.log(typeof new Date()); // object
console.log(typeof function () {}); // function
console.log(typeof name); // undefined
console.log(typeof null); // object

Cibergrafía

https://eloquent-javascript-es.vercel.app/

https://jonmircha.com/javascript#caracter%C3%ADsticas

https://kesharvani.hashnode.dev/why-using-var-is-a-bad-practice-in-javascript