Scope determines the accessibility (visibility) of variables.
JavaScript variables have 3 types of scope:
Before ES6 (2015), JavaScript variables had only Global Scope and Function Scope.
ES6 introduced two important new JavaScript keywords: let and const.
These two keywords provide Block Scope in JavaScript. Continue reading JavaScript Scope
The try statement defines a 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.
When executing JavaScript code, different errors can occur.
Errors can be coding errors made by the programmer, errors due to wrong input, and other unforeseeable things.
In this example we misspelled “alert” as “adddlert” to deliberately produce an error:
<p id="demo"></p>
<script>
try {
adddlert("Welcome guest!");
}
catch(err) {
document.getElementById("demo").innerHTML = err.message;
}
</script>
JavaScript catches adddlert as an error, and executes the catch code to handle it.
The try statement allows you to define a block of code to be tested for errors while it is being executed.
The catch statement allows you to define a block of code to be executed, if an error occurs in the try block.
The JavaScript statements try and catch come in pairs:
try {
Block of code to try
}
catch(err) {
Block of code to handle errors
}
When an error occurs, JavaScript will normally stop and generate an error message.
The technical term for this is: JavaScript will throw an exception (throw an error).
JavaScript will actually create an Error object with two properties: name and message.
The throw statement allows you to create a custom error.
Technically you can throw an exception (throw an error).
The exception can be a JavaScript String, a Number, a Boolean or an Object:
throw “Too big”; // throw a text
throw 500; // throw a number
If you use throw together with try and catch, you can control program flow and generate custom error messages.
This example examines input. If the value is wrong, an exception (err) is thrown.
The exception (err) is caught by the catch statement and a custom error message is displayed:
<!DOCTYPE html>
<html>
<body>
<p>Please input a number between 5 and 10:</p>
<input id="demo" type="text">
<button type="button" onclick="myFunction()">Test Input</button>
<p id="p01"></p>
<script>
function myFunction() {
const message = document.getElementById("p01");
message.innerHTML = "";
let x = document.getElementById("demo").value;
try {
if(x.trim() == "") throw "empty";
if(isNaN(x)) throw "not a number";
x = Number(x);
if(x < 5) throw "too low";
if(x > 10) throw "too high";
}
catch(err) {
message.innerHTML = "Input is " + err;
}
}
</script>
</body>
</html>
The code above is just an example.
Modern browsers will often use a combination of JavaScript and built-in HTML validation, using predefined validation rules defined in HTML attributes:
<input id="demo" type="number" min="5" max="10" step="1">
The finally statement lets you execute code, after try and catch, regardless of the result:
try {
Block of code to try
}
catch(err) {
Block of code to handle errors
}
finally {
Block of code to be executed regardless of the try / catch result
}
function myFunction() {
const message = document.getElementById("p01");
message.innerHTML = "";
let x = document.getElementById("demo").value;
try {
if(x.trim() == "") throw "is empty";
if(isNaN(x)) throw "is not a number";
x = Number(x);
if(x > 10) throw "is too high";
if(x < 5) throw "is too low";
}
catch(err) {
message.innerHTML = "Error: " + err + ".";
}
finally {
document.getElementById("demo").value = "";
}
}
JavaScript has a built in error object that provides error information when an error occurs.
The error object provides two useful properties: name and message.
| Property | Description |
|---|---|
| name | Sets or returns an error name |
| message | Sets or returns an error message (a string) |
Six different values can be returned by the error name property:
| Error Name | Description |
|---|---|
| EvalError | An error has occurred in the eval() function |
| RangeError | A number “out of range” has occurred |
| ReferenceError | An illegal reference has occurred |
| SyntaxError | A syntax error has occurred |
| TypeError | A type error has occurred |
| URIError | An error in encodeURI() has occurred |
The six different values are described below.
An EvalError indicates an error in the eval() function.
Newer versions of JavaScript do not throw EvalError. Use SyntaxError instead.
A RangeError is thrown if you use a number that is outside the range of legal values.
For example: You cannot set the number of significant digits of a number to 500.
let num = 1;
try {
num.toPrecision(500); // A number cannot have 500 significant digits
}
catch(err) {
document.getElementById("demo").innerHTML = err.name;
}
A ReferenceError is thrown if you use (reference) a variable that has not been declared:
let x = 5;
try {
x = y + 1; // y cannot be used (referenced)
}
catch(err) {
document.getElementById("demo").innerHTML = err.name;
}
A SyntaxError is thrown if you try to evaluate code with a syntax error.
try {
eval("alert('Hello)"); // Missing ' will produce an error
}
catch(err) {
document.getElementById("demo").innerHTML = err.name;
}
A TypeError is thrown if an operand or argument is incompatible with the type expected by an operator or function.
let num = 1;
try {
num.toUpperCase(); // You cannot convert a number to upper case
}
catch(err) {
document.getElementById("demo").innerHTML = err.name;
}
A URIError is thrown if you use illegal characters in a URI function:
try {
decodeURI("%%%"); // You cannot URI decode percent signs
}
catch(err) {
document.getElementById("demo").innerHTML = err.name;
}
Mozilla and Microsoft define some non-standard error object properties:
fileName (Mozilla)
lineNumber (Mozilla)
columnNumber (Mozilla)
stack (Mozilla)
description (Microsoft)
number (Microsoft)
Do not use these properties in public web sites. They will not work in all browsers.
Operator precedence describes the order in which operations are performed in an arithmetic expression.
Multiplication (*) and division (/) have higher precedence than addition (+) and subtraction (-).
As in traditional mathematics, multiplication is done first:
let x = 100 + 50 * 3;
When using parentheses, operations inside the parentheses are computed first :
let x = (100 + 50) * 3;
Operations with the same precedence (like * and /) are computed from left to right : Continue reading JavaScript Operator Precedence
A regular expression is a sequence of characters that forms a search pattern.
The search pattern can be used for text search and text replace operations.
A regular expression is a sequence of characters that forms a search pattern.
When you search for data in a text, you can use this search pattern to describe what you are searching for.
A regular expression can be a single character, or a more complicated pattern.
Regular expressions can be used to perform all types of text search and text replace operations. Continue reading JavaScript Regular Expressions
| Operator | Name | Description |
|---|---|---|
| & | AND | Sets each bit to 1 if both bits are 1 |
| | | OR | Sets each bit to 1 if one of two bits is 1 |
| ^ | XOR | Sets each bit to 1 if only one of two bits is 1 |
| ~ | NOT | Inverts all the bits |
| << | Zero fill left shift | Shifts left by pushing zeros in from the right and let the leftmost bits fall off |
| >> | Signed right shift | Shifts right by pushing copies of the leftmost bit in from the left, and let the rightmost bits fall off |
| >>> | Zero fill right shift | Shifts right by pushing zeros in from the left, and let the rightmost bits fall off |
The destructuring assignment syntax unpack object properties into variables:
let {firstName, lastName} = person;
It can also unpack arrays and any other iterables:
let [firstName, lastName] = person;
// Create an Object
const person = {
firstName: "John",
lastName: "Doe",
age: 50
};
// Destructuring
let {firstName, lastName} = person;
The order of the properties does not matter : Continue reading JavaScript Destructuring
JavaScript variables can be converted to a new variable and another data type:
The typeof operator returns the data type of a JavaScript variable.
In JavaScript, a primitive value is a single value with no properties or methods.
JavaScript has 7 primitive data types:
The typeof operator returns the type of a variable or an expression.
typeof "John" // Returns string
typeof ("John"+"Doe") // Returns string
typeof 3.14 // Returns number
typeof 33 // Returns number
typeof (33 + 66) // Returns number
typeof true // Returns boolean
typeof false // Returns boolean
typeof 1234n // Returns bigint
typeof Symbol() // Returns symbol
typeof x // Returns undefined
typeof null // Returns object
In JavaScript, null is a primitive value. However, typeof returns “object”.
This is a well-known bug in JavaScript and has historical reasons.
You can create a map by passing an array to the new Map() constructor:
// Create a Map
const fruits = new Map([
["apples", 500],
["bananas", 300],
["oranges", 200]
]);
You get the value of a key in a map with the get() method Continue reading JavaScript Map Methods
A Map holds key-value pairs where the keys can be any datatype.
A Map remembers the original insertion order of the keys.
You can create a JavaScript Map by:
new Map()Map.set()You can create a Map by passing an Array to the new Map() constructor : Continue reading JavaScript Maps