BASES TEÓRICAS DE

ESTRUCTURAS DE
ALMACENAMIENTO EN
MEMORIA
[Subtítulo del documento]

[FECHA]
[NOMBRE DE LA COMPAÑÍA]
[Dirección de la compañía]
 Introducción
o Principales diferencias entre los lenguajes compilados e interpretados.

o Características principales de JavaScript o Tipos de datos primitivos y uso en JavaScript

o Operadores en JavaScript

o Apoye todas las argumentaciones con imágenes ilustrativas y no olvide referenciar las fuentes
de información utilizadas.

DESARROLLO

Principales diferencia entre lo lenguajes copilados e interpretados

Lenguajes compilados
La diferencia entre lenguajes compilados e interpretados está contenida en la forma en
que interactúan con el ordenador. Es una noción común que los ordenadores se expresan
y entienden el código binario, pero antes hablé claramente de funciones escritas en inglés
(print). Bueno, en un lenguaje compilado estas funciones, a menudo llamadas por la
terminología inglesa, son convertidas en ensamblador por el compilador y posteriormente
ensambladas en lenguaje binario para que la PC pueda leerlas.
Sin embargo, el Assembly es un código que varía según la familia de
procesadores, por lo que es muy costoso en términos de tiempo y energía escribir
un programa para cada código Assembly. Por tanto, la solución pasa por escribir
un programa de alto nivel que pueda ser universal. Sin embargo, el problema
sigue siendo que para realizar cambios tendrás que acceder al código fuente,
cambiar el necesario y volver a convertirlo
El lenguaje compilado necesita que antes de ser ejecutada una compilación se
convierta el código fuente escrito a un lenguaje de máquina
El código creado debe traducirse de manera que el procesador del computador o
smartphone pueda comprenderlo, a este proceso se le llama compilación

Lenguajes interpretados
Para proceder a la explicación de esta segunda familia de lenguajes nos referiremos
a la propia etimología, Interpretada. El proceso de interpretación consiste en la
traducción de un idioma a otro idioma, en este es la traducción del idioma elegido al
idioma binario para que la PC pueda leerlo y ejecutarlo.

La diferencia con los lenguajes compilados radica en que el programa de un

lenguaje compilado está representado por el archivo ya escrito en binario que, una
vez lanzado, se lee directamente y se ejecuta. En los idiomas interpretados, el
programa está representado por el código fuente que primero se traduce y luego se
compila cada vez, con la consiguiente disminución del rendimiento. Sin embargo,
esto permite una mayor simplicidad en términos de sintaxis, como se muestra al
principio con python, pero sobre todo permite que el programa se ejecute en
cualquier máquina con cualquier sistema operativo.

Un lenguaje interpretado es convertido a lenguaje de máquina cada vez que es

ejecutado (para ello requiere del intérprete), que traduce las instrucciones.

Un programa escrito en un lenguaje interpretado, necesita de otro programa auxiliar

(el intérprete), que traduce los códigos fuentes de un programa y los interpreta para
la máquina.

https://aulab.es/noticia/18/diferencia-entre-lenguajes-de-programacion-compilados-
e-interpretados

https://sena.territorio.la/content/index.php/institucion/Titulada/institution/SENA/Tec
nologia/228118/Contenido/OVA/CF14/index.html#/curso/tema1

Características principales de JavaScript

1 Encadenamiento opcional en JavaScript con el operador «?.»

2 Operador de fusión nulo ??

3 Promises y funciones asíncronas

4 Ámbito de variables let y const

5 Transformación de datos usando JSON.parse

6 Separador de miles en el código fuente usando _

#1 Encadenamiento opcional en
JavaScript con el operador «?.»
El operador de encadenamiento opcional permite acceder de forma simplificada a
los atributos de un objeto cuando este puede ser undefined o null. Por ejemplo,
supón que tienes un objeto como el siguiente:

const toni = {
name: 'Antonio',
details: {
age: 35,
 },
};

Para acceder a la edad de toni debemos acceder primero al atributo details y

luego a age:

function getAge( person ) {

return person.details.age;
}

El problema que tenemos en la función anterior, y que seguro que has sufrido en
tus carnes, es que no siempre te pasan un objeto válido.
Si person o person.details es undefined, la función anterior devolvería un error:

getAge( toni ); // 35
getAge( {} ); // Uncaught TypeError: person.details is undefined

La forma habitual de evitar este problema es meter unas cuantas salvaguardas

que comprueben la validez del objeto y eviten el error:

function getAge( person ) {

if ( ! person ) {
return;
}
if ( ! person.details ) {
return;
}
return person.details.age;
}
getAge( toni ); // 35
getAge( {} ); // undefined

Esta solución, aunque efectiva, tiene un gran defecto: hemos pasado de algo
sencillo a un «monstruo» lleno de comprobaciones previas que dificultan la
inteligibilidad de nuestro código. Para simplificarlo, lo único que debemos hacer es
usar el operador de encadenamiento opcional ?.:

function getAge( person ) {

return person?.details?.age;
}
getAge( toni ); // 35
getAge( {} ); // undefined

con lo que nos ahorramos las salvaguardas y evitamos que el código pete si
alguna de las propiedades intermedias es undefined o null.

#2 Operador de fusión nulo ??

En JavaScript es muy fácil poner un valor por defecto a una variable usando ||,
¿verdad? ¡Mentira! Todos lo hemos hecho, pero tiene efectos secundarios
peligrosos…

Por ejemplo, supón que tenemos un selector en nuestro store de Redux que nos
permite recuperar un valor definido por el usuario. Si el usuario aún no ha definido
ningún valor, en el store lo mismo tenemos un undefined, con lo que podemos
usar || para asignarle un valor por defecto:

function getValue( state ) {

return state.value || 5;
}

Veamos qué valores nos devuelve la función según los setValue que haya hecho
el usuario:

// No setValue( x )...
getValue(); // 5
setValue( 2 );
getValue(); // 2
setValue( 1 );
getValue(); // 1
setValue( 0 );
getValue(); // 5

¡Vaya! En el último caso, si el usuario especifica el valor 0, el resultado de la

función es 5. El motivo es obvio: el operador || devuelve el segundo operando si el
primero es un valor que evalúa a false. Nosotros lo usamos pensando que x ||
y devolvería y si la x era undefined o null, pero en realidad devuelve y si x es
equivalente a false, y el 0 es un valor que es equivalente a usar false.
Para solucionar este problema, podemos aplicar la misma solución que antes y
meter una salvaguarda explícita:

function getValue( state ) {

if ( undefined === state.value ) return 5;
return state.value;
}

o, en este caso, incluso colapsar la salvaguarda en un operador ternario ?::

function getValue( state ) {

return undefined === state.value ? 5 : state.value;
}

pero ambas soluciones complican innecesariamente el código. Para asignar un

valor por defecto a una variable, debemos usar el operador de fusión nulo ??, el
cual devuelve la parte derecha si, y solo si, la izquierda es null o undefined:

function getValue( state ) {

return state.value ?? 5;
}

con lo que, ahora sí, conseguimos el efecto deseado:

// No setValue( x )...
getValue(); // 5
setValue( 2 );
getValue(); // 2
setValue( 1 );
getValue(); // 1
setValue( 0 );
getValue(); // 0

Por cierto, este operador puede usarse, como la mayoría de los demás
operadores, junto con el operador de asignación. Por ejemplo, esta expresión:

value = value ?? 5;

puede reescribirse tal que así:

value ??= 5;

#3 Promises y funciones
asíncronas
Las promises son un mecanismo que permite simplificar nuestro código cuando
trabajamos con operaciones asíncronas, esto es, operaciones cuyo resultado no
podemos obtener de forma immediata. Por ejemplo, si queremos recuperar un
dato de nuestro servidor, está claro que la respuesta no será instantánea, puesto
que tenemos que esperar a que el servidor reciba la petición, la procese y nos
envíe la respuesta.

En versiones anteriores de JavaScript (por ejemplo, con jQuery), esto solíamos

implementarlo con callbacks. La idea era bastante sencilla: junto a la petición para
recuperar el dato paso una función (el callback) que deberá llamarse cuando la
respuesta esté disponible. De esta forma, cuando la operación asíncrona se
complete, se llamará al callback y el código seguirá adelante:

jQuery.ajax( {
url: 'https://server.com/wp-json/wp/users/1',
success: ( user ) => {
console.log( user );
},
} );

Cuando se trata de una única petición, usar callbacks es una solución sencilla y
relativamente elegante. El problema es que es muy fácil que degenere. Si
queremos, por ejemplo, recuperar dos usuarios en lugar de uno, lo mismo
empezamos a tener callbacks anidados dentro de otros callbacks:

jQuery.ajax( {
url: 'https://server.com/wp-json/wp/v2/users/1',
success: ( user1 ) => {
jQuery.ajax( {
url: 'https://server.com/wp-json/wp/v2/users/2',
success: ( user2 ) => {
console.log( user1, user2 );
},
 } );
},
} );

Para solucionar este problema aparecieron las promises. La idea detrás del
concepto de promises es muy sencilla: en aquellos casos en los que obtener un
resultado no es immediato (como, por ejemplo, cuando recuperamos algo del
servidor), una promise en JavaScript es un objeto que sí podemos devolver al
instante que sirve como «promesa» de que, en un futuro, el resultado estará
disponible.

Por ejemplo, el primer código que hemos visto, escrito usando promises, sería tal
que así:

const promise = wp.apiFetch( {

url: 'https://server.com/wp-json/wp/v2/users/1',
} );
promise.then( ( user ) => console.log( user ) );

Como ves, la petición usando la librería wp.apiFetch devuelve una promise que
podemos asignar directamente a una variable. Luego, lo único que tenemos que
hacer es pasar un callback a la promise para recuperar el valor. Lo mismo estás
pensando que esto no es muy diferente a lo que hacíamos hasta ahora… pero la
ventaja es que, como te decía, nos permite ahorrar el código spaghetti:

const promise1 = wp.apiFetch( {

url: 'https://server.com/wp-json/wp/v2/users/1',
} );
const promise2 = wp.apiFetch( {
url: 'https://server.com/wp-json/wp/v2/users/2',
} );
Promise.all( [ promise1, promise2 ] ).then(
( [ user1, user2 ] ) => console.log( user1, user2 );
);

¿Has visto? Acabamos de lanzar dos peticiones en paralelo para recuperar los
usuarios 1 y 2 y luego, usando Promise.all, hemos esperado a que ambas
peticiones estuvieran resueltas para acceder a los resultados. No está nada mal,
¿eh?
Pues bien, JavaScript incluye una sintaxis adicional para trabajar con promises y
código asíncrono como si fuera síncrono. Lo único que debes hacer es definir una
función como asíncrona usando la palabra reservada async y, de repente, trabajar
con operaciones asíncronas en su cuerpo se convierte en un juego de niños:

async function logTwoUsers( id1, id2 ) {

const user1 = await wp.apiFetch( { url: '…' + id1 } );
const user2 = await wp.apiFetch( { url: '…' + id2 } );
console.log( user1, user2 );
}

Lo único que debes tener presente es que, cuando defines una operación
como async, el resultado de la misma siempre, siempre, siempre será
una promise (porque, por definición, una función asíncrona es aquella que, en
general, no puede devolverte un resultado en seguida):

async function getNumberFive() {

return 5;
}
const p = getNumberFive(); // a promise
p.then( console.log ); // prints "5"

#4 Ámbito de variables let y const

Este truquito es un poco menos impresionante que los anteriores, pero muy útil.
Como ya sabes, en las nuevas versiones de JavaScript puedes declarar variables
usando las palabras reservadas let y const. La primera define una variable a la
que le puedes cambiar el valor y la segunda define una constante:

let x = 1;
console.log( x ); // 1
x = 2;
console.log( x ); // 2
const y = 1;
console.log( y ); // 1
y = 2; // Uncaught TypeError: invalid assignment to const 'y'
console.log( y ); // 1
En principio puedes pensar que let es muy parecido al antiguo var, ¿no? Ambas
palabras clave permiten declarar una variable cuyo valor podemos cambiar. Pero
existe una diferencia sustancial entre ellos, y es el ámbito de aplicación de una
variable. Con let y const, el ámbito de la variable es el bloque donde se define.
En var, es la función entera.

function fn() {
if ( true ) {
var x = 1;
let y = 2;
const z = 3;
}//end if
console.log( x ); // 1
console.log( y ); // Uncaught ReferenceError: y is not defined
console.log( z ); // Uncaught ReferenceError: z is not defined
}

#5 Transformación de datos
usando JSON.parse
La función JSON.parse permite procesar una cadena de texto en formato JSON y
construir el objeto equivalente. Por ejemplo:

const x = JSON.parse( '{"x":1,"a":[1,2,3]}' );

// Object { x: 1, a: [ 1, 2, 3 ] }

Lo que mucha gente no sabe es que JSON.parse admite un segundo parámetro

llamado reviver. Este parámetro es una función que va a ejecutarse para cada
elemento que se está parseando y permite transformar el resultado. Por ejemplo,
imagina un objeto JSON como el siguiente:

const json = '{"name":"David","birthday":"1985-12-01T10:00:00.000Z"}';

Si usamos JSON.parse tal cual, nos generará un objeto con dos

atributos name y birthday de tipo string. Pero si le pasamos una
función reviver a JSON.parse, podemos indicarle transformaciones adicionales
como, por ejemplo, que birthday sea de tipo Date:

const user = JSON.parse(

json,
( key, value ) => 'birthday' === key
 ? new Date( value )
: value
)

#6 Separador de miles en el
código fuente usando _
El último truco que te traigo hoy es el separador de miles en el código fuente. Hay
una propuesta (actualmente, en fase 4) para permitir escribir los números en
nuestro código fuente de una forma que sea mucho más inteligible para los
humanos. Por ejemplo, ¿qué numeros ves aquí?

10000000000
2189719.25

Si pudiéramos usar el separador de miles, sería mucho más sencillo de interpretar,

¿verdad? Pues eso es precisamente lo que podemos hacer usando el guión
bajo _:

10_000_000_000
2_189_719.25

https://neliosoftware.com/es/blog/6-caracteristicas-de-javascript-que-debes-
conocer/

Tipos de datos primitivos y uso en JavaScript

Cómo se subdividen los tipos?

Los tipos de datos se subdividen en:

• Tipos primitivos.
• Tipos no primitivos.

En este artículo, abordaremos únicamente los tipos de datos primitivos.

A lo largo de la evolución de versiones de JS, ya hemos visto que las distintas
versiones han ido implementando nuevos cambios. Una muestra de ello, es que los
datos primitivos han ido aumentado con las distintas versiones de EcmaScript. Un
claro ejemplo de ello es que si miramos los tipos primitivos de la imagen superior y
la inferior podemos ver que en las últimas versiones que ha sacado EcmaScript se
han añadido también algunos tipos de datos.

Tipos primitivos:

Vamos a ver un ejemplo de cada uno:

→ string: el tipo de dato string almacena cadenas de texto. Un string, realmente es

un conjunto de caracteres. Cada uno de estos caracteres de la cadena ocupa una
posición dentro índice de la cadena, el primer elemento ocupará siempre el
elemento 0 del índice. Los escribimos entre comillas, simples (‘) o dobles (“).
→ number: engloba los números positivos hasta +9007199254740991 y negativos
hasta -9007199254740991. Entre estos números también son incluidos los números
decimales separados por un punto. Si por ejemplo, dividimos un número entre una
cadena de texto, podemos ver que el typeof arroja NaN. Esto se produce debido a
que esta operación no se puede realizar y el tipo que imprimirá será NaN ya que
dividir 5 entre una cadena de texto aparte de que no se posible realizar dicha división
como es lógico tampoco arrojará un tipo número. Por ello, muestra NaN

NaN → Not a Number

El número máximo y mínimo que podemos alcanzar con tipo number es:

→ bigInt: es el tipo de número más grande de JavaScript. Puede representar

valores superiores e inferiores a los del rango de los tipos number anteriores
(incluidos valores decimales). También se puede utilizar para almacenar números
que están dentro del rango de los tipos number.

→ boolean: El tipo booleano, es un valor lógico que tiene únicamente nos ofrece
dos posibles valores: verdadero y falso.
→ symbol (nuevo en ECMAScript 6): el tipo de dato symbol, lo usaremos para
crear identificadores únicos para objetos. Con ello, queremos decir, que cada objeto
será único (concepto de singleton) y si creamos dos objetos y comparamos sus tipos
el resultado que nos arrojará el console.log será true ya que ambos son de tipo
symbol. En caso de comparar los dos objetos (pese a que contienen lo mismo)
vemos que el resultado es false.

De hecho, hasta si creamos dos objetos sin añadirle valor, podemos ver que el
resultado con ambos operadores es false y false:

→ undefined: el tipo de dato undefined, nos sirve saber que tenemos variables sin
valores asignados.

→ null: es el tipo de dato más complicados de entender. Ya que, pese a que null
es un tipo de datos primitivo, cuando se hace un typeof de un tipo null, la consola
nos devolverá “object “.
Podemos asignar el valor null a cualquier variable, lo que básicamente significa que
está en blanco. Pero tenemos que declararlo nosotros (lo que se conoce como que
el programador tiene una intencionalidad → tener una intención) ya que por defecto
si no especificamos valor, el valor por defecto será undefined (tal y como hemos
visto en el tipo de dato anterior).

Null apunta a un objeto (nulo, dirección inexistente, inválido). Por lo que cuando
hacemos el typeof mostrará object aunque es un objeto de tipo null.

Lo más recomendable es no utilizar este tipo de dato primitivo. Ya que nos podemos
encontrar con muchos problemas. Vamos a ver algunos de ellos:

Comparando null VS null

Para comparar si es null un tipo de dato, no podemos hacer un typeof como hasta
ahora, ya que este, nos devuelve que es de tipo object. Para analizar si el valor de
una variable es null, en este caso, podemos utilizar la comparación de tipo de dato
== (compara si el valor es igual) y de === (compara valor y tipo de dato) y enfretarlo
contra null o contra un valor que sepamos que es null. En este caso, al ser
literalmente iguales tanto en valor como en tipo ambos resultados devuelven true.

Comparando undefined VS null

Hay que tener mucho cuidado con el operador que utilizamos cuando enfrentemos
un tipo de dato null vs un tipo de dato undefined. Ya que, si comparamos un tipo de
dato null con uno undefined según el tipo de operador que utilicemos en dicha
comparación podremos ver el resultado es uno u otro.

Si el operador == (compara si el valor es igual) nos imprimirá true. Ya que null es

vacío y undifined equivaldría a no definido y entonces, JavaScript interpreta que
ambos son relativamente iguales al representar un valor vacío devolviéndonos un
true.

Pero en cambio, si comparamos con el operador === (compara valor y tipo de dato)
vemos que da false porque como ya hemos visto, aunque en valor para JavaScript
sería el mismo (la ausencia de valor), también estamos comparando por tipo de dato
y null vs undefined no son iguales por lo que el resultado arrojado será un false.

JavaScript no se lleva “muy bien” con los null, así que, es mejor no declararlos
y trabajar directamente con valores undefined.

Espero que os hayan quedado un poco más claros los distintos tipos de datos
primitivos ya que esta información nos puede ser de utilizan para trabajar sobre
otros aspectos en JavaScript ¡Un saludo!

https://www.escuelafrontend.com/articulos/los-tipos-primitivos-en-javascript

Operadores en JavaScript

En el presente artículo del Manual de Javascript vamos a comenzar una serie de

textos enfocados en explicar los diferentes operadores disponibles en este
lenguaje de programación.
Al desarrollar programas en cualquier lenguaje se utilizan los operadores, que
sirven para hacer los cálculos y operaciones necesarios para llevar a cabo tus
objetivos. Hasta el menor de los programas imaginables necesita de los
operadores para realizar cosas, ya que un programa que no realizase
operaciones, sólo se limitaría a hacer siempre lo mismo.
Es el resultado de las operaciones lo que hace que un programa varíe su
comportamiento según los datos que tenga para trabajar y nos ofrezca resultados
que sean relevantes para el usuario que lo utilice. Existen operaciones más
sencillas o complejas, que se pueden realizar con operandos de distintos tipos,
como números o textos, veremos en este capítulo, y los siguientes, de manera
detallada todos estos operadores disponibles en Javascript.
Ejemplos de uso de operadores
Antes de entrar a enumerar los distintos tipos de operadores vamos a ver un par
de ejemplos de éstos para que nos ayuden a hacernos una idea más exacta de lo
que son. En el primer ejemplo vamos a realizar una suma utilizando el operador
suma.
3+5
Esta es una expresión muy básica que no tiene mucho sentido ella sola. Hace la
suma entre los dos operandos número 3 y 5, pero no sirve de mucho porque no se
hace nada con el resultado. Normalmente se combinan más de un operador para
crear expresiones más útiles. La expresión siguiente es una combinación entre
dos operadores, uno realiza una operación matemática y el otro sirve para guardar
el resultado.
miVariable = 23 * 5
En el ejemplo anterior, el operador * se utiliza para realizar una multiplicación y el
operador = se utiliza para asignar el resultado en una variable, de modo que
guardemos el valor para su posterior uso.
Los operadores se pueden clasificar según el tipo de acciones que realizan. A
continuación vamos a ver cada uno de estos grupos de operadores y
describiremos la función de cada uno.
Operadores aritméticos
Son los utilizados para la realización de operaciones matemáticas simples como la
suma, resta o multiplicación. En javascript son los siguientes:
+ Suma de dos valores
- Resta de dos valores, también puede utilizarse para cambiar el signo de un
número si lo utilizamos con un solo operando -23
* Multiplicación de dos valores
/ División de dos valores
% El resto de la división de dos números (3%2 devolvería 1, el resto de dividir 3
entre 2)
++ Incremento en una unidad, se utiliza con un solo operando
-- Decremento en una unidad, utilizado con un solo operando
Ejemplos
precio = 128 //introduzco un 128 en la variable precio
unidades = 10 //otra asignación, luego veremos operadores de asignación
factura = precio * unidades //multiplico precio por unidades, obtengo el valor
factura
resto = factura % 3 //obtengo el resto de dividir la variable factura por 3
precio++ //incrementa en una unidad el precio (ahora vale 129)
Operadores de asignación
Sirven para asignar valores a las variables, ya hemos utilizado en ejemplos
anteriores el operador de asignación =, pero hay otros operadores de este tipo,
que provienen del lenguaje C y que muchos de los lectores ya conocerán.
= Asignación. Asigna la parte de la derecha del igual a la parte de la izquierda. A
al derecha se colocan los valores finales y a la izquierda generalmente se coloca
una variable donde queremos guardar el dato.
+= Asignación con suma. Realiza la suma de la parte de la derecha con la de la
izquierda y guarda el resultado en la parte de la izquierda.
-= Asignación con resta
*= Asignación de la multiplicación
/= Asignación de la división
%= Se obtiene el resto y se asigna
Ejemplos
ahorros = 7000 //asigna un 7000 a la variable ahorros
ahorros += 3500 //incrementa en 3500 la variable ahorros, ahora vale 10500
ahorros /= 2 //divide entre 2 mis ahorros, ahora quedan 5250
En el siguiente artículo seguiremos conociendo otros de los operadores de
Javascript: Operadores de cadenas, operadores lógicos y operadores
condicionales.
Operadores de cadenas
Las cadenas de caracteres, o variables de texto, también tienen sus propios
operadores para realizar acciones típicas sobre cadenas. Aunque javascript sólo
tiene un operador para cadenas se pueden realizar otras acciones con una serie
de funciones predefinidas en el lenguaje que veremos más adelante.
+ Concatena dos cadenas, pega la segunda cadena a continuación de la primera.
Ejemplo
cadena1 = "hola"
cadena2 = "mundo"
cadenaConcatenada = cadena1 + cadena2 //cadena concatenada vale
"holamundo"
Un detalle importante que se puede ver en este caso es que el operador + sirve
para dos usos distintos, si sus operandos son números los suma, pero si se trata
de cadenas las concatena. Esto pasa en general con todos los operadores que se
repiten en el lenguaje, javascript es suficientemente listo para entender que tipo de
operación realizar mediante una comprobación de los tipos que están implicados
en élla.
Un caso que resultaría confuso es el uso del operador + cuando se realiza la
operación con operadores texto y numéricos entremezclados. En este caso
javascript asume que se desea realizar una concatenación y trata a los dos
operandos como si de cadenas de caracteres se trataran, incluso si la cadena de
texto que tenemos fuese un número. Esto lo veremos más fácilmente con el
siguiente ejemplo.
miNumero = 23
miCadena1 = "pepe"
miCadena2 = "456"
resultado1 = miNumero + miCadena1 //resultado1 vale "23pepe"
resultado2 = miNumero + miCadena2 //resultado2 vale "23456"
miCadena2 += miNumero //miCadena2 ahora vale "45623"
Como hemos podido ver, también en el caso del operador +=, si estamos tratando
con cadenas de texto y números entremezclados, tratará a los dos operadores
como si fuesen cadenas.
Nota: Como se puede haber imaginado, faltan muchas operaciones típicas a
realizar con cadenas, para las cuales no existen operadores. Es porque esas
funcionalidades se obtienen a través de la clase String de Javascript, que veremos
más adelante.
Operadores lógicos
Estos operadores sirven para realizar operaciones lógicas, que son aquellas que
dan como resultado un verdadero o un falso, y se utilizan para tomar decisiones
en nuestros scripts. En vez de trabajar con números, para realizar este tipo de
operaciones se utilizan operandos boleanos, que conocimos anteriormente, que
son el verdadero (true) y el falso (false). Los operadores lógicos relacionan los
operandos boleanos para dar como resultado otro operando boleano, tal como
podemos ver en el siguiente ejemplo.
Si tengo hambre y tengo comida entonces me pongo a comer
Nuestro programa Javascript utilizaría en este ejemplo un operando boleano para
tomar una decisión. Primero mirará si tengo hambre, si es cierto (true) mirará si
dispongo de comida. Si son los dos ciertos, se puede poner a comer. En caso de
que no tenga comida o que no tenga hambre no comería, al igual que si no tengo
hambre ni comida. El operando en cuestión es el operando Y, que valdrá
verdadero (true) en caso de que los dos operandos valgan verdadero.
Nota: Para no llevarnos a engaño, cabe decir que los operadores lógicos pueden
utilizarse en combinación con tipos de datos distintos de los boleanos, pero en
este caso debemos utilizarlos en expresiones que los conviertan en boleanos. En
el siguiente grupo de operadores que vamos a tratar en este artículo hablaremos
sobre los operadores condicionales, que se pueden utilizar junto con los
operadores lógicos para realizar sentencias todo lo complejas que necesitemos.
Por ejemplo:
if (x==2 && y!=3){
//la variable x vale 2 y la variable y es distinta de tres
}
En la expresión condicional anterior estamos evaluando dos comprobaciones que
se relacionan con un operador lógico. Por una parte x==2 devolverá un true en
caso que la variable x valga 2 y por otra, y!=3 devolverá un true cuando la variable
y tenga un valor distinto de 3. Ambas comprobaciones devuelven un boleano cada
una, que luego se le aplica el operador lógico && para comprobar si ambas
comprobaciones se cumplieron al mismo tiempo.

Sobra decir que, para ver ejemplos de operadores condicionales, necesitamos

aprender estructuras de control como if, a las que no hemos llegado todavía.
! Operador NO o negación. Si era true pasa a false y viceversa.
&& Operador Y, si son los dos verdaderos vale verdadero.
|| Operador O, vale verdadero si por lo menos uno de ellos es verdadero.
Ejemplo
miBoleano = true
miBoleano = !miBoleano //miBoleano ahora vale false
tengoHambre = true
tengoComida = true
comoComida = tengoHambre && tengoComida
Operadores condicionales
Sirven para realizar expresiones condicionales todo lo complejas que deseemos.
Estas expresiones se utilizan para tomar decisiones en función de la comparación
de varios elementos, por ejemplo si un numero es mayor que otro o si son iguales.
Nota: Por supuesto, los operadores condicionales sirven también para realizar
expresiones en las que se comparan otros tipos de datos. Nada impide comparar
dos cadenas, para ver si son iguales o distintas, por ejemplo. Incluso podríamos
comparar boleanos.
Los operadores condicionales se utilizan en las expresiones condicionales para
tomas de decisiones. Como estas expresiones condicionales serán objeto de
estudio más adelante será mejor describir los operadores condicionales más
adelante. De todos modos aquí podemos ver la tabla de operadores condicionales.
== Comprueba si dos valores son iguales
!= Comprueba si dos valores son distintos
> Mayor que, devuelve true si el primer operando es mayor que el segundo
< Menor que, es true cuando el elemento de la izquierda es menor que el de la
derecha
>= Mayor igual
<= Menor igual
Veremos ejemplos de operadores condicionales cuando expliquemos estructuras
de control, como la condicional if.
De manera adicional, en este texto veremos un asunto de bastante importancia en
la programación en general, que es la precedencia de operadores, que debemos
tener en cuenta siempre que utilicemos diversos operadores en una misma
expresión, para que se relacionen entre ellos y se resuelvan de la manera
habíamos planeado.
Operadores a nivel de bit
Estos son muy poco corrientes y es posible que nunca los llegues a utilizar. Su
uso se realiza para efectuar operaciones con ceros y unos. Todo lo que maneja un
ordenador son ceros y unos, aunque nosotros utilicemos números y letras para
nuestras variables en realidad estos valores están escritos internamente en forma
de ceros y unos. En algunos caso podremos necesitar realizar operaciones
tratando las variables como ceros y unos y para ello utilizaremos estos operandos.
En este manual se nos queda un poco grande realizar una discusión sobre este
tipo de operadores, pero aquí podréis ver estos operadores por si algún día os
hacen falta.
& Y de bits
^ Xor de bits
| O de bits
<< >> >>> >>>= >>= <<= Varias clases de cambios
Precedencia de los operadores
La evaluación de una sentencia de las que hemos visto en los ejemplos anteriores
es bastante sencilla y fácil de interpretar, pero cuando en una sentencia entran en
juego multitud de operadores distintos puede haber una confusión a la hora de
interpretarla y dilucidar qué operadores son los que se ejecutan antes que otros.
Para marcar unas pautas en la evaluación de las sentencias y que estas se
ejecuten siempre igual y con sentido común existe la precedencia de operadores,
que no es más que el orden por el que se irán ejecutando las operaciones que
ellos representan. En un principio todos los operadores se evalúan de izquierda a
derecha, pero existen unas normas adicionales, por las que determinados
operadores se evalúan antes que otros. Muchas de estas reglas de precedencia
están sacadas de las matemáticas y son comunes a otros lenguajes, las podemos
ver a continuación.
() [] . Paréntesis, corchetes y el operador punto que sirve para los objetos
! - ++ -- negación, negativo e incrementos
* / % Multiplicación división y módulo
+- Suma y resta
<< >> >>> Cambios a nivel de bit
< <= > >= Operadores condicionales
== != Operadores condicionales de igualdad y desigualdad
& ^ | Lógicos a nivel de bit
&& || Lógicos boleanos
= += -= *= /= %= <<= >>= >>>= &= ^= != Asignación
En los siguientes ejemplos podemos ver cómo las expresiones podrían llegar a ser
confusas, pero con la tabla de precedencia de operadores podremos entender sin
errores cuál es el orden por el que se ejecutan.

12 * 3 + 4 - 8 / 2 % 3
En este caso primero se ejecutan los operadores * / y %, de izquierda a derecha,
con lo que se realizarían estas operaciones. Primero la multiplicación y luego la
división por estar más a la izquierda del módulo.
36 + 4 - 4 % 3
Ahora el módulo.
36 + 4 - 1
Por último las sumas y las restas de izquierda a derecha.
40 - 1
Lo que nos da como resultado el valor siguiente.
39
De todos modos, es importante darse cuenta que el uso de los paréntesis puede
ahorrarnos muchos quebraderos de cabeza y sobretodo la necesidad de sabernos
de memoria la tabla de precedencia de los operadores. Cuando veamos poco
claro el orden con el que se ejecutarán las sentencias podemos utilizarlos y así
forzar que se evalúe antes el trozo de expresión que se encuentra dentro de los
paréntesis.
Para acabar con el tema de operadores de Javascript básicos nos quedan por ver
el Operador ternario en Javascript y también otro operador un tanto especial,
llamado typeof. En versiones del lenguaje más modernas añadieron más
operadores que podrás conocer en el Manual de Javascript ES6.

https://javadesde0.com/tipos-de-datos-primitivos-en-javascript/
https://desarrolloweb.com/articulos/529.php