The length property sets or returns the number of elements in an array.

Return the length of an array:

array.length

const fruits = ["Banana", "Orange", "Apple", "Mango"];

let length = fruits.length;

Output: 4

Set the length of an array:

array.length = number

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.length = 2;

Output: Banana,Orange

The concat() method concatenates (joins) two or more arrays.

The concat() method returns a new array, containing the joined arrays.

The concat() method does not change the existing arrays.

Syntax

array1.concat(array2, array3, ..., arrayX)

Example

const arr1 = ["Cecilie", "Lone"];

const arr2 = ["Emil", "Tobias", "Linus"];

const arr3 = ["Robin"];

const children = arr1.concat(arr2,arr3);

Output: Cecilie, Lone, Emil, Tobias, Linus, Robin

The copyWithin() method copies array elements to another position in the array.

The copyWithin() method overwrites the existing values.

The copyWithin() method does not add items to the array.

Syntax

array.copyWithin(target, start, end)

Example

const fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi"];

fruits.copyWithin(2, 0, 2);

Output: Banana,Orange,Banana,Orange,Kiwi

The entries() method returns an Array Iterator object with key/value pairs:

The entries() method does not change the original array.

Syntax

array.entries()

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

const f = fruits.entries();

Output: 0,Banana;1,Orange;2,Apple;3,Mango

The every() method executes a function for each array element.

The every() method returns true if the function returns true for all elements.

The every() method returns false if the function returns false for one element.

The every() method does not execute the function for empty elements.

The every() method does not change the original array

Syntax

array.every(function(currentValue, index, arr), thisValue)

Example

const ages = [32, 33, 16, 40];

ages.every(checkAge)

function checkAge(age) {

return age > 18;

}

Output: false

The some() method checks if any array elements pass a test (provided as a function).

The some() method executes the function once for each array element:

• If the function returns true, some() returns true and stops.

• If the function returns false, some() runs the next function.

The some() method does not execute the function for empty array elements.

The some() method does not change the original array.

Syntax

array.some(function(value, index, arr), this)

Example

const ages = [3, 10, 18, 20];

ages.some(checkAdult);

function checkAdult(age) {

return age > 18;

}

Output: true

The fill() method fills specified elements in an array with a value.

The fill() method overwrites the original array.

Start and end position can be specified. If not, all elements will be filled.

Syntax

array.fill(value, start, end)

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.fill("Kiwi", 2, 4);

Output: Banana,Orange,Kiwi,Kiwi

The filter() method creates a new array filled with elements that pass a test provided by a function.

The filter() method does not execute the function for empty elements.

The filter() method does not change the original array.

Syntax

array.filter(function(currentValue, index, arr), thisValue)

Example

const ages = [32, 33, 16, 40];

const result = ages.filter(checkAdult);

function checkAdult(age) {

return age >= 18;

}

Output: 32,33,40

The find() method returns the value of the first element that passes a test.

The find() method executes a function for each array element.

The find() method returns undefined if no elements are found.

The find() method does not execute the function for empty elements.

The find() method does not change the original array.

Syntax

array.find(function(currentValue, index, arr),thisValue)

Example

const ages = [3, 10, 18, 20];

const result = ages.find(checkAge);

function checkAge(age) {

return age > 18;

}

Output: 20

The findIndex() method executes a function for each array element.

The findIndex() method returns the index (position) of the first element that passes a test.

The findIndex() method returns -1 if no match is found.

The findIndex() method does not execute the function for empty array elements.

The findIndex() method does not change the original array.

Syntax

array.findIndex(function(currentValue, index, arr), thisValue)

Example

const ages = [3, 10, 18, 20];

const result = ages.find(checkAge);

function checkAge(age) {

return age > 18;

}

Output: 3

The forEach() method calls a function for each element in an array.

The forEach() method is not executed for empty elements.

Syntax

array.forEach(function(currentValue, index, arr), thisValue)

Example

const fruits = ["apple", "orange", "cherry"];

fruits.forEach(myFunction);

Output: result of each array element

map() creates a new array from calling a function for every array element.

map() calls a function once for each element in an array.

map() does not execute the function for empty elements.

map() does not change the original array.

Syntax

array.map(function(currentValue, index, arr), thisValue)

Example

const numbers = [65, 44, 12, 4];

const newArr = numbers.map(myFunction)

function myFunction(num) {

return num * 10;

}

Output: 650,440,120,40

The Array.from() method returns an array from any object with a length property.

The Array.from() method returns an array from any iterable object.

Note: Array.from() is a static property of the JavaScript Array object. You can only use it as Array.from(). Using x.from(), where x is an array will return undefined.

Syntax

Array.from(object, mapFunction, thisValue)

Example

Array.from("ABCDEFG")

Output: A,B,C,D,E,F,G

The includes() method returns true if an array contains a specified value.

The includes() method returns false if the value is not found.

The includes() method is case sensitive.

Syntax

array.includes(element, start)

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.includes("Banana", 3);

Output: false

The indexOf() method returns the first index (position) of a specified value.

The indexOf() method returns -1 if the value is not found.

The indexOf() method starts at a specified index and searches from left to right.

By default the search starts at the first element and ends at the last.

Negative start values counts from the last element (but still searches from right to left).

Syntax

array.indexOf(item, start)

Example

const fruits = ["Banana", "Orange", "Apple", "Mango", "Apple"];

let index = fruits.indexOf("Apple", 3);

Output: 4

The lastIndexOf() method returns the last index (position) of a specified value.

The lastIndexOf() method returns -1 if the value is not found.

The lastIndexOf() starts at a specified index and searches from right to left.

By defalt the search starts at the last element and ends at the first.

Negative start values counts from the last element (but still searches from right to left).

Syntax

array.lastIndexOf(item, start)

Example

const fruits = ["Orange", "Apple", "Mango", "Apple", "Banana", "Apple"];

let index = fruits.lastIndexOf("Apple");

Output: 5

The isArray() method returns true if an object is an array, otherwise false.

Note: Array.isArray() is a static property of the JavaScript Array object. You can only use it as Array.isArray(). Using x.isArray(), where x is an array will return undefined.

Syntax

Array.isArray(obj)

Example

let text = "W3Schools";

let result = Array.isArray(text);

Output: false

The join() method returns an array as a string.

The join() method does not change the original array.

Any separator can be specified. The default is comma (,).

Syntax

array.join(separator)

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

let text = fruits.join(" and ");

Output: Banana and Orange and Apple and Mango

The keys() method returns an Array Iterator object with the keys of an array.

The keys() method does not change the original array.

Syntax

array.keys()

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

const keys = Object.keys(fruits);

Output: 0,1,2,3

The shift() method removes the first item of an array.

The shift() method changes the original array.

The shift() method returns the shifted element.

Syntax

array.shift()

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.shift();

Output: Banana, fruits = ["Orange", "Apple", "Mango"]

The unshift() method adds new elements to the beginning of an array.

The unshift() method overwrites the original array.

Syntax

array.unshift(item1, item2, ..., itemX)

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.unshift("Lemon","Pineapple");

Output: Lemon,Pineapple,Banana,Orange,Apple,Mango

The pop() method removes (pops) the last element of an array.

The pop() method changes the original array.

The pop() method returns the removed element.

Syntax

array.pop()

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.pop();

Output: Mango; fruits = ["Banana", "Orange", "Apple"];

The push() method adds new items to the end of an array.

The push() method changes the length of the array.

The push() method returns the new length.

Syntax

array.push(item1, item2, ..., itemX)

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.push("Kiwi", "Lemon");

Output: Banana,Orange,Apple,Mango,Kiwi,Lemon

The reduce() method executes a reducer function for array element.

The reduce() method returns a single value: the function's accumulated result.

The reduce() method does not execute the function for empty array elements.

The reduce() method does not change the original array.

Syntax

array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

Example

const numbers = [15.5, 2.3, 1.1, 4.7];

document.getElementById("demo").innerHTML = numbers.reduce(getSum, 0);

function getSum(total, num) {

return total + num;

}

Output: 23.6

The reduceRight() method executes a reducer function for each array element.

The reduceRight() method works from right to left.

The reduceRight() method returns a single value: the function's accumulated result.

The reduceRight() method does not execute the function for empty elements.

Syntax

array.reduceRight(function(total, currentValue, currentIndex, arr), initialValue)

Example

const numbers = [2, 45, 30, 100];

document.getElementById("demo").innerHTML = numbers.reduceRight(getSum);

function getSum(total, num) {

return total - num;

}

Output: 23

The sort() sorts the elements of an array.

The sort() overwrites the original array.

The sort() sorts the elements as strings in alphabetical and ascending order.

Note: Sorting alphabetically works well for strings ("Apple" comes before "Banana"). But, sorting numbers can produce incorrect results. "25" is bigger than "100", because "2" is bigger than "1". You can fix this by providing a "compare function" (See examples below).

Syntax

array.sort(compareFunction)

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.sort();

Output: Apple,Banana,Mango,Orange

The reverse() method reverses the order of the elements in an array.

The reverse() method overwrites the original array.

Syntax

array.reverse()

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.reverse();

Output: Mango,Apple,Orange,Banana

The slice() method returns selected elements in an array, as a new array.

The slice() method selects from a given start, up to a (not inclusive) given end.

The slice() method does not change the original array.

Syntax

array.slice(start, end)

Example

const fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];

const citrus = fruits.slice(1, 3);

Output: Orange,Lemon

The splice() method adds and/or removes array elements.

The splice() method overwrites the original array.

Syntax

array.splice(index, howmany, item1, ....., itemX)

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.splice(2, 1, "Lemon", "Kiwi");

Output: Banana,Orange,Lemon,Kiwi,Mango

The length property returns the length of a string.

The length property of an empty string is 0.

Syntax

string.length

Example

let text = "Hello World!";

let length = text.length;

Output: 12

The charAt() method returns the character at a specified index (position) in a string.

The index of the first character is 0, the second 1, ...

The index of the last character is string length - 1 (See Examples below).

Syntax

string.charAt(index)

Example

let text = "HELLO WORLD";

let letter = text.charAt(1);

Output: E

The charCodeAt() method returns the Unicode of the character at a specified index (position) in a string.

Syntax

string.charCodeAt(index)

Example

let text = "HELLO WORLD";

let code = text.charCodeAt(1);

Output: 69

The concat() method joins two or more strings.

The concat() method does not change the existing strings.

The concat() method returns a new string.

Syntax

string.concat(string1, string2, ..., stringX)

Example

let text1 = "Hello";

let text2 = "world!";

let result = text1.concat(" ", text2);

Output: Hello world!

The startsWith() method returns true if a string starts with a specified string.

Otherwise it returns false.

The startsWith() method is case sensitive.

Syntax

string.startsWith(searchValue, start)

Example

let text = "Hello world, welcome to the universe.";

text.startsWith("world", 6);

Output: true

The endsWith() method returns true if a string ends with a specified string.

Otherwise it returns false.

The endsWith() method is case sensitive.

Syntax

string.endsWith(searchvalue, length)

Example

let text = "Hello world, welcome to the universe.";

text.endsWith("world", 11);

Output: true

The String.fromCharCode() method converts Unicode values to characters.

The String.fromCharCode() is a static method of the String object.

The syntax is always String.fromCharCode().

You cannot use myString.fromCharCode().

Syntax

String.fromCharCode(n1, n2, ..., nX)

Example

let text = String.fromCharCode(72, 69, 76, 76, 79);

Output: Hello

The includes() method returns true if a string contains a specified string.

Otherwise it returns false.

The includes() method is case sensitive.

Syntax

string.includes(searchvalue, start)

Example

let text = "Hello world, welcome to the universe.";

let result = text.includes("world");

Output: true

let text = "Hello World, welcome to the universe.";

let result = text.includes("world", 12);

Output: false

The indexOf() method returns the position of the first occurrence of a value in a string.

The indexOf() method returns -1 if the value is not found.

The indexOf() method is case sensitive

Syntax

string.indexOf(searchvalue, start)

Example

let text = "Hello world, welcome to the universe.";

text.indexOf("e", 5);

Output: 14

The lastIndexOf() method returns the index (position) of the last occurrence of a specified value in a string.

The lastIndexOf() method searches the string from the end to the beginning.

The lastIndexOf() method returns the index from the beginning (position 0).

Syntax

string.lastIndexOf(searchvalue, start)

Example

let text = "Hello planet earth, you are a great planet.";

let result = text.lastIndexOf("planet", 20);

Output: 6

The localeCompare() method compares two strings in the current locale.

The localeCompare() method returns sort order -1, 1, or 0 (for before, after, or equal).

The current locale is based on the language settings of the browser.

Syntax

string.localeCompare(compareString)

Example

let text1 = "cd";

let text2 = "ab";

let result = text1.localeCompare(text2);

Output: 1

The match() method matches a string against a regular expression **

The match() method returns an array with the matches.

The match() method returns null if no match is found.

Syntax

string.match(match)

A seach for "ain" using a string:

let text = "The rain in SPAIN stays mainly in the plain";

text.match("ain");

Output: ain

A seach for "ain" using a regular expression:

let text = "The rain in SPAIN stays mainly in the plain";

text.match(/ain/);

Output: ain

A global seach for "ain":

let text = "The rain in SPAIN stays mainly in the plain";

text.match(/ain/g);

Output: ain,ain,ain

The repeat() method returns a string with a number of copies of a string.

The repeat() method returns a new string.

The repeat() method does not change the original string.

Syntax

string.repeat(count)

Example

let text = "Hello world!";

let result = text.repeat(2);

Output: Hello world!Hello world!

The replace() method searches a string for a value or a regular expression.

The replace() method returns a new string with the value(s) replaced.

The replace() method does not change the original string.

Syntax

string.replace(searchValue, newValue)

Example

let text = "Visit Microsoft!";

let result = text.replace("Microsoft", "W3Schools");

Output: Visit W3Schools!

A global replacement:

let text = "Mr Blue has a blue house and a blue car";

let result = text.replace(/blue/g, "red");

Output: Mr Blue has a red house and a red car.

The search() method matches a string against a regular expression **

The search() method returns the index (position) of the first match.

Syntax

string.search(searchValue)

Example

let text = "Mr. Blue has a blue house";

let position = text.search("Blue");

Output: 4

The slice() method extracts a part of a string.

The slice() method returns the extracted part in a new string.

The slice() method does not change the original string.

The start and end parameters specifies the part of the string to extract.

The first position is 0, the second is 1, ...

A negative number selects from the end of the string.

Syntax

string.slice(start, end)

Example

let text = "Hello world!";

let result = text.slice(0, 5);

Output: Hello

The split() method splits a string into an array of substrings.

The split() method returns the new array.

The split() method does not change the original string.

If (" ") is used as separator, the string is split between words.

Syntax

string.split(separator, limit)

Example

let text = "How are you doing today?";

const myArray = text.split(" ");

Output: How,are,you,doing,today?

Split the words, and return the second word:

let text = "How are you doing today?";

const myArray = text.split(" ");

let word = myArray[1];

Output: are

Split the characters, including spaces:

const myArray = text.split("");

Output: H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?

Use the limit parameter:

const myArray = text.split(" ", 3);

Output: How,are,you

The substr() method extracts a part of a string.

The substr() method begins at a specified position, and returns a specified number of characters.

The substr() method does not change the original string.

Syntax

string.substr(start, length)

Example

let text = "Hello world!";

let result = text.substr(1, 4);

Output: ello

The substring() method extracts characters, between two indices (positions), from a string, and returns the substring.

The substring() method extracts characters from start to end (exclusive).

The substring() method does not change the original string.

If start is greater than end, arguments are swapped: (4, 1) = (1, 4).

Syntax

string.substring(start, end)

Example

let text = "Hello world!";

let result = text.substring(1, 4);

Output: ell

The toLowerCase() method converts a string to lowercase letters.

The toLowerCase() method does not change the original string.

Syntax

string.toLowerCase()

Example

let text = "Hello World!";

let result = text.toLowerCase();

Output: hello world!

The toUpperCase() method converts a string to uppercase letters.

The toUpperCase() method does not change the original string.

Syntax

string.toUpperCase()

Example

let text = "Hello World!";

let result = text.toUpperCase();

Output: HELLO WORLD!

The trim() method removes whitespace from both sides of a string.

The trim() method does not change the original string.

Syntax

string.trim()

Example

let text = "    Hello World!    ";

let result = text.trim();

Output: Hello World!

Returns the largest number possible in JavaScript

Number.MAX_VALUE returns the largest number possible in JavaScript.

Number.MAX_VALUE has the value of 1.7976931348623157e+308.

Numbers larger than MAX_VALUE are represented as Infinity.

Note: MAX_VALUE is a property of the JavaScript Number object. You can only use it as Number.MAX_VALUE. Using x.MAX_VALUE, where x is a variable, will return undefined.

Syntax

Number.MAX_VALUE

Example

let x = Number.MAX_VALUE;

Output: 1.7976931348623157e+308

Returns the smallest number possible in JavaScript

Number.MIN_VALUE returns the smallest number possible in JavaScript.

Number.MIN_VALUE has a value of 5e-324.

Note: MIN_VALUE is the value closest to 0. Numbers smaller than this are converted to 0. The most negative number is the negative MAX_NUMBER.

Note: MIN_VALUE is a property of the JavaScript Number object. You can only use it as Number.MIN_VALUE. Using x.MIN_VALUE, where x is a variable, will return undefined.

Syntax

Number.MIN_VALUE

Example

let x = Number.MIN_VALUE;

Output: 5e-324

POSITIVE_INFINITY returns positive infinity.

POSITIVE_INFINITY is "something higher than any other number".

You can only use it as Number.POSITIVE_INFINITY.

Syntax

Number.POSITIVE_INFINITY

Example

let x = Number.POSITIVE_INFINITY;

Output: Infinity

Number.NEGATIVE_INFINITY returns negative infinity.

Number.NEGATIVE_INFINITY is "a number lower than any other number".

You can only use it as Number.NEGATIVE_INFINITY.

Syntax

Number.NEGATIVE_INFINITY

Example

let x = 100;

x.NEGATIVE_INFINITY;

Output: -Infinity

In JavaScript, NaN is short for "Not-a-Number".

In JavaScript, NaN is a number that is not a legal number.

The Global NaN property is the same as the Number.Nan property.

Syntax

Number.NaN

Example

let x = Number.NaN;

let x = NaN;

Output: NaN; Nan

The Number.isFinite() method returns true if a number is a finite number.

Infinite (not finite) numbers are Infinity, -Infinity, or NaN

Otherwise it returns false.

Syntax

Number.isFinite(value)

Example

Number.isFinite(123)

Output: true

Number.isFinite("123")

Output: false

The Number.isInteger() method returns true if a value is an integer of the datatype Number.

Otherwise it returns false.

Syntax

Number.isInteger(value)

Example

Number.isInteger(5-2);

Output: true

Number.isInteger(5/2);

Output: false

In JavaScript, NaN is short for "Not-a-Number".

In JavaScript, NaN is a number that is not a legal number.

The Number.isNaN() method returns true if the value is NaN, and the type is a Number.

Syntax

Number.isNaN(value)

Example

Number.isNaN(123);

Output: false

Number.isNaN(-1.23);

Output: false

Number.isNaN('123');

Output: false

Number.isNaN(0/0);

Output: false

The Number.isSafeInteger() method returns trueif a number is a safe integer.

Otherwise it returns false.

A safe integer is an integer that can be exactly represented as an IEEE-754 double precision number: all integers from (253 - 1) to -(253 - 1).

Syntax

Number.isSafeInteger(value)

Example

Number.isSafeInteger(5e100);

Output: false

Number.isSafeInteger(-123);

Output: true

Number.isSafeInteger('123');

Output: false

The toExponential() method converts a number into an exponential notation.

Syntax

number.toExponential(x)

Example

let num = 5.56789;

let n = num.toExponential();

Output: 5.56789e+0

let num = 5.56789;

let n = num.toExponential(3);

Output: 5.568e+0

The toFixed() method converts a number to a string.

The toFixed() method rounds the string to a specified number of decimals.

Syntax

number.toFixed(x)

Example

let num = 5.56789;

let n = num.toFixed();

Output: 6

let num = 5.56789;

let n = num.toFixed(2);

Output: 5.57

The toLocaleString() returns a number as a string, using local language format.

The language format depends on the locale setup on your computer.

Syntax

number.toLocaleString(locales, options)

Example

let num = 1000000;

let text = num.toLocaleString();

Output: 1,000,000

Format a number into a string, using the locale specific of FINLAND:

let num = 1000000;

let text = num.toLocaleString("fi-FI");

Output: 1 000 000

Format a number into a currency string, using the locale specific of USA:

let num = 1000000;

let text = num.toLocaleString("en-US", {style:"currency", currency:"USD"});

Output: $1,000,000.00

The toPrecision() method formats a number to a specified length.

A decimal point and nulls are added (if needed), to create the specified length.

Syntax

number.toPrecision(x)

Example

let num = 0.001658853;

num.toPrecision(2);

num.toPrecision(3);

num.toPrecision(10);

Output: 0.0017; 0.00166; 0.001658853000

A numeric value that represents positive/negative infinity

"Not-a-Number" value

Indicates that a variable has not been assigned a value

The constructor property returns the function that created the Object prototype.

function Object() { [native code] }

prototype allows you to add new properties and methods to objects.

Syntax

object.prototype.name = value

Example 1

Array.prototype.myUcase = function() {

for (let i = 0; i < this.length; i++) {

this[i] = this[i].toUpperCase();

}

};

var fruits = ["Banana", "Orange", "Apple", "Mango"];

fruits.myUcase();

Output: BANANA,ORANGE,APPLE,MANGO

Example 2

function Person(first, last, age, eyecolor) {

this.firstName = first;

this.lastName = last;

this.eyeColor = eyecolor;

}

const.myFather = new Person("John", "Doe", "Blue", );

Person.prototype.nationality = "English";

Output: myFather.nationality = "English";

The encodeURI() method encodes a URI.

The encodeURI() method does not encode characters like: , / ? : @ & = + $ * #

let uri = "my test.asp?name=ståle&car=saab";

let encoded = encodeURI(uri);

Encoded URI: my%20test.asp?name=st%C3%A5le&car=saab

The decodeURI() method decodes a URI.

let uri = "my test.asp?name=ståle&car=saab";

let decoded = decodeURI(encoded);

Decoded URI:

The encodeURIComponent() method encodes a URI component.

The encodeURIComponent() method encodes special characters including: , / ? : @ & = + $ #

let uri = "https://w3schools.com/my test.asp?name=ståle&car=saab";

let encoded = encodeURIComponent(uri);

Encoded URI: https%3A%2F%2Fw3schools.com%2Fmy%20test.asp%3Fname%3Dst%C3%A5le%26car%3Dsaab

The decodeURIComponent() method decodes a URI component.

let uri = "https://w3schools.com/my test.asp?name=ståle&car=saab";

let decoded = decodeURIComponent(encoded);

Decoded URI: https://w3schools.com/my test.asp?name=ståle&car=saab

The Number.isFinite() method returns true if a number is a finite number.

Infinite (not finite) numbers are Infinity, -Infinity, or NaN

Otherwise it returns false.

Syntax

Number.isFinite(value)

Example

Number.isFinite(123)

Output: true

Number.isFinite("123")

Output: false

In JavaScript, NaN is short for "Not-a-Number".

In JavaScript, NaN is a number that is not a legal number.

The Number.isNaN() method returns true if the value is NaN, and the type is a Number.

Syntax

Number.isNaN(value)

Example

Number.isNaN(123);

Output: false

Number.isNaN(-1.23);

Output: false

Number.isNaN('123');

Output: false

Number.isNaN(0/0);

Output: false

The Number() method converts a value to a number.

If the value cannot be converted, NaN is returned.

Number(true);

Number(false);

Number(new Date());

Output: 1; 0; 1649293650949

The parseFloat() method parses a value as a string and returns the first number.

Note: If the first character cannot be converted, NaN is returned. Leading and trailing spaces are ignored. Only the first number found is returned.

parseFloat(10);

parseFloat("10");

parseFloat("10.33");

parseFloat("34 45 66");

parseFloat("He was 40");

Output: 10;10;10.33;34;NaN

The parseInt method parses a value as a string and returns the first integer.

A radix parameter specifies the number system to use:

2 = binary, 8 = octal, 10 = decimal, 16 = hexadecimal.

If radix is omitted, JavaScript assumes radix 10. If the value begins with "0x", JavaScript assumes radix 16.

Syntax

parseInt(string, radix)

Example

parseInt("10");

parseInt("10.00");

parseInt("10.33");

parseInt("34 45 66");

parseInt(" 60 ");

parseInt("40 years");

parseInt("He was 40");

Output: 10;10;10;34;60;40;NaN

The String() method converts a value to a string.

Note: The String() method returns the same as the toString() method for any value.

String(new Date());

String("12345");

String(12345);

Output: Wed Apr 06 2022 21:11:55 GMT-0400 (EDT);12345;12345

The toString() method returns a string verion of an object

The toString() method does not change the original object.

Syntax

array.toString()

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

let text = fruits.toString();

Output: Banana,Orange,Apple,Mango

The valueOf() method returns the object itself.

The valueOf() method does not change the original object.

fruits.valueOf() returns the same as fruits.

Syntax

array.valueOf()

Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];

const myArray = fruits.valueOf();

Output: Banana,Orange,Apple,Mango; same as const myArray = fruits;

Perform a global match (find all matches rather than stopping after the first match)

let pattern = /[1-4]/g;

Perform case-insensitive matching

let pattern = /w3schools/i;

Perform multiline matching

Brackets [abc] specifies matches for the characters inside the brackets.

Brackets can define single characters, groups, or character spans:

let text = "Do you know if this is all there is?";

let pattern = /[is]/gi;

Output: i,i,s,i,s,i,s

Brackets [^abc] specifies matches for any character NOT between the brackets.

Brackets can define single characters, groups, or character spans:

let pattern = /[^h]/g;

The [0-9] expression is used to find any character between the brackets.

The digits inside the brackets can be any numbers or span of numbers from 0 to 9.

let text = "123456789";

let pattern = /[1-4]/g;

Output: 1,2,3,4

Find any character NOT between the brackets (any non-digit)

let text = "123456789";

let pattern = /[^1-4]/g;

Output: 5,6,7,8,9

The (x|y) expression is used to find any of the alternatives specified.

The alternatives can be of any characters.

let pattern= /(red|green)/g;

let pattern = /(0|5|7)/g;

Find a single character, except newline or line terminator

let text = "That's hot!";

let pattern = /./g;

Output: T,h,a,t,',s, ,h,o,t,!

let text = "That's hot!";

let pattern = /h.t/g;

Output: hat,hot

The \w metacharacter matches word characters.

A word character is a character a-z, A-Z, 0-9, including _ (underscore).

let text = "Give 100%!";

let pattern = /\w/g;

Output: G,i,v,e,1,0,0

The \W metacharacter matches non-word characters:

let text = "Give 100%!";

let pattern = /\W/g;

Output: ,%,!

The \d metacharacter matches digits from 0 to 9.

let text = "Give 100%!";

let pattern= /\d/g;

Output: 1,0,0

The \D metacharacter matches non-digit characters.

let text = "Give 100%!";

let pattern = /\D/g;

Output: G,i,v,e, ,%,!

The \s metacharacter matches whitespace character.

Whitespace characters can be:

• A space character

• A tab character

• A carriage return character

• A new line character

• A vertical tab character

• A form feed character

let text = "Is this all there is?";

let pattern = /\s/g;

Output: , , ,

The \S metacharacter matches non-whitespace characters.

let text = "Is this all there is?";

let pattern = /\S/g;

Output: I,s,t,h,i,s,a,l,l,t,h,e,r,e,i,s,?

The \b metacharacter matches at the beginning or end of a word.

Search for the pattern LO at the beginning of a word like this: \bLO

Search for the pattern LO at the end of a word like this: LO\b

let text = "HELLO, LOOK AT YOU";

let pattern = /\bLO/;

Output: 7

let text = "HELLO, LOOK AT YOU";

let pattern = /LO\b/;

Output: 3

The \B metacharacter matches NOT at the beginning/end of a word.

let text = "HELLO, LOOK AT YOU";

let pattern = /\BLO/;

Output: 3

let text = "HELLO, LOOK AT YOU";

let pattern = /LO\B/;

Output: 7

The \0 metacharacter maches NUL characters (\0).

let text = "Visit W3Schools.\0Learn Javascript.";

let pattern = /\0/;

Output: 16

The \n character matches newline characters (\n).

let text = "Visit W3Schools.\nLearn Javascript.";

let pattern = /\n/;

Output: 16

Find a form feed character

Find a carriage return character

Find a tab character

Find a vertical tab character

The \xxx metacharacters matches the Latin character by an octal number (xxx).

let text = "Visit W3Schools. Hello World!";

let pattern = /\127/g;

Output: W,W; octn(127)=W

The \xdd metacharacters matches Latin characters specified by a hexadecimal number (dd).

let text = "Visit W3Schools. Hello World!";

let pattern = /\x57/g;

Output: W,W; hex(57)=W

The \ udddd metacharacters matches Unicode characters specified by a hexadecimal number (dddd).

let text = "Visit W3Schools. Hello World!";

let pattern = /\u0057/g;

Output: W,W; Uni(u0057)=W

The n+ quantifier matches any string that contains at least one n.

let text = "Hellooo World! Hello W3Schools!";

let pattern = /o+/g;

Output: ooo,o,o,oo

The n* quantifier matches any string that contains zero or more occurrences of n.

let text = "Hellooo World! Hello W3Schools!";

let pattern = /lo*/g;

Output: l,looo,l,l,lo,l

The n? quantifier matches any string that contains zero or one occurrences of n.

let text = "1, 100 or 1000?";

let pattern = /10?/g;

Output: 1,10,10

The n{X} quantifier matches any string that contains a sequence of X n's. X must be a number.

let text = "100, 1000 or 10000?";

let pattern = /d{4}/g;

Output: 1000,1000

The n{X,Y} quantifier matches any string that contains a sequence of X to Y n's.

let text = "100, 1000 or 10000?";

let pattern = /d{3,4}/g;

Output: 100,1000,1000

The n{X,} quantifier matches any string that contains a sequence of at least X n's.

let text = "100, 1000 or 10000?";

let pattern = /\d{3,}/g;

Output: 100,1000,10000

The n$ quantifier matches any string with n at the end of it.

let text = "Is this his";

let pattern = /is$/;

Output: is

The ^n quantifier matches any string with n at the beginning of it.

let text = "Is this his";

let pattern = /^Is/g;

Output: Is

The ?=n quantifier matches any string that is followed by a specific string n.

let text = "Is this all there is";

let pattern = /is(?= all)/g;

Output: is

The ?!n quantifier matches any string that is not followed by a specific string n.

let text = "Is this all there is";

let pattern = /is(?! all)/gi;

Output: Is,is

The global property specifies whether or not the "g" modifier is set.

This property returns true if the "g" modifier is set, otherwise it returns false.

The ignoreCase property specifies whether or not the "i" modifier is set.

This property returns true if the "i" modifier is set, otherwise it returns false.

The lastIndex property specifies the index at which to start the next match.

Note: This property only works if the "g" modifier is set.

This property returns an integer that specifies the character position immediately after the last match found by exec( ) or test( ) methods.

let text = "The rain in Spain stays mainly in the plain";

let pattern = /ain/g;

let result = "";

while (pattern.test(text)==true) {pattern.lastIndex}

Output: 8,17,28,43

The multiline property specifies whether or not the m modifier is set.

This property returns true if the "m" modifier is set, otherwise it returns false.

The source property returns the text of the RegExp pattern.

let text = "Visit W3Schools";

let pattern = /W3S/g;

let result = pattern.source;

Output: W3S

The exec() method tests for a match in a string.

If it finds a match, it returns a result array, otherwise it returns null.

let text = "The best things in life are free";

let result = /e/.exec(text);

Output: e

The test() method tests for a match in a string.

If it finds a match, it returns true, otherwise it returns false.

let text = "The best things in life are free"; let pattern = /e/;

let result = pattern.test(text);

Output: true

The constructor() method is a special method for creating and initializing objects created within a class.

The constructor() method is called automatically when a class is initiated, and it has to have the exact name "constructor", in fact, if you do not have a constructor method, JavaScript will add an invisible and empty constructor method.

Note: A class cannot have more than one constructor() method. This will throw a SyntaxError.

You can use the super() method to call the constructor of a parent class (see "More Examples" below).

class Car {

constructor(brand) { // Constructor

this.carname = brand;

}

}

mycar = new Car("Ford");

The extends keyword is used to create a child class of another class (parent).

The child class inherits all the methods from another class.

Inheritance is useful for code reusability: reuse properties and methods of an existing class when you create a new class.

Note: From the example above; The super() method refers to the parent class. By calling the super() method in the constructor method, we call the parent's constructor method and gets access to the parent's properties and methods.

Syntax

class childClass extends parentClass

Example

class Car {

constructor(brand) {

this.carname = brand;

}

present() {

return 'I have a ' + this.carname;

}

}

class Model extends Car {

constructor(brand, mod) {

super(brand);

this.model = mod;

}

show() {

return this.present() + ', it is a ' + this.model;

}

}

mycar = new Model("Ford", "Mustang");

document.getElementById("demo").innerHTML = mycar.show();

The static keyword defines static methods for classes.

Static methods are called directly on the class (Car from the example above) - without creating an instance/object (mycar) of the class.

class Car {

constructor(brand) {

this.carname = brand;

}

static hello() { // static method

return "Hello!!";

}

}

mycar = new Car("Ford");

//Call 'hello()' on the class Car:

document.getElementById("demo").innerHTML = Car.hello();

//and NOT on the 'mycar' object:

//document.getElementById("demo").innerHTML = mycar.hello();

//this would raise an error.

The super keyword is used to call the constructor of its parent class to access the parent's properties and methods.

Syntax

super(arguments); // calls the parent constructor (only inside the constructor)

super.parentMethod(arguments); // calls a parent method

Example

Create a class named "Model" which will inherit the methods from the "Car" class, by using the extends keyword.

By calling the super() method in the constructor method, we call the parent's constructor method and gets access to the parent's properties and methods:

class Car {

constructor(brand) {

this.carname = brand;

}

present() {

return 'I have a ' + this.carname;

}

}

class Model extends Car {

constructor(brand, mod) {

super(brand);

this.model = mod;

}

show() {

return this.present() + ', it is a ' + this.model;

}

}

mycar = new Model("Ford", "Mustang");

document.getElementById("demo").innerHTML = mycar.show();

A private field is an identifier prefixed with # (the hash symbol). The hash is an integral part of the field's name, which means a private property can never have name clash with a public property. In order to refer to a private field anywhere in the class, you must declare it in the class body (you can't create a private property on the fly). Apart from this, a private field is pretty much equivalent to a normal property.

class Color {

// Declare: every Color instance has a private field called #values.

#values;

constructor(r, g, b) {

this.#values = [r, g, b];

}

getRed() {

return this.#values[0];

}

setRed(value) {

this.#values[0] = value;

}

}

const red = new Color(255, 0, 0);

console.log(red.getRed()); // 255

The name property sets or returns the name of an error.

Six different values can be returned by the error name property:

Syntax

errorObj.name

Example

try {

adddlert("Welcome guest!");

}

catch(err) {

document.getElementById("demo").innerHTML = err.name;

}

The message property sets or returns an error message.

Syntax

errorObj.message

Example

try {

adddlert("Welcome guest!");

}

catch(err) {

document.getElementById("demo").innerHTML = err.message;

}

The var statement declares a variable.

Variables are containers for storing information.

Creating a variable in JavaScript is called "declaring" a variable:

var carName;

The let statement declares a variable.

Variables are containers for storing information.

Creating a variable in JavaScript is called "declaring" a variable:

let carName;

After the declaration, the variable is empty (it has no value).

To assign a value to the variable, use the equal sign:

carName = "Volvo";

You can also assign a value to the variable when you declare it:

let carName = "Volvo";

The const statement declares a variable.

Variables are containers for storing information.

Creating a variable in JavaScript is called "declaring" a variable:

Note: A const variable must be assigned when it is declared. As a general rule, always declare a variable with const unless you know that the value will change.

Use const when you declare:

• A new Array

• A new Object

• A new Function

• A new RegExp

const name = "Volvo";

// Create an object:

const car = {type:"Fiat", model:"500", color:"white"};

// Change a property:

car.color = "red";

// Add a property:

car.owner = "Johnson";

The function statement declares a function.

A declared function is "saved for later use", and will be executed later, when it is invoked (called).

In JavaScript, functions are objects, and they have both properties and methods.

A function can also be defined using an expression

Syntax

function functionName(parameters) {

code to be executed

}

Example

// Declare a function

function myFunction() {

document.getElementById("demo").innerHTML = "Hello World!";

}

// Call the function

myFunction();

// Calling a function without delaration

argument) => {Code w/argument}

(argument) => function(argument

The return statement stops the execution of a function and returns a value.

Syntax

return value;

Example

document.getElementById("demo").innerHTML = myFunction("John");

function myFunction(name) {

return "Hello " + name;

}

A class is a type of object template.

The class statement initiates a JavaScript class.

Properties and methods are assigned in the constructor() method.

The constructor() method is called each time a class object is initialized.

Syntax

class className {

// class body

}

Example

// Create a Car class

class Car {

constructor(brand) {

this.carname = brand;

}

}

// Create a Car Object

myCar = new Car("Ford");

The if/else statement executes a block of code if a specified condition is true. If the condition is false, another block of code can be executed.

The if/else statement is a part of JavaScript's "Conditional" Statements, which are used to perform different actions based on different conditions.

In JavaScript we have the following conditional statements:

• Use if to specify a block of code to be executed, if a specified condition is true

• Use else to specify a block of code to be executed, if the same condition is false

• Use else if to specify a new condition to test, if the first condition is false

• Use switch to select one of many blocks of code to be executed

Syntax

The if statement specifies a block of code to be executed if a condition is true:

if (condition) {

// block of code to be executed if the condition is true

}

The else statement specifies a block of code to be executed if the condition is false:

if (condition) {

// block of code to be executed if the condition is true

} else {

// block of code to be executed if the condition is false

}

The else if statement specifies a new condition if the first condition is false:

if (condition1) {

// block of code to be executed if condition1 is true

} else if (condition2) {

// block of code to be executed if the condition1 is false and condition2 is true

} else {

// block of code to be executed if the condition1 is false and condition2 is false

}

The switch statement executes a block of code depending on different cases.

The switch statement is a part of JavaScript's "Conditional" Statements, which are used to perform different actions based on different conditions. Use switch to select one of many blocks of code to be executed. This is the perfect solution for long, nested if/else statements.

The switch statement evaluates an expression. The value of the expression is then compared with the values of each case in the structure. If there is a match, the associated block of code is executed.

The switch statement is often used together with a break or a default keyword (or both). These are both optional:

• The break keyword breaks out of the switch block. This will stop the execution of more execution of code and/or case testing inside the block. If break is omitted, the next code block in the switch statement is executed.

• The default keyword specifies some code to run if there is no case match. There can only be one default keyword in a switch. Although this is optional, it is recommended that you use it, as it takes care of unexpected cases.

Syntax

switch(expression) {

case n:

code block

break;

case n:

code block

break;

default:

default code block

}

The break statement breaks out of a switch or a loop.

In a switch, it breaks out of the switch block. This stops the execution of more code inside the switch.

In in a loop, it breaks out of the loop and continues executing the code after the loop (if any).

let text = "";

for (let i = 0; i < 5; i++) {

if (i === 3) break;

text += i + "<br>";

}

let text = "";i = 0;

while (i < 5) {

text += i + "<br>";

i++;

if (i === 3) break;

}

The for statement defines a code block that is executed as long as a condition is true.

Note: If you omit statement 2, you must provide a break inside the loop. Otherwise the loop will never end. This will crash your browser.

Syntax

for (statement 1; statement 2; statement 3) {

code block to be executed

}

Example

for (let i = 0; i < 5; i++) {

text += i + "<br>";

}

Loop (iterate over) an array to collect car names:

const cars = ["BMW", "Volvo", "Saab", "Ford"];

for (let i = 0; i < cars.length; i++) {

text += cars[i] + "<br>";

}

The for...in statements combo iterates (loops) over the properties of an object.

The code block inside the loop is executed once for each property.

Note: Do not use for...in to iterate an array if the index order is important. Use a for loop instead.

Syntax

for (x in object) {

code block to be executed

}

Iterate (loop) over the properties of an object:

constperson = {fname:"John", lname:"Doe", age:25};

let text = "";

for (let x in person) {

text += person[x] + " ";

}

Iterate (loop) over the values of an array:

const cars = ["BMW", "Volvo", "Saab", "Ford"];

let text = "";

for (let x in cars) {

text += cars[x] + " ";

}

The for...of statements combo iterates (loops) over the values of any iterable.

The code block inside the loop is executed once for each value.

Syntax

for (x of iterable) {

code block to be executed

}

Iterate (loop) over the values of an array:

let text = "";

const cars = ['BMW', 'Volvo', 'Mini'];

for (let x of cars) {

text += x + " ";

}

Iterate (loop) over the values of a string:

let text = "JavaScript";

for (let x of text) {

text += x + " ";

}

The do...while statements combo defines a code block to be executed once, and repeated as long as a condition is true.

The do...while is used when you want to run a code block at least one time.

Note: If you use a variable in the condition, you must initialize it before the loop, and increment it within the loop. Otherwise the loop will never end. This will crash your browser.

Note: If the condition is always true, the loop will never end. This will also crash your browser.

Syntax

do {

code block to be executed

}

while (condition);

Example

let text = "";

let i = 0;

do {

text += i + "<br>";

i++;

}

while (i < 5);

The while statement creates a loop (araund a code block) that is executed while a condition is true.

The loop runs while the condition is true. Otherwise it stops.

Syntax

while (condition) {

code block to be executed

}

Loop a code block as long as a i is less than 5:

let text = "";

let i = 0;

while (i < 5) {

text += i + "<br>";

i++;

}

Loop (iterate over) an array to collect car names:

const cars = ["BMW", "Volvo", "Saab", "Ford"];

let text = "";

let i = 0;

while (i < cars.length) {

text += cars[i] + "<br>";

i++;

}

The continue statement breaks one iteration (in the loop) if a specified condition occurs, and continues with the next iteration in the loop.

The difference between continue and the break statement, is instead of "jumping out" of a loop, the continue statement "jumps over" one iteration in the loop.

However, when the continue statement is executed, it behaves differently for different types of loops:

• In a while loop, the condition is tested, and if it is true, the loop is executed again

• In a for loop, the increment expression (e.g. i++) is first evaluated, and then the condition is tested to find out if another iteration should be done

The continue statement can also be used with an optional label reference.

Note: The continue statement (with or without a label reference) can only be used inside a loop.

Loop through a block of code, but skip the value of 3:

let text = "";

for (let i = 0; i < 5; i++) {

if (i === 3) continue;

text += i + "<br>";

}

let text = "";

let i = 0;

while (i < 5) {

i++;

if (i === 3) continue;

text += i + "<br>";

}

The throw statement allows you to create a custom error.

The throw statement throws (generates) an error.

The throw statement throws an exception.

The exception can be a JavaScript String, a Number, a Boolean or an Object:

Note: Using throw with try and catch, lets you control program flow and generate custom error messages.

function myFunction() {

const message = document.getElementById("message");

message.innerHTML = "";

let x = document.getElementById("demo").value;

try {

if(x == "") throw "is Empty";

if(isNaN(x)) throw "not a number";

if(x > 10) throw "too high";

if(x < 5) throw "too low";

}

catch(err) {

message.innerHTML = "Input " + err;

}

}

The try...catch...finally statements combo handles errors without stopping JavaScript.

The try statement defines the code block to run (to try).

The catch statement defines a code block to handle any error.

The finally statement defines a code block to run regardless of the result.

The throw statement defines a custom error.

Both catch and finally are optional, but you must use one of them

Syntax

try {

tryCode - Code block to run

}

catch(err) {

catchCode - Code block to handle errors

}

finally {

finallyCode - Code block to be executed regardless of the try result

}

Example

function myFunction()

const message = document.getElementById("message");

message.innerHTML = "";

let x = document.getElementById("demo").value;

try {

if(x == "") throw "Empty";

if(isNaN(x)) throw "Not a number";

if(x > 10) throw "Too high";

if(x < 5) throw "Too low";

}

catch(err) {

message.innerHTML = "Error: " + err + ".";

}

finally {

document.getElementById("demo").value = "";

}

}

The debugger statement stops the execution of JavaScript, and calls the debugger.

Note: If no debugging is available, the debugger statement has no effect. Normally, you activate debugging in your browser with the F12 key, and select "Console" in the debugger menu.

let x = 15 * 5;

debugger;

document.getElementbyId("demo").innerHTML = x;

The JSON.parse() method parses a string and returns a JavaScript object.

The string has to be written in JSON format.

The JSON.parse() method can optionally transform the result with a function.

Syntax

JSON.parse(string, function)

Example

var obj = JSON.parse('{"firstName":"John", "lastName":"Doe"}');

The JSON.stringify() method converts JavaScript objects into strings.

When sending data to a web server the data has to be a string.

Syntax

JSON.stringify(obj, replacer, space)

Example

var obj = { "name":"John", "age":30, "city":"New York"};

var myJSON = JSON.stringify(obj);

document.getElementById("demo").innerHTML = myJSON;