Saltar al contenido principal

Introducción

Preparación de Entorno (Linux)​

A pesar de no dominar el escritorio, linux (predominante en ambientes de desarrollo, devops y producción) y contrario a lo que algunos pensarían, configurar este OS para nuestro entorno de desarrollo es más sencillo de lo que parece, sólo con tener los conocimientos básicos de terminal o incluso sin ellos (muchos de los comandos ya vienen en instrucciones que podriamos copiar y pegar, y de paso aprenderlos). A continuación presento unos enlaces que llevan a algunos de mis tutoriales para configura sistemas operativos como ubuntu o archlinux.

Mi entorno de desarrollo

Anatomía de una variable​

Las variables son contenedores que nos permiten almacenar datos de distintos tipos y a las que les podemos poner un nombre específico. Las variables, como su nombre lo indica, va a variar a lo largo de la ejecución del código.

Para crear una variable en JS se utiliza la palabra reservada let, seguido del nombre que queremos asignarle y para el valor, escribimos el signo de asignación "Igual" =, seguido del tipo de valor que queremos:

let toolBox = "martillo"; // Aqui estamos utilizando la técnica denominada
// "Camel Case" para nombrar la variable.

Lo que NO es permitido hacer​

No ser ambigüo, ser lo mas descriptivo con los nombres de las variables.

let t = "Martillo";
let tb = "Martillo";
let pcBox = "Martillo";
let t, tb;
pcBox;

Lo que es permitido hacer​

let primeraHerramientaDeArmando = "Martillo";
let urlDelUsuario = "https://github.com/ruizamdev";
let idDelUsuario = "230947230"; // Podemos o no, utilizar punto y coma al final de cada sentencia

Constantes​

Tiene la misma utilidad que una variable pero, en vez de variar el valor, se mantiene igual en la mayoría o en todo el tiempo que dure la ejecución del código.

const pi = 3.141592;

Tipos de datos​

En JS tenemos diez tipos de datos, estos se dividen dos grupos, los Primitivos y los Complejos:

PrimitivosComplejos
StringObject
NumberArray
BooleanFunction
Null
Undefined
Symbol
Bigint

Tipos de datos Primitivos​

String​

Son cadenas de caracteres, los escribimos entre comillas dobles, simples y a partir de ES6 (ECMAScript 6) con comillas francesas:

let nombre = "Armando";

Number​

Es un número:

let edad = 25;

Boolean​

Es un dato que puede representar valores binarios, verdadero o falso (true or false):

let esMayorDeEdad = true;

Null​

Tipo de dato nulo, nos indica que no hay valor, que esta vacío, nos asegura que no hay nada almacenado:

let noHayValor = null;

Undefined​

Indefinido, también nos indica que no hay un valor, pero a diferencia de null, esto lo asigna el propio lenguaje, como por ejemplo cuando declaramos una variable pero no le asignamos un valor:

let noDefinido = undefined; // Este valor, nosotros como programadores no lo utilizaremos,
// esto lo hace JS para indicarlo en ciertas situaciones.

Symbol​

Nos indica un valor único:

let simboloUnico = Symbol("unico");

Bigint​

Nos indica un valor numérico grande:

let numeroGrande = 2n;

Tipos de datos Complejos​

Object​

Es un tipo de dato el cual tiene varias propiedades únicas que lo conforman e identifican:

let laptop = {
marca: "Lenovo",
model: "Legion",
};

Array​

Son listas o un conjunto de datos, asignadas a una variable o constante:

let verduras = ["acelga", "espinaca", "lechuga"];

Function​

Es una serie de instrucciones que se pueden reutilizar, las cuales pueden ser llamadas por su nombre para ejecutarse

function saludar() {
console.log("Hello there");
}

Creación de Strings​

Hay varias formas de crear strings o cadenas, para hacerle saber a javascript que el tipo de datos que estamos guardando en una variable o constante es mediante comillas simples 'dato', comillas dobles "dato" o backticks o comillas invertidas ``

let string1 = "Estas son comillas simples";
let string2 = "Estas son comillas dobles";
let string3 = `${string1} pero invertidas, llamadas backticks`;
let string4 =
string1 +
" y " +
string2 +
"mostradas en una sola linea mediante concatenacion";

Operadores Aritméticos​

Tipos de Números​

Entero y Decimal​

const entero = 42;
const decimal = 3.1415;
console.log(typeof entero, typeof decimal);
number number

Notación científica​

const cientifico = 5e3;

Infinitos y Not a Number​

const infinito = Infinity;
const noEsNumero = NaN;

Operaciones Aritméticas​

  1. Suma, resta, multiplicación y división.
    const suma = 3 + 2;
    const resta = 4 - 4;
    const multiplicacion = 4 * 8;
    const division = 15 / 3;
  2. Módulo y exponentes
    const modulo = 15 % 8;
    const exponente = 2 ** 3;

Problemas​

Precisión

const resultado = 0.1 + 0.2;
console.log(resultado);
console.log(resultado.toFixed(1));
console.log(resultado === 0.3); // el simbolo "===" compara si son iguales a nivel
// de número y tipo de número
0.30000000000000004
0.3
false

Operaciones avanzadas​

const raizCuadrada = Math.sqrt(16);
const valorAbsoluto = Math.abs(-7);
const aleatorio = Math.random();
console.log(raizCuadrada);
console.log(valorAbsoluto);
console.log(aleatorio);
4
7
102

Conversión de tipos​

En los lenguajes de programación, la computadora no lo entiende tal cual, es por eso que se necesitan compiladores para poder transformar ese código escrito por nosotros en código que puede entender la computadora.
Dentro de estos lenguajes de programación existen dos tipos: los compilados y los interpretados.
Por ejemplo:

CompiladosInterpretados
C, C++JavaScript
RustRuby
GoPHP
SwiftPython

La diferencia radica en el momento en el que es compilado (traducido o trasformado a lenguaje maquina [0 y 1]) el código fuente, hablamos que en los de tipo compilado ésta traducción ocurre antes de la ejecución del programa, y los interpretados se van traduciendo conforme se va ejecutando el programa.
También existe otra característica de ambos grupos, el chequeo de tipos, en el compilado es estático y en el interpretado es dinámico, esto quiere decir que al momento de ejecución (en el caso de JS) nuestro lenguaje no va a saber que tipo de valores tienen nuestras variables hasta que se ejecuta esa parte del programa, cosa contraria con los lenguajes compilados.

CompiladosInterpretados
Chequeo estático de tiposChequeo dinámico de tipos

JavaScript en este sentido, se podría decir que tiene un tipado débil, porque podemos escribir una variable con valor numerico y despues un valor string.

En este ejemplo JS va checando cada valor y al momento de encontrar algo inusual marca un error:

const saludo = 'hola'
console.log()
const despedida = 'adios'
console.log(despedida)
const titulo = 'me gusta estudiar
console.log(titulo) // Aquí saldrá un error
const descripcion = 'porque aprendo mucho'
console.log(descripcion)

En este otro ejemplo al ver que los dos tipos de valor que se están sumando no son iguales, convierte en este caso el valor booleano en numero para poder realizar la operación; esto lo hace automáticamente JS.

const numero = 2;
const booleano = true;
console.log(numero + booleano);
3

A esto es a lo que se le llama conversión de tipos, y existen 2 variantes:

ImplícitaExplícita
2 + trueString()
Number()
Boolean()

Explicit Type Casting​

String a Integer​

const string = "42";
const integer = parseInt(string);
console.log(integer);
console.log(typeof integer);
42
number

String a Float​

const stringDecimal = "3.14";
const float = parseFloat(stringDecimal);
console.log(float);
console.log(typeof float);
3.14
number

Binario a decimal​

const binary = "1010";
const decimal = parseInt(binary, 2);
console.log(decimal);
console.log(typeof decimal);
10
number

Implicit Type Casting​

Concatenación de string y number = string​

const sum = "5" + 3;
console.log(sum);
53

Concatenación de string y boolean = string​

const sumWithBoolean = "3" + true;
3true

Suma de number y boolean = number​

const sumWithNumber = 2 + true;
console.log(sumWithNumber);
3
const stringValue = "10";
const numberValue = 10;
const booleanValue = true;

console.log(stringValue + stringValue); // concatena (type string)
console.log(stringValue + numberValue); // concatena (type string)
console.log(stringValue + booleanValue); // concatena (type string)

console.log(numberValue + stringValue); // concatena (type string)
console.log(numberValue + numberValue); // suma (type number)
console.log(numberValue + booleanValue); // suma (type number)

console.log(booleanValue + stringValue); // concatena (type string)
console.log(booleanValue + numberValue); // suma (type number)
console.log(booleanValue + booleanValue); // suma (type number)
1010
1010
10true

1010
20
11

true10
11
2