Ir al contenido principal

Asignación, operadores aritméticos y concatenación

Las asignaciones clonan, los operadores crean.

En este capítulo vamos a repasar los operadores más básicos y, por tanto, los más utilizados en la mayoría de lenguajes de programación: los operadores de asignación y los operadores aritméticos.

También cubriremos los operadores de concatenación de cadenas, que por su similitud con ciertos operadores aritméticos encajan en este capítulo.

Índice

  1. Asignación simple
  2. Operadores aritméticos
    1. Operadores binarios
    2. Operadores unarios
    3. Precedencia de operadores
    4. Conversión implícita
  3. Concatenación
    1. Conversión implícita
  4. Asignación compuesta
  5. Lo que hemos conseguido
  6. A continuación

Asignación simple

La asignación simple en Node.JS se basa en el símbolo =. En capítulos anteriores ya vimos ejemplos de su uso que reutilizamos aquí: 

// Asigna la cadena "Hola, mundo!" a la variable message
let message = "Hola, mundo!"

// Reasigna el número 123456 a la variable message
message = 123456

// Asigna el valor true a la constante truthy
const truthy = true

// Asigna el valor de una constante a una variable
let alsoTruthy = truthy

Operadores aritméticos

Los operadores aritméticos en Node.JS permiten realizar operaciones matemáticas.

Se dividen en dos grupos: los que requieren dos operandos (operadores binarios) y los que requieren uno solo (operadores unarios).

Operadores binarios

Son los que toman dos operandos numéricos y devuelven también un valor numérico.

Operador Operación Ejemplo
+ Suma 
const five = 2 + 3
- Resta 
const one = 3 - 2
* Multiplicación 
const ten = 5 * 2
/ División 
const three = 6 / 2
** Exponenciación 
const sixteen = 2 ** 4
% Resto de división 
const two = 8 % 3

Operadores unarios

Los operadores unarios operan sobre un único operando y son dos: operador de incremento (++) y de decremento (--).

El incremento suma 1 al valor de la variable y el decremento resta 1. Ejemplo: 

let unaryVar = 2
console.log(unaryVar)	// 2

unaryVar++
console.log(unaryVar)	// 3

unaryVar--
console.log(unaryVar)	// 2

La posición del operador unario, antes o despues de la variable sobre la que opera, influye en el comportamiento:

  • Si el operador unario precede a la variable (++unaryVar), primero se modifica el valor de la variable y luego se devuelve dicho valor.
  • Si la variable precede al operador unario (unaryVar++), primero se devuelve el valor de la variable para luego modificarlo.
let varA = 2

// Primero devuelve el valor, luego incrementa
const varB = varA++
console.log(varB)	// 2
console.log(varA)	// 3

// Primero decrementa, luego devuelve
const varC = --varA
console.log(varC)	// 2
console.log(varA)	// 2

Precedencia de operadores

El orden de aplicación en Node.JS es el habitual en otros lenguajes de programación:

  1. Exponenciación (**)
  2. Multiplicativos (*, /, %)
  3. Aditivos (+, -)
// 7
console.log(2 ** 2 + 6 / 2)

Y, como en otros lenguajes de programación, el uso de paréntesis altera las reglas de precedencia: 

// 16
console.log(2 ** ((2 + 6) / 2))

Conversión implícita

En el capítulo Tipos de datos básicos vimos cómo hacer conversiones explícitas.

Sin embargo, Node.JS también realiza conversiones implícitas al usar valores string o boolean en operaciones aritméticas: 

// 3
console.log(2 + true)

// 10
console.log(5 * "2")

Si la conversión falla, el resultado es NaN, como vimos en Valores especiales.

Concatenación

El operador de concatenación (+) combina dos valores de tipo string en uno nuevo. 

const firstWord = "Hola"
const secondWord = "mundo"

const helloWorld = firstWord + ", " + secondWord + "!"
console.log(helloWorld)	// "Hola, mundo!"

Conversión implícita

Como en el caso de los operadores aritméticos, Node.JS es capaz de llevar a cabo conversiones implícitas si se utilizan valores de tipo number o boolean en operaciones de concatenación: 

const one = 1
console.log("Número " + one)	// "Número 1"

console.log("True no es " + false)	// "True no es false"

Asignación compuesta

La asignación compuesta es un híbrido entre operacion aritmética, especificamente suma o resta, y asignación: Permite, con un solo operador, incrementar o decrementar el valor de una variable en una cierta cantidad y reasignar el resultado en la misma variable. 

let myVar = 1

console.log(myVar += 2)	// 3
console.log(myVar)	    // 3

myVar -= 3
console.log(myVar)	    // 0

También funciona con cadenas: 

let myVar = "Hola, "

console.log(myVar += "mundo!")	// "Hola, mundo!"
console.log(myVar)	            // "Hola, mundo!"

Lo que hemos conseguido

En este capítulo has aprendido:

  • A asignar valores a variables y constantes con =.
  • A usar operadores aritméticos binarios (+, -, *, /, %, **) y unarios (++, --), así como su precedencia.
  • Que Node.JS puede realizar conversiones implícitas en operaciones aritméticas.
  • A concatenar cadenas y a reconocer las conversiones implícitas con number y boolean.
  • A utilizar asignaciones compuestas (+=, -=) con números y cadenas.

A continuación

El próximo capítulo tratará sobre comparaciones y operadores lógicos. Con ambos tendrás una visión completa de las operaciones posibles en Node.JS, ya sea con number, string o boolean.

Labels: