JavaScript syntax

Keywords

Case sensitivity

JavaScript is case sensitive. It is common to start the name of a constructor with a capitalized letter, and the name of a function or variable with a lower-case letter.

Example:

var a = 5;
console.log(a); // 5
console.log(A); // throws a ReferenceError: A is not defined

Whitespace and semicolons

Unlike in C, whitespace in JavaScript source can directly impact semantics. Semicolons end statements in JavaScript. Because of automatic semicolon insertion (ASI), some statements that are well formed when a newline is parsed will be considered complete, as if a semicolon were inserted just prior to the newline. Some authorities advise supplying statement-terminating semicolons explicitly, because it may lessen unintended effects of the automatic semicolon insertion.^[3]

There are two issues: five tokens can either begin a statement or be the extension of a complete statement; and five restricted productions, where line breaks are not allowed in certain positions, potentially yielding incorrect parsing.

The five problematic tokens are the open parenthesis "(", open bracket "[", slash "/", plus "+", and minus "-". Of these, the open parenthesis is common in the immediately invoked function expression pattern, and open bracket occurs sometimes, while others are quite rare. An example:

a = b + c
(d + e).foo()

// Treated as:
// a = b + c(d + e).foo();

with the suggestion that the preceding statement be terminated with a semicolon.

Some suggest instead the use of leading semicolons on lines starting with '(' or '[', so the line is not accidentally joined with the previous one. This is known as a defensive semicolon, and is employed because code may otherwise become ambiguous when it is rearranged. For example:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Initial semicolons are also sometimes used at the start of JavaScript libraries, in case they are appended to another library that omits a trailing semicolon, as this can result in ambiguity of the initial statement. In such a case where perhaps unusual semicolon placement occurs, it may just be better to manually place semicolons at the end of statements.

The five restricted productions are return, throw, break, continue, and post-increment/decrement. In all cases, inserting semicolons does not fix the problem, but makes the parsed syntax clear, making the error easier to detect. return and throw take an optional value, while break and continue take an optional label. In all cases, the advice is to keep the value or label on the same line as the statement. This most often shows up in the return statement, where one might return a large object literal, which might be accidentally placed starting on a new line. For post-increment/decrement, there is potential ambiguity with pre-increment/decrement, and again it is recommended to simply keep these on the same line.

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Comments

Comment syntax is the same as in C++, Swift and other programming languages.

Single-line comments begin with // and continue until the end of the line. A second type of comments can also be made; these start with /* and end with */ and can be used for multi-line comments.

A third type of comment, the hashbang comment, starts with #! and continues until the end of the line. They are only valid at the start of files and are intended for use in CLI environments.^[4]

#! Hashbang comment

// One-line comment

/* Multi-line
   comment */

Scoping and hoisting

Variables declared with var are lexically scoped at a function level, while ones with let or const have a block level scope. Since declarations are processed before any code is executed, a variable can be assigned to and used prior to being declared in the code.^[7] This is referred to as hoisting, and it is equivalent to variables being forward declared at the top of the function or block.^[8]

With var, let, and const statements, only the declaration is hoisted; assignments are not hoisted. Thus a var x = 1 statement in the middle of the function is equivalent to a var x declaration statement at the top of the function, and an x = 1 assignment statement at that point in the middle of the function. This means that values cannot be accessed before they are declared; forward reference is not possible. With var a variable's value is undefined until it is initialized. Variables declared with let or const cannot be accessed until they have been initialized, so referencing such variables before will cause an error.

Function declarations, which declare a variable and assign a function to it, are similar to variable statements, but in addition to hoisting the declaration, they also hoist the assignment – as if the entire statement appeared at the top of the containing function – and thus forward reference is also possible: the location of a function statement within an enclosing function is irrelevant. This is different from a function expression being assigned to a variable in a var, let, or const statement.

So, for example,

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Block scoping can be produced by wrapping the entire block in a function and then executing it – this is known as the immediately-invoked function expression pattern – or by declaring the variable using the let keyword.

Declaration and assignment

Variables declared outside a scope are global. If a variable is declared in a higher scope, it can be accessed by child scopes.

When JavaScript tries to resolve an identifier, it looks in the local scope. If this identifier is not found, it looks in the next outer scope, and so on along the scope chain until it reaches the global scope where global variables reside. If it is still not found, JavaScript will raise a ReferenceError exception.

When assigning an identifier, JavaScript goes through exactly the same process to retrieve this identifier, except that if it is not found in the global scope, it will create the "variable" in the scope where it was created.^[9] As a consequence, a variable never declared will be global, if assigned. Declaring a variable (with the keyword var) in the global scope (i.e. outside of any function body (or block in the case of let/const)), assigning a never declared identifier or adding a property to the global object (usually window) will also create a new global variable.

Note that JavaScript's strict mode forbids the assignment of an undeclared variable, which avoids global namespace pollution.

Examples

Here are some examples of variable declarations and scope:

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it was not declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

Undefined

The value of "undefined" is assigned to all uninitialized variables, and is also returned when checking for object properties that do not exist. In a Boolean context, the undefined value is considered a false value.

Note: undefined is considered a genuine primitive type. Unless explicitly converted, the undefined value may behave unexpectedly in comparison to other types that evaluate to false in a logical context.

let test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
const testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Note: There is no built-in language literal for undefined. Thus (x === undefined) is not a foolproof way to check whether a variable is undefined, because in versions before ECMAScript 5, it is legal for someone to write var undefined = "I'm defined now";. A more robust approach is to compare using (typeof x === 'undefined').

Functions like this will not work as expected:

function isUndefined(x) { let u; return x === u; }             // like this...
function isUndefined(x) { return x === void 0; }               // ... or that second one
function isUndefined(x) { return (typeof x) === "undefined"; } // ... or that third one

Here, calling isUndefined(my_var) raises a ReferenceError if my_var is an unknown identifier, whereas typeof my_var === 'undefined' does not.

Number

Numbers are represented in binary as IEEE 754 floating point doubles. Although this format provides an accuracy of nearly 16 significant digits, it cannot always exactly represent real numbers, including fractions.

This becomes an issue when comparing or formatting numbers. For example:

console.log(0.2 + 0.1 === 0.3); // displays false
console.log(0.94 - 0.01);       // displays 0.9299999999999999

As a result, a routine such as the toFixed() method should be used to round numbers whenever they are formatted for output.

Numbers may be specified in any of these notations:

345;    // an "integer", although there is only one numeric type in JavaScript
34.5;   // a floating-point number
3.45e2; // another floating-point, equivalent to 345
0b1011; // a binary integer equal to 11
0o377;   // an octal integer equal to 255
0xFF;   // a hexadecimal integer equal to 255, digits represented by the ...
        // ... letters A-F may be upper or lowercase

There is also a numeric separator, _ (the underscore), introduced in ES2021:

// Note: Wikipedia syntax does not support numeric separators yet
1_000_000_000;    // Used with big numbers
1_000_000.5;      // Support with decimals
1_000e1_000;      // Support with exponents

// Support with binary, octals and hex
0b0000_0000_0101_1011;
0o0001_3520_0237_1327;
0xFFFF_FFFF_FFFF_FFFE;

// But users cannot use them next to a non-digit number part, or at the start or end
_12; // Variable is not defined (the underscore makes it a variable identifier)
12_; // Syntax error (cannot be at the end of numbers)
12_.0; // Syntax error (does not make sense to put a separator next to the decimal point)
12._0; // Syntax error
12e_6; // Syntax error (next to "e", a non-digit. Does not make sense to put a separator at the start)
1000____0000; // Syntax error (next to "_", a non-digit. Only 1 separator at a time is allowed

The extents +∞, −∞ and NaN (Not a Number) of the number type may be obtained by two program expressions:

Infinity; // positive infinity (negative obtained with -Infinity for instance)
NaN;      // The Not-A-Number value, also returned as a failure in ...
          // ... string-to-number conversions

Infinity and NaN are numbers:

typeof Infinity;   // returns "number"
typeof NaN;        // returns "number"

These three special values correspond and behave as the IEEE-754 describes them.

The Number constructor (used as a function), or a unary + or -, may be used to perform explicit numeric conversion:

const myString = "123.456";
const myNumber1 = Number(myString);
const myNumber2 = +myString;

When used as a constructor, a numeric wrapper object is created (though it is of little use):

const myNumericWrapper = new Number(123.456);

However, NaN is not equal to itself:

const nan = NaN;
console.log(NaN == NaN);        // false
console.log(NaN === NaN);       // false
console.log(NaN !== NaN);       // true
console.log(nan !== nan);       // true

// Users can use the isNaN methods to check for NaN
console.log(isNaN("converted to NaN"));     // true
console.log(isNaN(NaN));                    // true
console.log(Number.isNaN("not converted")); // false
console.log(Number.isNaN(NaN));             // true

BigInt

In JavaScript, regular numbers are represented with the IEEE 754 floating point type, meaning integers can only safely be stored if the value falls between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.^[10] BigInts instead represent integers of any size, allowing programmers to store integers too high or low to be represented with the IEEE 754 format.^[11]

There are two ways to declare a BigInt value. An n can be appended to an integer, or the BigInt function can be used:^[11]

const a = 12345n; // Creates a variable and stores a BigInt value of 12345
const b = BigInt(12345);

String

A string in JavaScript is a sequence of characters. In JavaScript, strings can be created directly (as literals) by placing the series of characters between double (") or single (') quotes. Such strings must be written on a single line, but may include escaped newline characters (such as \n). The JavaScript standard allows the backquote character (`, a.k.a. grave accent or backtick) to quote multiline literal strings, as well as embedded expressions using the syntax ${expression}.^[12]

const greeting = "Hello, World!";
const anotherGreeting = 'Greetings, people of Earth.';
const aMultilineGreeting = `Warm regards,
John Doe.`

// Template literals type-coerce evaluated expressions and interpolate them into the string.
const templateLiteral = `This is what is stored in anotherGreeting: ${anotherGreeting}.`;
console.log(templateLiteral); // 'This is what is stored in anotherGreeting: 'Greetings, people of Earth.''
console.log(`You are ${Math.floor(age)=>18 ? "allowed" : "not allowed"} to view this web page`);

Individual characters within a string can be accessed using the charAt method (provided by String.prototype). This is the preferred way when accessing individual characters within a string, because it also works in non-modern browsers:

const h = greeting.charAt(0);

In modern browsers, individual characters within a string can be accessed (as strings with only a single character) through the same notation as arrays:

const h = greeting[0];

However, JavaScript strings are immutable:

greeting[0] = "H"; // Fails

Applying the equality operator ("==") to two strings returns true, if the strings have the same contents, which means: of the same length and containing the same sequence of characters (case is significant for alphabets). Thus:

const x = "World";
const compare1 = ("Hello, " + x == "Hello, World"); // Here compare1 contains true.
const compare2 = ("Hello, " + x == "hello, World"); // Here compare2 contains  ...
                                                    // ... false since the ...
                                                    // ... first characters ...
                                                    // ... of both operands ...
                                                    // ... are not of the same case.

Quotes of the same type cannot be nested unless they are escaped.

let x = '"Hello, World!" he said.'; // Just fine
x = ""Hello, World!" he said."; //  Not good
x = "\"Hello, World!\" he said."; // Works by escaping " with \"

The String constructor creates a string object (an object wrapping a string):

const greeting = new String("Hello, World!");

These objects have a valueOf method returning the primitive string wrapped within them:

const s = new String("Hello !");
typeof s; // Is 'object'
typeof s.valueOf(); // Is 'string'

Equality between two String objects does not behave as with string primitives:

const s1 = new String("Hello !");
const s2 = new String("Hello !");
s1 == s2; // Is false, because they are two distinct objects
s1.valueOf() == s2.valueOf(); // Is true

Boolean

JavaScript provides a Boolean data type with true and false literals. The typeof operator returns the string "boolean" for these primitive types. When used in a logical context, 0, -0, null, NaN, undefined, and the empty string ("") evaluate as false due to automatic type conversion. All other values (the complement of the previous list) evaluate as true, including the strings "0", "false" and any object.

Type conversion

Automatic type coercion by the equality comparison operators (== and !=) can be avoided by using the type checked comparison operators (=== and !==).

When type conversion is required, JavaScript converts Boolean, Number, String, or Object operands as follows:^[13]

Number and String

The string is converted to a number value. JavaScript attempts to convert the string numeric literal to a Number type value. First, a mathematical value is derived from the string numeric literal. Next, this value is rounded to nearest Number type value.

Boolean

If one of the operands is a Boolean, the Boolean operand is converted to 1 if it is true, or to 0 if it is false.

Object

If an object is compared with a number or string, JavaScript attempts to return the default value for the object. An object is converted to a primitive String or Number value, using the .valueOf() or .toString() methods of the object. If this fails, a runtime error is generated.

// Automatic type coercion
console.log(true  ==   2 ); // false... true  → 1 !== 2 ←  2
console.log(false ==   2 ); // false... false → 0 !== 2 ←  2
console.log(true  ==   1 ); // true.... true  → 1 === 1 ←  1
console.log(false ==   0 ); // true.... false → 0 === 0 ←  0
console.log(true  ==  "2"); // false... true  → 1 !== 2 ← "2"
console.log(false ==  "2"); // false... false → 0 !== 2 ← "2"
console.log(true  ==  "1"); // true.... true  → 1 === 1 ← "1"
console.log(false ==  "0"); // true.... false → 0 === 0 ← "0"
console.log(false ==  "" ); // true.... false → 0 === 0 ← ""
console.log(false ==  NaN); // false... false → 0 !== NaN

console.log(NaN == NaN); // false...... NaN is not equivalent to anything, including NaN.

// Type checked comparison (no conversion of types and values)
console.log(true === 1); // false...... data types do not match

// Explicit type coercion
console.log(true === !!2);   // true.... data types and values match
console.log(true === !!0);   // false... data types match, but values differ
console.log( 1  ? true : false); // true.... only ±0 and NaN are "falsy" numbers
console.log("0" ? true : false); // true.... only the empty string is "falsy"
console.log(Boolean({}));    // true.... all objects are "truthy"

const b = new Boolean(false);   // Object  false {}
const t = Boolean(b);           // Boolean true
const f = Boolean(b.valueOf()); // Boolean false
let n = new Boolean(b);       // Not recommended
n = new Boolean(b.valueOf()); // Preferred

if (0 || -0 || "" || null || undefined || b.valueOf() || !new Boolean() || !t) {
  console.log("Never this");
} else if ([] && {} && b && typeof b === "object" && b.toString() === "false") {
  console.log("Always this");
}

Symbol

Symbols are a feature introduced in ES6. Each symbol is guaranteed to be a unique value, and they can be used for encapsulation.^[15]

Example:

let x = Symbol(1);
const y = Symbol(1);
x === y; // => false

const symbolObject = {};
const normalObject = {};

// since x and y are unique,
// they can be used as unique keys in an object
symbolObject[x] = 1;
symbolObject[y] = 2;

symbolObject[x]; // => 1
symbolObject[y]; // => 2

// as compared to normal numeric keys
normalObject[1] = 1;
normalObject[1] = 2; // overrides the value of 1

normalObject[1]; // => 2

// changing the value of x does not change the key stored in the object
x = Symbol(3);
symbolObject[x]; // => undefined

// changing x back just creates another unique Symbol
x = Symbol(1);
symbolObject[x]; // => undefined

There are also well known symbols.

One of which is Symbol.iterator; if something implements Symbol.iterator, it is iterable:

const x = [1, 2, 3, 4]; // x is an Array
x[Symbol.iterator] === Array.prototype[Symbol.iterator]; // and Arrays are iterable

const xIterator = x[Symbol.iterator](); // The [Symbol.iterator] function should provide an iterator for x
xIterator.next(); // { value: 1, done: false }
xIterator.next(); // { value: 2, done: false }
xIterator.next(); // { value: 3, done: false }
xIterator.next(); // { value: 4, done: false }
xIterator.next(); // { value: undefined, done: true }
xIterator.next(); // { value: undefined, done: true }

// for..of loops automatically iterate values
for (const value of x) {
   console.log(value); // 1 2 3 4
}

// Sets are also iterable:
[Symbol.iterator] in Set.prototype; // true

for (const value of new Set(['apple', 'orange'])) {
   console.log(value); // "apple" "orange"
}

Array

An Array is a JavaScript object prototyped from the Array constructor specifically designed to store data values indexed by integer keys. Arrays, unlike the basic Object type, are prototyped with methods and properties to aid the programmer in routine tasks (for example, join, slice, and push).

As in the C family, arrays use a zero-based indexing scheme: A value that is inserted into an empty array by means of the push method occupies the 0th index of the array.

const myArray = [];          // Point the variable myArray to a newly ...
                             // ... created, empty Array
myArray.push("hello World"); // Fill the next empty index, in this case 0
console.log(myArray[0]);     // Equivalent to console.log("hello World");

Arrays have a length property that is guaranteed to always be larger than the largest integer index used in the array. It is automatically updated, if one creates a property with an even larger index. Writing a smaller number to the length property will remove larger indices.

Elements of Arrays may be accessed using normal object property access notation:

myArray[1];  // the 2nd item in myArray
myArray["1"];

The above two are equivalent. It is not possible to use the "dot"-notation or strings with alternative representations of the number:

myArray.1;     // syntax error
myArray["01"]; // not the same as myArray[1]

Declaration of an array can use either an Array literal or the Array constructor:

let myArray;

// Array literals
myArray = [1, 2]; // length of 2
myArray = [1, 2,]; // same array - Users can also have an extra comma at the end

// It is also possible to not fill in parts of the array
myArray = [0, 1, /* hole */, /* hole */, 4, 5]; // length of 6
myArray = [0, 1, /* hole */, /* hole */, 4, 5,]; // same array
myArray = [0, 1, /* hole */, /* hole */, 4, 5, /* hole */,]; // length of 7

// With the constructor
myArray = new Array(0, 1, 2, 3, 4, 5); // length of 6
myArray = new Array(365);              // an empty array with length 365

Arrays are implemented so that only the defined elements use memory; they are "sparse arrays". Setting myArray[10] = 'someThing' and myArray[57] = 'somethingOther' only uses space for these two elements, just like any other object. The length of the array will still be reported as 58. The maximum length of an array is 4,294,967,295 which corresponds to 32-bit binary number (11111111111111111111111111111111)₂.

One can use the object declaration literal to create objects that behave much like associative arrays in other languages:

const dog = {color: "brown", size: "large"};
dog["color"]; // results in "brown"
dog.color;    // also results in "brown"

One can use the object and array declaration literals to quickly create arrays that are associative, multidimensional, or both. (Technically, JavaScript does not support multidimensional arrays, but one can mimic them with arrays-of-arrays.)

const cats = [{color: "brown", size: "large"},
    {color: "black", size: "small"}];
cats[0]["size"];      // results in "large"

const dogs = {rover: {color: "brown", size: "large"},
    spot: {color: "black", size: "small"}};
dogs["spot"]["size"]; // results in "small"
dogs.rover.color;     // results in "brown"

Date

A Date object stores a signed millisecond count with zero representing 1970-01-01 00:00:00 UT and a range of ±10⁸ days. There are several ways of providing arguments to the Date constructor. Note that months are zero-based.

new Date();                       // create a new Date instance representing the current time/date.
new Date(2010, 2, 1);             // create a new Date instance representing 2010-Mar-01 00:00:00
new Date(2010, 2, 1, 14, 25, 30); // create a new Date instance representing 2010-Mar-01 14:25:30
new Date("2010-3-1 14:25:30");    // create a new Date instance from a String.

Methods to extract fields are provided, as well as a useful toString:

const d = new Date(2010, 2, 1, 14, 25, 30); // 2010-Mar-01 14:25:30;

// Displays '2010-3-1 14:25:30':
console.log(d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate() + ' '
    + d.getHours() + ':' + d.getMinutes() + ':' + d.getSeconds());

// Built-in toString returns something like 'Mon 1 March, 2010 14:25:30 GMT-0500 (EST)':
console.log(d);

Error

Custom error messages can be created using the Error class:

throw new Error("Something went wrong.");

These can be caught by try...catch...finally blocks as described in the section on exception handling.

Math

The Math object contains various math-related constants (for example, π) and functions (for example, cosine). (Note that the Math object has no constructor, unlike Array or Date. All its methods are "static", that is "class" methods.) All the trigonometric functions use angles expressed in radians, not degrees or grads.

Methods of the Math object

Example	Returned value rounded to 5 digits	Description
Math.abs(-2.3)	2.3	Absolute value
Math.acos(Math.SQRT1_2)	0.78540 rad = 45°	Arccosine
Math.asin(Math.SQRT1_2)	0.78540 rad = 45°	Arcsine
Math.atan(1)	0.78540 rad = 45°	Half circle arctangent (⁠${\displaystyle -\pi /2}$⁠ to ⁠${\displaystyle +\pi /2}$⁠)
Math.atan2(-3.7, -3.7)	−2.3562 rad = −135°	Whole circle arctangent (⁠${\displaystyle -\pi }$⁠ to ⁠${\displaystyle +\pi }$⁠)
Math.ceil(1.1)	2	Ceiling: round up to smallest integer ≥ argument
Math.cos(Math.PI/4)	0.70711	Cosine
Math.exp(1)	2.7183	Exponential function: e raised to this power
Math.floor(1.9)	1	Floor: round down to largest integer ≤ argument
Math.log(Math.E)	1	Natural logarithm, base e
Math.max(1, -2)	1	Maximum: (x > y) ? x : y
Math.min(1, -2)	−2	Minimum: (x < y) ? x : y
Math.pow(-3, 2)	9	Exponentiation (raised to the power of): Math.pow(x, y) gives xy
Math.random()	e.g. 0.17068	Pseudorandom number between 0 (inclusive) and 1 (exclusive)
Math.round(1.5)	2	Round to the nearest integer; half fractions are rounded up (e.g. 1.5 rounds to 2)
Math.sin(Math.PI/4)	0.70711	Sine
Math.sqrt(49)	7	Square root
Math.tan(Math.PI/4)	1	Tangent

Regular expression

/expression/.test(string);     // returns Boolean
"string".search(/expression/); // returns position Number
"string".replace(/expression/, replacement);

// Here are some examples
if (/Tom/.test("My name is Tom")) console.log("Hello Tom!");
console.log("My name is Tom".search(/Tom/));          // == 11 (letters before Tom)
console.log("My name is Tom".replace(/Tom/, "John")); // == "My name is John"

// \d  - digit
// \D  - non digit
// \s  - space
// \S  - non space
// \w  - word char
// \W  - non word
// [ ] - one of
// [^] - one not of
//  -  - range

if (/\d/.test('0'))                   console.log('Digit');
if (/[0-9]/.test('6'))                console.log('Digit');
if (/[13579]/.test('1'))              console.log('Odd number');
if (/\S\S\s\S\S\S\S/.test('My name')) console.log('Format OK');
if (/\w\w\w/.test('Tom'))             console.log('Hello Tom');
if (/[a-zA-Z]/.test('B'))             console.log('Letter');

// A...Z a...z 0...9  - alphanumeric
// \u0000...\uFFFF    - Unicode hexadecimal
// \x00...\xFF        - ASCII hexadecimal
// \t                 - tab
// \n                 - new line
// \r                 - CR
// .                  - any character
// |                  - OR

if (/T.m/.test('Tom')) console.log ('Hi Tom, Tam or Tim');
if (/A|B/.test("A"))  console.log ('A or B');

// ?   - 0 or 1 match
// *   - 0 or more
// +   - 1 or more
// {n}   - exactly n
// {n,}  - n or more
// {0,n} - n or less
// {n,m} - range n to m

if (/ab?c/.test("ac"))       console.log("OK"); // match: "ac", "abc"
if (/ab*c/.test("ac"))       console.log("OK"); // match: "ac", "abc", "abbc", "abbbc" etc.
if (/ab+c/.test("abc"))      console.log("OK"); // match: "abc", "abbc", "abbbc" etc.
if (/ab{3}c/.test("abbbc"))  console.log("OK"); // match: "abbbc"
if (/ab{3,}c/.test("abbbc")) console.log("OK"); // match: "abbbc", "abbbbc", "abbbbbc" etc.
if (/ab{1,3}c/.test("abc"))  console.log("OK"); // match: "abc", "abbc", "abbbc"

// ^  - string starts with
// $  - string ends with

if (/^My/.test("My name is Tom"))   console.log ("Hi!");
if (/Tom$/.test("My name is Tom"))  console.log ("Hi Tom!");

// ( )  - groups characters

if (/water(mark)?/.test("watermark")) console.log("Here is water!"); // match: "water", "watermark",
if (/(Tom)|(John)/.test("John"))      console.log("Hi Tom or John!");

// /g  - global
// /i  - ignore upper/lower case
// /m  - allow matches to span multiple lines

console.log("hi tom!".replace(/Tom/i, "John"));  // == "hi John!"
console.log("ratatam".replace(/ta/, "tu"));      // == "ratutam"
console.log("ratatam".replace(/ta/g, "tu"));     // == "ratutum"

my_array = my_string.split(my_delimiter);
// example
my_array = "dog,cat,cow".split(",");      // my_array==["dog","cat","cow"];

my_array = my_string.match(my_expression);
// example
my_array = "We start at 11:30, 12:15 and 16:45".match(/\d\d:\d\d/g); // my_array==["11:30","12:15","16:45"];

const myRe = /(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})/;
const results = myRe.exec("The date and time are 2009-09-08 09:37:08.");
if (results) {
  console.log("Matched: " + results[0]); // Entire match
  const my_date = results[1]; // First group == "2009-09-08"
  const my_time = results[2]; // Second group == "09:37:08"
  console.log(`It is ${my_time} on ${my_date}`);
} else console.log("Did not find a valid date!");

Function

Every function in JavaScript is an instance of the Function constructor:

// x, y is the argument. 'return x + y' is the function body, which is the last in the argument list.
const add = new Function('x', 'y', 'return x + y');
add(1, 2); // => 3

The add function above may also be defined using a function expression:

const add = function(x, y) {
  return x + y;
};
add(1, 2); // => 3

In ES6, arrow function syntax was added, allowing functions that return a value to be more concise. They also retain the this of the global object instead of inheriting it from where it was called / what it was called on, unlike the function() {} expression.

const add = (x, y) => {return x + y;};
// values can also be implicitly returned (i.e. no return statement is needed)
const addImplicit = (x, y) => x + y;

add(1, 2); // => 3
addImplicit(1, 2) // => 3

For functions that need to be hoisted, there is a separate expression:

function add(x, y) {
  return x + y;
}
add(1, 2); // => 3

Hoisting allows users to use the function before it is "declared":

add(1, 2); // => 3, not a ReferenceError
function add(x, y) {
  return x + y;
}

A function instance has properties and methods.

function subtract(x, y) {
  return x - y;
}

console.log(subtract.length); // => 2, arity of the function (number of arguments)
console.log(subtract.toString());

/*
"function subtract(x, y) {
  return x - y;
}"
*/

Arithmetic

JavaScript supports the following binary arithmetic operators:

JavaScript supports the following unary arithmetic operators:

let x = 1;
console.log(++x); // x becomes 2; displays 2
console.log(x++); // displays 2; x becomes 3
console.log(x);  // x is 3; displays 3
console.log(x--); //  displays 3; x becomes 2
console.log(x);  //  displays 2; x is 2
console.log(--x); //  x becomes 1; displays 1

The modulo operator displays the remainder after division by the modulus. If negative numbers are involved, the returned value depends on the operand.

const x = 17;
console.log(x%5); // displays 2
console.log(x%6); // displays 5
console.log(-x%5); // displays -2
console.log(-x%-5); // displays -2
console.log(x%-5); // displays 2

To always return a non-negative number, users can re-add the modulus and apply the modulo operator again:

const x = 17;
console.log((-x%5+5)%5); // displays 3

Users could also do:

const x = 17;
console.log(Math.abs(-x%5)); // also 3

Assignment

Assignment of primitive types

let x = 9;
x += 1; 
console.log(x); // displays: 10
x *= 30;
console.log(x); // displays: 300
x /= 6;
console.log(x); // displays: 50
x -= 3;
console.log(x); // displays: 47
x %= 7;
console.log(x); // displays: 5

Assignment of object types

/**
 * To learn JavaScript objects...
 */
const object_1 = {a: 1};		// assign reference of newly created object to object_1
let object_2 = {a: 0};
let object_3 = object_2;	    // object_3 references the same object as object_2 does
	 
object_3.a = 2;
message();	        	// displays 1 2 2
	 
object_2 = object_1;		// object_2 now references the same object as object_1
	        	        // object_3 still references what object_2 referenced before
message();		        // displays 1 1 2
	 
object_2.a = 7;  	        // modifies object_1
message();		        // displays 7 7 2

object_3.a = 5;                 // object_3 does not change object_2
message();	                // displays 7 7 5

object_3 = object_2;
object_3.a=4;                  // object_3 changes object_1 and object_2
message();                     // displays 4 4 4

/**
 * Prints the console.log message
 */
function message() {
	console.log(object_1.a + " " + object_2.a + " " + object_3.a);
}

let a, b, c, d, e;
[a, b, c] = [3, 4, 5];
console.log(`${a},${b},${c}`); // displays: 3,4,5
e = {foo: 5, bar: 6, baz: ['Baz', 'Content']};
const arr = [];
({baz: [arr[0], arr[3]], foo: a, bar: b} = e);
console.log(`${a},${b},${arr}`);	// displays: 5,6,Baz,,,Content
[a, b] = [b, a];		// swap contents of a and b
console.log(a + ',' + b);		// displays: 6,5

[a, b, c] = [3, 4, 5]; // permutations
[a, b, c] = [b, c, a];
console.log(`${a},${b},${c}`); // displays: 4,5,3

const a = [1, 2, 3, 4];

// It can be used multiple times in the same expression
const b = [...a, ...a]; // b = [1, 2, 3, 4, 1, 2, 3, 4];

// It can be combined with non-spread items.
const c = [5, 6, ...a, 7, 9]; // c = [5, 6, 1, 2, 3, 4, 7, 9];

// For comparison, doing this without the spread operator 
// creates a nested array.
const d = [a, a]; // d = [[1, 2, 3, 4], [1, 2, 3, 4]]

// It works the same with function calls
function foo(arg1, arg2, arg3) {
    console.log(`${arg1}:${arg2}:${arg3}`);
}

// Users can use it even if it passes more parameters than the function will use
foo(...a); // "1:2:3" → foo(a[0], a[1], a[2], a[3]);

// Users can mix it with non-spread parameters
foo(5, ...a, 6); // "5:1:2" → foo(5, a[0], a[1], a[2], a[3], 6);

// For comparison, doing this without the spread operator
// assigns the array to arg1, and nothing to the other parameters.
foo(a); // "1,2,3,4:undefined:undefined"

const bar = { a: 1, b: 2, c: 3 };

// This would copy the object
const copy = { ...bar }; // copy = { a: 1, b: 2, c: 3 };

// "b" would be overridden here
const override = { ...bar, b: 4 }; // override = { a: 1, c: 3, b: 4 }

function foo(a, b, ...c) {
    console.log(c.length);
}

foo(1, 2, 3, 4, 5); // "3" → c = [3, 4, 5]
foo('a', 'b'); // "0" → c = []

Comparison

Variables referencing objects are equal or identical only if they reference the same object:

const obj1 = {a: 1};
const obj2 = {a: 1};
const obj3 = obj1;
console.log(obj1 == obj2);  //false
console.log(obj3 == obj1);  //true
console.log(obj3 === obj1); //true

See also String.

Logical

JavaScript provides four logical operators:

• unary negation (NOT = !a)
• binary disjunction (OR = a || b) and conjunction (AND = a && b)
• ternary conditional (c ? t : f)

In the context of a logical operation, any expression evaluates to true except the following:

• Strings: "", '',
• Numbers: 0, -0, NaN,
• Special: null, undefined,
• Boolean: false.

The Boolean function can be used to explicitly convert to a primitive of type Boolean:

// Only empty strings return false
console.log(Boolean("")      === false);
console.log(Boolean("false") === true);
console.log(Boolean("0")     === true);

// Only zero and NaN return false
console.log(Boolean(NaN) === false);
console.log(Boolean(0)   === false);
console.log(Boolean(-0)  === false); // equivalent to -1*0
console.log(Boolean(-2)  === true);

// All objects return true
console.log(Boolean(this) === true);
console.log(Boolean({})   === true);
console.log(Boolean([])   === true);

// These types return false
console.log(Boolean(null)      === false);
console.log(Boolean(undefined) === false); // equivalent to Boolean()

The NOT operator evaluates its operand as a Boolean and returns the negation. Using the operator twice in a row, as a double negative, explicitly converts an expression to a primitive of type Boolean:

console.log( !0 === Boolean(!0));
console.log(Boolean(!0) === !!1);
console.log(!!1 === Boolean(1));
console.log(!!0 === Boolean(0));
console.log(Boolean(0) === !1);
console.log(!1 === Boolean(!1));
console.log(!"" === Boolean(!""));
console.log(Boolean(!"") === !!"s");
console.log(!!"s" === Boolean("s"));
console.log(!!"" === Boolean(""));
console.log(Boolean("") === !"s");
console.log(!"s" === Boolean(!"s"));

The ternary operator can also be used for explicit conversion:

console.log([] == false); console.log([] ? true : false); // “truthy”, but the comparison uses [].toString()
console.log([0] == false); console.log([0]? true : false); // [0].toString() == "0"
console.log("0" == false); console.log("0"? true : false); // "0" → 0 ... (0 == 0) ... 0 ← false
console.log([1] == true); console.log([1]? true : false); // [1].toString() == "1"
console.log("1" == true); console.log("1"? true : false); // "1" → 1 ... (1 == 1) ... 1 ← true
console.log([2] != true); console.log([2]? true : false); // [2].toString() == "2"
console.log("2" != true); console.log("2"? true : false); // "2" → 2 ... (2 != 1) ... 1 ← true

Expressions that use features such as post–incrementation (i++) have an anticipated side effect. JavaScript provides short-circuit evaluation of expressions; the right operand is only executed if the left operand does not suffice to determine the value of the expression.

console.log(a || b);  // When a is true, there is no reason to evaluate b.
console.log(a && b);  // When a is false, there is no reason to evaluate b.
console.log(c ? t : f); // When c is true, there is no reason to evaluate f.

In early versions of JavaScript and JScript, the binary logical operators returned a Boolean value (like most C-derived programming languages). However, all contemporary implementations return one of their operands instead:

console.log(a || b); // if a is true, return a, otherwise return b
console.log(a && b); // if a is false, return a, otherwise return b

Programmers who are more familiar with the behavior in C might find this feature surprising, but it allows for a more concise expression of patterns like null coalescing:

const s = t || "(default)"; // assigns t, or the default value, if t is null, empty, etc.

Logical assignment

Bitwise

JavaScript supports the following binary bitwise operators:

Examples:

const x = 11 & 6;
console.log(x); // 2

JavaScript supports the following unary bitwise operator:

Bitwise Assignment

JavaScript supports the following binary assignment operators:

Examples:

let x=7;
console.log(x); // 7
x<<=3;
console.log(x); // 7->14->28->56

String

Examples:

let str = "ab" + "cd";  // "abcd"
str += "e";      // "abcde"

const str2 = "2" + 2;     // "22", not "4" or 4.

??

const a = b ?? 3;

const a = b || 3;

Compound statements

A pair of curly brackets { } and an enclosed sequence of statements constitute a compound statement, which can be used wherever a statement can be used.

If ... else

if (expr) {
  //statements;
} else if (expr2) {
  //statements;
} else {
  //statements;
}

Conditional (ternary) operator

The conditional operator creates an expression that evaluates as one of two expressions depending on a condition. This is similar to the if statement that selects one of two statements to execute depending on a condition. I.e., the conditional operator is to expressions what if is to statements.

const result = condition ? expression : alternative;

is the same as:

if (condition) {
    const result = expression;
} else {
    const result = alternative;
}

Unlike the if statement, the conditional operator cannot omit its "else-branch".

Switch statement

The syntax of the JavaScript switch statement is as follows:

switch (expr) {
  case SOMEVALUE:
    // statements;
    break;
  case ANOTHERVALUE:
    // statements specific to ANOTHERVALUE
    // no break statement, falling through to the following case
  case ORANOTHERONE:
    // statements for when ANOTHERVALUE || ORANOTHERONE
    break; //The buck stops here.
  case YETANOTHER:
    // statements;
    break;
  default:
    // statements;
    break;
 }

• break; is optional; however, it is usually needed, since otherwise code execution will continue to the body of the next case block. This fall through behavior can be used when the same set of statements apply in several cases, effectively creating a disjunction between those cases.
  • Add a break statement to the end of the last case as a precautionary measure, in case additional cases are added later.
• String literal values can also be used for the case values.
• Expressions can be used instead of values.
• The default case (optional) is executed when the expression does not match any other specified cases.
• Braces are required.

For loop

The syntax of the JavaScript for loop is as follows:

 for (initial; condition; loop statement) {
  /*
   statements will be executed every time
   the for{} loop cycles, while the
   condition is satisfied
  */
 }

or

 for (initial; condition; loop statement(iteration)) // one statement

For ... in loop

The syntax of the JavaScript for ... in loop is as follows:

for (var property_name in some_object) {
  // statements using some_object[property_name];
}

• Iterates through all enumerable properties of an object.
• Iterates through all used indices of array including all user-defined properties of array object, if any. Thus it may be better to use a traditional for loop with a numeric index when iterating over arrays.
• There are differences between the various Web browsers with regard to which properties will be reflected with the for...in loop statement. In theory, this is controlled by an internal state property defined by the ECMAscript standard called "DontEnum", but in practice, each browser returns a slightly different set of properties during introspection. It is useful to test for a given property using if (some_object.hasOwnProperty(property_name)) { ... }. Thus, adding a method to the array prototype with Array.prototype.newMethod = function() {...} may cause for ... in loops to loop over the method's name.

While loop

The syntax of the JavaScript while loop is as follows:

while (condition) {
  statement1;
  statement2;
  statement3;
  ...
}

Do ... while loop

The syntax of the JavaScript do ... while loop is as follows:

do {
  statement1;
  statement2;
  statement3;
  ...
} while (condition);

With

The with statement adds all of the given object's properties and methods into the following block's scope, letting them be referenced as if they were local variables.

with (document) {
  const a = getElementById('a');
  const b = getElementById('b');
  const c = getElementById('c');
};

• Note the absence of document. before each getElementById() invocation.

The semantics are similar to the with statement of Pascal.

Because the availability of with statements hinders program performance and is believed to reduce code clarity (since any given variable could actually be a property from an enclosing with), this statement is not allowed in strict mode.

Labels

JavaScript supports nested labels in most implementations. Loops or blocks can be labeled for the break statement, and loops for continue. Although goto is a reserved word,^[19] goto is not implemented in JavaScript.

loop1: for (let a = 0; a < 10; ++a) {
  if (a === 4) break loop1; // Stops after the 4th attempt
  console.log('a = ' + a);
  loop2: for (let b = 0; b < 10; ++b) {
    if (b === 3) continue loop2; // Number 3 is skipped
    if (b === 6) continue loop1; // Continues the first loop, 'finished' is not shown
    console.log('b = ' + b);
  } //end of loop2
  console.log('finished');
} //end of loop1
block1: {
  console.log('Hello'); // Displays 'Hello'
  break block1;
  console.log('World'); // Will never get here
}
goto block1; // Parse error.

Async/await

interface DBResponse {
    id: string;
    rev?: string;
    ok?: boolean;
}

interface Document {
    _id: string;
    _rev?: string;
    [key: string]: any;
}

interface Database {
    post(doc: object): Promise<DBResponse>;
    get(id: string): Promise<Document>;
}

declare const db: Database;

async function createNewDoc(): Promise<Document> {
    const response: DBResponse = await db.post({});
    const doc: Document = await db.get(response.id);
    return doc;
}

async function main(): Promise<void> {
    try {
        const doc: Document = await createNewDoc();
        console.log(doc);
    } catch (err: Error) {
        console.error("Error creating or fetching document:", err);
    }
}

main();