const - JS | lectureJavaScript Fundamentals 1

An operator allows us to transform values or combine multiple values. There are many categories of operators .i.e. mathematical operators, logical operators, assignment operators etc.

Mathematical or Arithmetic Operators

We recently used the plus ( + ) operator, but of course there are more such as; multiplication ( * ), division ( / ), minus ( - ) etc.

Minus

const numberOfApples = 100;
const amountBought = 12
console.log(numberOfApples - amountBought) // Result ==> 88

Multiplication

console.log(amountBought * 2) // Result ==> 24

Division

console.log(amountBought / 10) // Result ==> 1.2

Exponentiation

// 2 ** 3 means 2 to the power of 3 .i.e. 2 x 2 x 2 = 8
console.log(2 ** 3) // Result ==> 8

String concatenation using the plus operator

const firstName = 'Ulrich'
const lastName = 'Ekeu'
console.log(firstName + ' ' + lastName) // Result ==> Ulrich Ekeu

Assignment Operators

The most straight forward assignment operator is just the equal ( = ) sign.

const result = 12 + 3

The equal sign is actually itself an operator. So in the above code snippet, we have two operators; the equal ( = ) and plus ( + ) operators. In this case, the result variable will be assigned 15, because the plus operator is executed before the assignment operator.

The order in which the operators are executed is based on a couple of rules about operator precedence that I will show you in the next lecture.

Addition assignment operator ( += )

let ulrichAge = 20
ulrichAge +=  10 // ulrichAge = ulrichAge + 10 = 30console.log(ulrichAge)

What the highlighted line does is simply to increment the value of ulrichAge by 10. That is, instead of writing ulrichAge = ulrichAge + 10, you can directly write ulrichAge += 10. Thus having 30 as the final result being assigned to ulrichAge.

It's basically the same idea with other assignment operators such as the substraction assignment ( -= ), exponentiation assignment (**= ), division assignment ( /= ) etc.

let u = 12
// Division assignment
console.log(u /= 2) // Result ==> 6

// Substraction assignment
console.log(u -= 3) // Result ==> 3

// Exponentiation assignment
console.log(u **= 2) // Result ==> 9

Increment ( ++ ) and Decrement ( -- ) Operators

All it does is either increment or decrement by one the value of the variable to which it is applied and returns a value. This operator can be used in two ways :

• Postfix Increment: Meaning the operator is placed after the variable. As an example, let's assume we have the following code snippet :

  script.js

    let valueToIncrement = 12
    let keepCurrentValue = valueToIncrement++

  What happens is that, the increment ( ++ ) operator will increment ( add one ) valueToIncrement ( meaning it's new value will be 13 ) and the value being returned to keepCurrentValue will be the value of valueToIncrement before it was incremented .i.e. 12

• Prefix Increment: Meaning the operator is placed before the variable. As an example, let's assume we have the following code snippet :

  script.js

    let valueToIncrement = 12
    let keepIncrementedValue = valueToIncrement++

  What happens is that, the increment ( ++ ) operator will increment ( add one ) valueToIncrement ( meaning it's new value will be 13 ) and the value being returned to keepIncrementedValue will be the value of valueToIncrement after it has been incremented .i.e. 13

I talked about postfix and prefix increment, but you have to remember that it's exactly the same idea as postfix and prefix decrement.

Comparison Operators

We use comparison operators to produce boolean values. They will be useful later when we start making decisions with our code based on some conditions. Some examples of comparison operators are, the greater than operator ( > ), the less than operator ( < ), the less than or equal operator ( <= ), the greater than or equal operator ( >= ) etc.

Greater than operator ( > )

The greater than operator checks if the left variable of the operator is greater than the right variable of the operator. If it is greater, it returns true else;, it returns false.

    let ageJacob = 12
    let ageUlrich = 62
    // Returns false since 12 is not greater than 20
    console.log(ageJacob > ageUlrich) // Result ==> false

From the above code snippet, the left variable is ageJacob and the right variable ageUlrich. Since ageJacob isn't greater than ageUlrich the returned value is false.

Greater than or equal operator ( >= )

The greater than or equal operator checks if the left variable of the operator is greater than or equal to the right variable of the operator. If it is greater or equal, it returns true else;, it returns false.

    //Let's check if Ulrich has reached the retirement age
    console.log(ageUlrich >= 62) // Result ==> true

From the above code snippet, the left variable is ageUlrich, and the right variable 62. Using the greater than or equal operator, we check to see if Ulrich's age is at least 62. At least, meaning his age is greater than 62 or exactly 62. In this case, it is exactly 62, and the returned value will be true.

To finish the lecture, I want to let you know that you can see the full list of operators used in JavaScript on MDN.