Fundamental

Variables

var x = 1; // Too old...
const y = 3;
let z = 2;

let

To create a variable, use the let keyword.

let message;
message = "Hello"; // store the string 'Hello' in the variable named message

const

To declare a constant (unchanging) variable, use const instead of let:

const myBirthday = "29.08.2000";

myBirthday = "15.02.2004"; // error, can't reassign the constant!

For the object constant variable, we still can reassign its fields, but not the whole object itself.

const obj = {
  name: "Tu",
};

obj.name = "Tuslipid"; // name: Tuslipid
obj = {
  name: "Tusss",
}; // error, can't reassign the constant!

var

In older scripts, you may also find another keyword: var instead of let:

var message = "Hello";

The var keyword is almost the same as let. It also decalares variable, but in a slightly different, old-school way.

There are subtle differences between let and var, learn more at The old var.

It is recommended to use const, let instead of var.

Data types

NaN, null and undefined

• NaN A computational error. It is a result of an incorrect or and undefined mathematical operation. NaN is sticky. Any further mathematical operation on NaN returns NaN.

alert("not a number" / 2); // NaN, such division is erroneous

alert(NaN + 1); // NaN

• null In JavaScript, null is not a reference to a non-existing object or a null pointer like in some other languages. It's just a speical value shich represents nothing, empty or value unknown.

let age = null; // age is unknown

• undefined The meaning of undefined is value is not assigned. If a variable is declared, but not assigned, then its value is undefined:

let age;
alert(age); // undefined

Interaction

• alert

• prompt

• confirm

Comparisons

== vs ===

A strict equality operator === checks the equality without type conversion. In other words, if a and b are different types, then a === b immediately returns false without an attempt to convert them.

In a == b, if the type of a is different from b, b needs converting to the same type of a then check the equality.

0 == false; // true
0 === false; // false

Logical operators

! (NOT)

The boolean NOT operator accepts a single argument and does the following:

1. Converts the operand to boolean type: true/false.

2. Returns the inverse value. true/false -> false/true

// The boolean value of all variables except 0, false, null, undefined are TRUE.
!true; // false
!"non-empty string"; // false
![1, 2, 3]; // false
!!"non-empty string"; // true

!0; // true
!null; // true
!undefined; // true
!false; // true

!a does not mean a != null or a !== null && a !== undefined.

Nullish coalescing operator ??

?? returns the first arguments if it's not null/undefined. Otherwise, the second one.

result = a ?? b;

// same as
result = a != null ? a : b;

Comparison with ||:

• || returns the first truthy value. || doesn't distinguish between false, 0, and empty string "" and null/undefined.

• ?? returns the first defined value.

let height = 0;
alert(height || 100); // 100
alert(height ?? 100); // 0

Loop for

• for (basic)

• forEach

array.forEach((element) => element);

• for...in

for (const key in obj) {
  if (Object.hasOwnProperties(key)) {
    const element = obj[key];
  }
}

• for...of

for (const iterator of obj) {
  const value = iterator;
}

Functions

Function declaration:

function func() {}

Function expression:

const func = function () {};

Arrow function:

const func = () => {};

Code quality

Polyfills and transpilers

Polyfills

The scripts that update/add new functions.

Transpilers

Translate code to a different version.