JavaScript syntax

The syntax of JavaScript is the set of rules that define a correctly structured JavaScript program.
The examples below make use of the log function of the console object present in most browsers for standard text output.
The JavaScript standard library lacks an official standard text output function. Given that JavaScript is mainly used for client-side scripting within modern Web browsers, and that almost all Web browsers provide the alert function, alert can also be used, but is not commonly used.

Origins

summarized the ancestry of the syntax in the first paragraph of the JavaScript 1.1 specification as follows:

Basics

Case sensitivity

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

let a=5;
console.log; // 5
console.log; // throws a ReferenceError: A is not defined

Whitespace and semicolons

s, tabs and newlines used outside of string constants are called whitespace. Unlike in C, whitespace in JavaScript source can directly impact semantics. Because of a technique called "automatic semicolon insertion", some statements that are well formed when a newline is parsed will be considered complete. Some authorities advise supplying statement-terminating semicolons explicitly, because it may lessen unintended effects of the automatic semicolon insertion.
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 ".foo // Treated as: // a = b + c.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 '.foo // Treated as: // a = b + c; // .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. 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 syntax is the same as in C++ and many other languages. // a short, one-line comment /* this is a long, multi-line comment about my script. May it one day be great. */ /* Comments /* may not be nested */ Syntax error */ Variables s in standard JavaScript have no type attached, and any value can be stored in any variable. Starting with ES6, the version of the language finalised in 2015, variables can be declared with let, var or const. However, while the object assigned to a const cannot be changed, its properties can. Before ES6, variables were declared only with a var statement. An identifier must start with a letter, underscore, or dollar sign ; subsequent characters can also be digits. Because JavaScript is case sensitive, letters include the characters "A" through "Z" and the characters "a" through "z". Starting with JavaScript 1.5, ISO 8859-1 or Unicode letters can be used in identifiers. In certain JavaScript implementations, the at sign can be used in an identifier, but this is contrary to the specifications and not supported in newer implementations.Scoping and hoisting Variables are lexically scoped at function level, and this does not depend on order : if a variable is declared inside a function, then inside the function, the name will resolve to that variable. This is equivalent in block scoping to variables being forward declared at the top of the function, and is referred to as . However, the variable value is undefined until it is initialized, and forward reference is not possible. Thus a statement in the middle of the function is equivalent to a declaration statement at the top of the function, and an assignment statement at that point in the middle of the function – only the declaration is hoisted, not the assignment. Function statements, whose effect is to declare a variable of type Function and assign a value 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. Be sure to understand that var func = function // will NOT be hoisted function func // will be 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 any function are global. If a variable is declared in a higher scope, it can be accessed by child functions. When JavaScript tries to resolve an identifier, it looks in the local function scope. If this identifier is not found, it looks in the outer function that declared the local one, 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" as a property of the global object. As a consequence, a variable never declared will be global, if assigned. Declaring a variable in the global code, assigning a never declared identifier or adding a property to the global object 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. Also const cannot be declared without initialization.Examples Here are examples of variable declarations and scope: var x = 0; // A global variable, because it is not in any function function f f; console.log; // This line will raise a ReferenceError exception, because the value of z is no longer available for console.log; console.log; // throws a ReferenceError: i is not defined for console.log; // throws a TypeError: Assignment to constant variable const pi; // throws a SyntaxError: Missing initializer in const declaration Primitive data types The JavaScript language provides six primitive data types: Undefined Null Number [|String] Boolean Symbol Some of the primitive data types also provide a set of named values that represent the extents of the type boundaries. These named values are described within the appropriate sections below.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. var test; // variable declared, but not defined,... //... set to value of undefined var testObj = ; console.log; // test variable exists, but value not... //... defined, displays undefined console.log; // testObj exists, property does not,... //... displays undefined console.log; // unenforced type during check, displays true console.log; // enforce type during check, displays false Note: There is no built-in language literal for undefined. Thus 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. A more robust approach is to compare using. Functions like this won't work as expected: function isUndefined // like this... function isUndefined //... or that second one function isUndefined //... or that third one Here, calling isUndefined raises a if is an unknown identifier, whereas doesn't.Null Unlike undefined, null is often set to indicate that something has been declared, but has been defined to be empty. In a Boolean context, the value of null is considered a false value in JavaScript. Note: Null is a true primitive-type within the JavaScript language, of which is the single value. As such, when performing checks that enforce type checking, the null value will not equal other false types. Surprisingly, is considered an object by. console.log; // unenforced type during check, displays true console.log; // enforce type during check, displays false console.log; // true Number Numbers are represented in binary as IEEE-754 doubles, which provides an accuracy of nearly 16 significant digits. Because they are floating point numbers, they do not always exactly represent real numbers, including fractions. This becomes an issue when comparing or formatting numbers. For example: console.log; // displays true as per ECMASCRIPT 6 Specifications console.log; // displays 0.9299999999999999 As a result, a routine such as the method should be used to round numbers whenever they are . 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 The extents +∞, −∞ and NaN of the number type may be obtained by two program expressions: Infinity; // positive infinity 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, or a unary + or -, may be used to perform explicit numeric conversion: var myString = "123.456"; var myNumber1 = Number; var myNumber2 = +myString; When used as a constructor, a numeric wrapper object is created : myNumericWrapper = new Number; However, it's impossible to use equality operators to determine whether a value is NaN: console.log; // false console.log; // false console.log; // true var a = NaN; var b = a; console.log; // false String A string in JavaScript is a sequence of characters. In JavaScript, strings can be created directly 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. The JavaScript standard allows the backquote character to quote multiline literal strings, but this is supported only on certain browsers as of 2016: Firefox and Chrome, but not Internet Explorer 11. var greeting = "Hello, World!"; var anotherGreeting = 'Greetings, people of Earth.'; Individual characters within a string can be accessed using the method. This is the preferred way when accessing individual characters within a string, because it also works in non-modern browsers: var h = greeting.charAt; In modern browsers, individual characters within a string can be accessed through the same notation as arrays: var h = greeting; However, JavaScript strings are immutable: greeting = "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. Thus: var x = "World"; var compare1 = ; // Here compare1 contains true. var compare2 = ; // 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. var x = '"Hello, World!" he said.'; // Just fine. var x = ""Hello, World!" he said."; // Not good. var x = "\"Hello, World!\" he said."; // Works by escaping " with \" It is possible to create a string using the constructor: var greeting = new String; These objects have a method returning the primitive string wrapped within them: var s = new String; typeof s; // Is 'object'. typeof s.valueOf; // Is 'string'. Equality between two objects does not behave as with string primitives: var s1 = new String; var s2 = new String; s1 s2; // Is false, because they are two distinct objects. s1.valueOf s2.valueOf; // Is true. Boolean provides a Boolean data type with and literals. The operator returns the string for these primitive types. When used in a logical context,,,,,, and the empty string evaluate as due to automatic type coercion. All other values evaluate as, including the strings, and any object. Automatic type coercion by the equality comparison operators can be avoided by using the type checked comparison operators. When type conversion is required, JavaScript converts,,, or operands as follows: ;: 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. ;: If one of the operands is a Boolean, the Boolean operand is converted to 1 if it is, or to 0 if it is. ;: 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 or methods of the object. If this fails, a runtime error is generated. Douglas Crockford advocates the terms "truthy" and "falsy" to describe how values of various types behave when evaluated in a logical context, especially in regard to edge cases. The binary logical operators returned a Boolean value in early versions of JavaScript, but now they return one of the operands instead. The left–operand is returned, if it can be evaluated as :, in the case of conjunction:, or, in the case of disjunction: ; otherwise the right–operand is returned. Automatic type coercion by the comparison operators may differ for cases of mixed Boolean and number-compatible operands, because the Boolean operand will be compared as a numeric value. This may be unexpected. An expression can be explicitly cast to a Boolean primitive by doubling the logical negation operator:, using the function, or using the conditional operator:. // Automatic type coercion console.log; // false... true → 1 ! 2 ← 2 console.log; // false... false → 0 ! 2 ← 2 console.log; // true.... true → 1 1 ← 1 console.log; // true.... false → 0 0 ← 0 console.log; // false... true → 1 ! 2 ← "2" console.log; // false... false → 0 ! 2 ← "2" console.log; // true.... true → 1 1 ← "1" console.log; // true.... false → 0 0 ← "0" console.log; // true.... false → 0 0 ← "" console.log; // false... false → 0 ! NaN console.log; // false...... NaN is not equivalent to anything, including NaN. // Type checked comparison console.log; // false...... data types do not match // Explicit type coercion console.log; // true.... data types and values match console.log; // false... data types match, but values differ console.log; // true.... only ±0 and NaN are “falsy” numbers console.log; // true.... only the empty string is “falsy” console.log); // true.... all objects are “truthy” The new operator can be used to create an object wrapper for a Boolean primitive. However, the operator does not return for the object wrapper, it returns. Because all objects evaluate as, a method such as, or, must be used to retrieve the wrapped value. For explicit coercion to the Boolean type, Mozilla recommends that the function be used in preference to the Boolean object. var b = new Boolean; // Object false var t = Boolean; // Boolean true var f = Boolean); // Boolean false var n = new Boolean; // Not recommended n = new Boolean); // Preferred if || !new Boolean || !t) else if Symbol New in ECMAScript6. A Symbol is a unique and immutable identifier. Example: x=Symbol; y=Symbol; xy; // false arr=; arr=1; arr=2; // x and y are unique keys for the array arr arr; // displays 1 arr; // displays 2 x=Symbol; arr; // displays arr; // is now undefined x=Symbol; arr; // undefined The Symbol wrapper also provides access to a variable free iterator. x=; // x is an Array and iterable ex=x; // provides an iterator for x while !=undefined) console.log; // displays 1,2,3,4 Native objects The JavaScript language provides a handful of native objects. JavaScript native objects are considered part of the JavaScript specification. JavaScript environment notwithstanding, this set of objects should always be available.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. As in the :Category:C programming language family|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. var myArray = ; // Point the variable myArray to a newly... //... created, empty Array myArray.push; // Fill the next empty index, in this case 0 console.log; // Equivalent to console.log; 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; // the 2nd item in myArray myArray; The above two are equivalent. It's not possible to use the "dot"-notation or strings with alternative representations of the number: myArray.1; // syntax error myArray; // not the same as myArray Declaration of an array can use either an Array literal or the Array constructor: myArray = ; // array with length 6 and 6 elements,... //... including 2 undefined elements myArray = new Array; // array with length 6 and 6 elements myArray = new Array; // an empty array with length 365 Arrays are implemented so that only the defined elements use memory; they are "sparse arrays". Setting and only uses space for these two elements, just like any other object. The length of the array will still be reported as 58. One can use the object declaration literal to create objects that behave much like associative arrays in other languages: dog = ; dog; // 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. cats = ; cats; // results in "large" dogs = ; dogs; // 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; // create a new Date instance representing 2010-Mar-01 00:00:00 new Date; // create a new Date instance representing 2010-Mar-01 14:25:30 new Date; // create a new Date instance from a String. Methods to extract fields are provided, as well as a useful toString: var d = new Date; // 2010-Mar-01 14:25:30; // Displays '2010-3-1 14:25:30': console.log + '-' + + '-' + d.getDate + ' ' + d.getHours + ':' + d.getMinutes + ':' + d.getSeconds); // Built-in toString returns something like 'Mon Mar 01 2010 14:25:30 GMT-0500 ': console.log; Error Custom error messages can be created using the Error class: throw new Error; 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 and functions. All the trigonometric functions use angles expressed in radians, not degrees or grads. Property Returned value rounded to 5 digits Description Math.E 2.7183 e |: Natural logarithm base Math.LN2 0.69315 Natural logarithm of 2 Math.LN10 2.3026 Natural logarithm of 10 Math.LOG2E 1.4427 Logarithm to the base 2 of Math.LOG10E 0.43429 Logarithm to the base 10 of Math.PI 3.14159 Pi|: circumference/diameter of a circle Math.SQRT1_2 0.70711 Square root of ½ Math.SQRT2 1.4142 Square root of 2 Example Returned value rounded to 5 digits Description Math.abs 2.3 Absolute value: ? -x : x Math.acos 0.78540 rad. = 45° Arccosine Math.asin 0.78540 rad. = 45° Arcsine Math.atan 0.78540 rad. = 45° Half circle arctangent Math.atan2 -2.3562 rad. = -135° Whole circle arctangent Math.ceil 2 Ceiling: round up to smallest integer ≥ argument Math.cos 0.70711 Cosine Math.exp 2.7183 Exponential function: raised to this power Math.floor 1 Floor: round down to largest integer ≤ argument Math.log 1 Natural logarithm, base Math.max 1 Maximum: ? x : y Math.min -2 Minimum: ? x : y Math.pow 9 Exponentiation : Math.pow gives x^y Math.random 0.17068 Pseudorandom number between 0 and 1 Math.round 2 Round to the nearest integer; half fractions are rounded up Math.sin 0.70711 Sine Math.sqrt 7 Square root Math.tan 1 Tangent Regular expression /expression/.test; // returns Boolean "string".search; // returns position Number "string".replace; // Here are some examples if console.log; console.log; // 11 console.log; // "My name is John" Character classes // \d - digit // \D - non digit // \s - space // \S - non space // \w - word char // \W - non word // - one of // - one not of // - - range if console.log; if console.log; if console.log; if console.log; if console.log; if console.log; Character matching // 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 console.log ; if console.log ; Repeaters // ? - 0 or 1 match // * - 0 or more // + - 1 or more // - exactly n // - n or more // - n or less // - range n to m if console.log; // match: "ac", "abc" if console.log; // match: "ac", "abc", "abbc", "abbbc" etc. if console.log; // match: "abc", "abbc", "abbbc" etc. if console.log; // match: "abbbc" if console.log; // match: "abbbc", "abbbbc", "abbbbbc" etc. if console.log; // match: "abc", "abbc", "abbbc" Anchors // ^ - string starts with // $ - string ends with if console.log ; if console.log ; Subexpression // - groups characters if ?/.test) console.log; // match: "water", "watermark", if |/.test) console.log; Flags // /g - global // /i - ignore upper/lower case // /m - allow matches to span multiple lines console.log; // "hi John!" console.log; // "ratutam" console.log; // "ratutum" Advanced methods my_array = my_string.split; // example my_array = "dog,cat,cow".split; // my_array; my_array = my_string.match; // example my_array = "We start at 11:30, 12:15 and 16:45".match; // my_array; Capturing groups var myRe = / /; var results = myRe.exec; if else console.log; 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. var add = new Function; var t = add; console.log; // 3 The add function above may also be defined using a function expression: var add = function ; var t = add; console.log; // 3 There exists a shorthand for assigning a function expression to a variable, and is as follows: function add var t = add; console.log; // 3 Or var add = ; // or var add = ; var t = add; console.log; // 3 A function instance has properties and methods. function subtract console.log; // 2, expected amount of arguments. console.log); /* "function subtract " /Operators The '+' operator is overloaded: it is used for string concatenation and arithmetic addition. This may cause problems when inadvertently mixing strings and numbers. As a unary operator, it can convert a numeric string to a number. // Concatenate 2 strings console.log; // displays Hello // Add two numbers console.log; // displays 8 // Adding a number and a string results in concatenation console.log; // displays 22 console.log; // displays $34, but $7 may have been expected console.log; // displays $7 console.log; // displays 77, numbers stay numbers until a string is added // Convert a string to a number console.log; // displays true console.log; // displays NaN Similarly, the '*' operator is overloaded: it can convert a string into a number. console.log; // displays 8 console.log; // 21 console.log; // 21 console.log; // displays NaN Arithmetic JavaScript supports the following binary arithmetic operators: + addition - subtraction * multiplication / division % modulo ** exponentiation JavaScript supports the following unary arithmetic operators: + unary conversion of string to number - unary negation ++ increment -- decrement var x = 1; console.log; // x becomes 2; displays 2 console.log; // displays 2; x becomes 3 console.log; // x is 3; displays 3 console.log; // displays 3; x becomes 2 console.log; // displays 2; x is 2 console.log; // 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. var x = 17; console.log; // displays 2 console.log; // displays 5 console.log; // displays -2 console.log; // displays -2 console.log; // displays 2 To always return a non-negative number, re-add the modulus and apply the modulo operator again: var x = 17; console.log; // displays 3 Assignment of primitive types var x = 9; x += 1; console.log; // displays: 10 x *= 30; console.log; // displays: 300 x /= 6; console.log; // displays: 50 x -= 3; console.log; // displays: 47 x %= 7; console.log; // displays: 5 Assignment of object types /** * To learn JavaScript objects... */ var object_1 = ; // assign reference of newly created object to object_1 var object_2 = ; var 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 doesn't 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 Destructuring assignment In Mozilla's JavaScript, since version 1.7, destructuring assignment allows the assignment of parts of data structures to several variables at once. The left hand side of an assignment is a pattern that resembles an arbitrarily nested object/array literal containing l-lvalues at its leaves that are to receive the substructures of the assigned value. var a, b, c, d, e; = ; console.log; // displays: 3,4,5 e = ; var arr = ; = e; console.log; // displays: 5,6,Baz,,,Content = ; // swap contents of a and b console.log; // displays: 6,5 = ; // permutations = ; console.log; // displays: 4,5,3 Spread/rest operator The ECMAScript 2015 standard introduces the "..." operator, for the related concepts of "spread syntax" and "rest parameters" Spread syntax provides another way to destructure arrays. It indicates that the elements in a specified array should be used as the parameters in a function call or the items in an array literal. In other words, "..." transforms "" into ", foo, foo; // It can be used multiple times in the same expression var b = ; // b = ; // It can be combined with non-spread items. var c = ; // c = ; // For comparison, doing this without the spread operator // creates a nested array. var d = ; // d = 1, 2, 3, 4], foo; // "0" → c = Rest parameters are similar to Javascript's arguments object, which is an array-like object that contains all of the parameters in the current function call. Unlike arguments, however, rest parameters are true Array objects, so methods such as .slice and .sort can be used on them directly. The ... operator can only be used with Array objects.Comparison Variables referencing objects are equal or identical only if they reference the same object: var obj1 = ; var obj2 = ; var obj3 = obj1; console.log; //false console.log; //true console.log; //true See also String.Logical JavaScript provides four logical operators: unary negation binary disjunction and conjunction ternary conditional 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; console.log; console.log; // Only zero and NaN return false console.log; console.log; console.log; // equivalent to -1*0 console.log; // All objects return true console.log; console.log; console.log; // These types return false console.log; console.log; // 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; console.log; console.log; console.log; console.log; console.log; console.log; console.log; console.log; console.log; console.log; console.log; The ternary operator can also be used for explicit conversion: console.log; console.log; // “truthy”, but the comparison uses .toString console.log; console.log; // .toString "0" console.log; console.log; // "0" → 0... ... 0 ← false console.log; console.log; // .toString "1" console.log; console.log; // "1" → 1... ... 1 ← true console.log; console.log; // .toString "2" console.log; console.log; // "2" → 2... ... 1 ← true Expressions that use features such as post–incrementation 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; // When a is true, there is no reason to evaluate b. console.log; // When a is false, there is no reason to evaluate b. console.log; // 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. However, all contemporary implementations return one of their operands instead: console.log; // if a is true, return a, otherwise return b console.log; // 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: var s = t || ""; // assigns t, or the default value, if t is null, empty, etc. Bitwise JavaScript supports the following binary bitwise operators: & AND OR ^ XOR ! NOT << shift left >> shift right ; copies of the leftmost bit are shifted in from the left >>> shift right. For positive numbers, >> and >>> yield the same result. Examples: x=11 & 6; console.log; // 2 JavaScript supports the following unary bitwise operator:Bitwise Assignment JavaScript supports the following binary assignment operators: &= and = or ^= xor <<= shift left >>= shift right ; copies of the leftmost bit are shifted in from the left >>>= shift right. For positive numbers, >>= and >>>= yield the same result. Examples: x=7; console.log; // 7 x<<=3; console.log; // 7->14->28->56 String = assignment + concatenation += concatenate and assign Examples: str = "ab" + "cd"; // "abcd" str += "e"; // "abcde" str2 = "2" + 2; // "22", not "4" or 4. Control structures 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 else if else 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. result = condition ? expression : alternative; is the same as: if else 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 break; is optional; however, it is usually needed, since otherwise code execution will continue to the body of the next case block. 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 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 or for // one statement For ... in loop The syntax of the JavaScript for... in loop is as follows: for 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. Thus, adding a method to the array prototype with 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 Do ... while loop The syntax of the JavaScript do... while loop is as follows: do while ; 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 ; Note the absence of before each 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, this statement is not allowed in strict mode.Labels JavaScript supports nested labels in most implementations. Loops or blocks can be labelled for the break statement, and loops for continue. Although goto is a reserved word, goto is not implemented in JavaScript. loop1: for block1: goto block1; // Parse error. Functions A function is a block with a parameter list that is normally given a name. A function may use local variables. If you exit the function without a return statement, the value is returned. function gcd console.log; // 20 var mygcd = gcd; // mygcd is a reference to the same function as gcd. Note no argument s. console.log; // 20 Functions are first class objects and may be assigned to other variables. The number of arguments given when calling a function may not necessarily correspond to the number of arguments in the function definition; a named argument in the definition that does not have a matching argument in the call will have the value . Within the function, the arguments may also be accessed through the object; this provides access to all arguments using indices, including those beyond the number of named arguments. function add7 ; add7; // 11 add7; // 9 Primitive values are passed by value. For objects, it is the reference to the object that is passed. var obj1 = ; var obj2 = ; function foo foo; // Does not affect obj1 at all. 3 is additional parameter console.log; // writes 1 3 Functions can be declared inside other functions, and access the outer function's local variables. Furthermore, they implement full closures by remembering the outer function's local variables even after the outer function has exited. var v = "Top"; var bar, baz; function foo foo; baz; bar; // Fugly even though foo has exited. console.log; // Top Objects For convenience, types are normally subdivided into primitives and objects. Objects are entities that have an identity and that map property names to values. Objects may be thought of as associative arrays or hashes, and are often implemented using these data structures. However, objects have additional features, such as a prototype chain, which ordinary associative arrays do not have. JavaScript has several kinds of built-in objects, namely Array, Boolean, Date, Function, Math, Number, Object, RegExp and String. Other objects are "host objects", defined not by the language, but by the runtime environment. For example, in a browser, typical host objects belong to the DOM.Creating objects Objects can be created using a constructor or an object literal. The constructor can use either a built-in Object function or a custom function. It is a convention that constructor functions are given a name that starts with a capital letter: // Constructor var anObject = new Object; // Object literal var objectA = ; var objectA2 = ; // A != A2, s create new objects as copies. var objectB = ; // Custom constructor Object literals and array literals allow one to easily create flexible data structures: var myStructure = ; This is the basis for JSON, which is a simple notation that uses JavaScript-like syntax for data exchange.Methods A method is simply a function that has been assigned to a property name of an object. Unlike many object-oriented languages, there is no distinction between a function definition and a method definition in object-related JavaScript. Rather, the distinction occurs during function calling; a function can be called as a method. When called as a method, the standard local variable ' is just automatically set to the object instance to the left of the "". In the example below, Foo is being used as a constructor. There is nothing special about a constructor - it is just a plain function that initialises an object. When used with the ' keyword, as is the norm, is set to a newly created blank object. Note that in the example below, Foo is simply assigning values to slots, some of which are functions. Thus it can assign different functions to different instances. There is no prototyping in this example. function px function Foo var foo1 = new Foo; var foo2 = new Foo; foo2.prefix = "b-"; console.log + foo2.pyz); // foo1/2 a-Y b-Z foo1.m3 = px; // Assigns the function itself, not its evaluated result, i.e. not px var baz = ; baz.m4 = px; // No need for a constructor to make an object. console.log + foo1.m3 + baz.m4); // m1/m3/m4 a-X a-X c-X foo1.m2; // Throws an exception, because foo1.m2 doesn't exist. Constructors s simply assign values to slots of a newly created object. The values may be data or other functions. Example: Manipulating an object: function MyObject MyObject.staticC = "blue"; // On MyObject Function, not object console.log; // blue object = new MyObject; console.log; // red console.log; // 1000 console.log; // undefined object.attributeC = new Date; // add a new property delete object.attributeB; // remove a property of object console.log; // undefined delete object; // remove the whole Object console.log; // throws an exception The constructor itself is referenced in the object's prototype's constructor slot. So, function Foo // Use of 'new' sets prototype slots would set x's prototype to Foo.prototype, // and Foo.prototype has a constructor slot pointing back to Foo). x = new Foo; // The above is almost equivalent to y = ; y.constructor = Foo; y.constructor; // Except x.constructor y.constructor // true x instanceof Foo // true y instanceof Foo // false // y's prototype is Object.prototype, not // Foo.prototype, since it was initialised with // instead of new Foo. // Even though Foo is set to y's constructor slot, // this is ignored by instanceof - only y's prototype's // constructor slot is considered. Functions are objects themselves, which can be used to produce an effect similar to "static properties" as shown below. Object deletion is rarely used as the scripting engine will garbage collect objects that are no longer being referenced.Inheritance JavaScript supports inheritance hierarchies through prototyping in the manner of Self. In the following example, the class inherits from the class. When is created as, the reference to the base instance of is copied to. Derive does not contain a value for, so it is retrieved from when is accessed. This is made clear by changing the value of, which is reflected in the value of. Some implementations allow the prototype to be accessed or set explicitly using the slot as shown below. function Base function Derived base = new Base; Derived.prototype = base; // Must be before new Derived Derived.prototype.constructor = Derived; // Required to make `instanceof` work d = new Derived; // Copies Derived.prototype to d instance's hidden prototype slot. d instanceof Derived; // true d instanceof Base; // true base.aBaseFunction = function d.anOverride; // Derived::anOverride d.aBaseFunction; // Base::aNEWBaseFunction console.log; // true console.log; // true in Mozilla-based implementations and false in many others. The following shows clearly how references to prototypes are copied on instance creation, but that changes to a prototype can affect all instances that refer to it. function m1 function m2 function m3 function Base Base.prototype.m = m2; bar = new Base; console.log); // bar.m Two function Top t = new Top; foo = new Base; Base.prototype = t; // No effect on foo, the *reference* to t is copied. console.log); // foo.m Two baz = new Base; console.log); // baz.m Three t.m = m1; // Does affect baz, and any other derived classes. console.log); // baz.m1 One In practice many variations of these themes are used, and it can be both powerful and confusing.Exception handling JavaScript includes a try... catch... finally exception handling statement to handle run-time errors. The try... catch... finally statement catches exceptions resulting from an error or a throw statement. Its syntax is as follows: try catch finally Initially, the statements within the try block execute. If an exception is thrown, the script's control flow immediately transfers to the statements in the catch block, with the exception available as the error argument. Otherwise the catch block is skipped. The catch block can, if it does not want to handle a specific error. In any case the statements in the finally block are always executed. This can be used to free resources, although memory is automatically garbage collected. Either the catch or the finally clause may be omitted. The catch argument is required. The Mozilla implementation allows for multiple catch statements, as an extension to the ECMAScript standard. They follow a syntax similar to that used in Java: try catch catch catch catch In a browser, the event is more commonly used to trap exceptions. onerror = function ; Native functions and methods eval (expression) Evaluates expression string parameter, which can include assignment statements. Variables local to functions can be referenced by the expression. However, the represents a major security risk, as it allows a bad actor to execute arbitrary code, and so its use is discouraged. ; // shows val 9.

Popular articles Javier Milei - Argentine libertarian economist, author, radio conductor and public speaker sympathetic to the Austrian School of economic thought. He became widely known for his regular ... Jimmy Carter - American politician, philanthropist, and former farmer who served as the 39th president of the United States from 1977 to 1981. A member of the Democratic Party, he previ... UEFA Euro 2024 - The 2024 UEFA European Football Championship , commonly referred to as UEFA Euro 2024 or simply Euro 2024 , will be the 17th edition of the UEFA European Championship, the quadrennial internationa... Argentina - country located mostly in the southern half of South America. Sharing the bulk of the Southern Cone with Chile to the west, the country is also b... Sam Altman - American entrepreneur, investor, programmer, and blogger. He is the former president of Y Combinator and now the CEO of OpenAI. Early life and education. ... Rosalynn Carter - American who served as First Lady of the United States from 1977 to 1981 as the wife of President Jimmy Carter. For decades, she has been a leading advocate for numerou... Next Argentine presidential election - Next Argentine presidential election - presidential election in Argentina.... Popular movies The Hunger Games (film) - 2012 American dystopian action thriller science fiction-adventure film directed by Gary Ross and based on Suzanne Collins’s 2008 novel of the same name. It is the first insta... untitled Captain Marvel sequel - part of Marvel Cinematic Universe.... Killers of the Flower Moon (film project) - Killers of the Flower Moon - film project in United States of America. It was presented as drama, detective fiction, thriller. The film project starred Leonardo Dicaprio, Robert De Niro. Director of... Five Nights at Freddy's (film) - Five Nights at Freddy's - film published in 2017 in United States of America. Scenarist of the film - Scott Cawthon.... Popular video games Minecraft - sandbox video game developed by Mojang Studios. Created by Markus "Notch" Persson in the Java programming language and released as a public alpha for personal computers in 2... Grand Theft Auto V - 2013 action-adventure game developed by Rockstar North and published by Rockstar Games. It is the first main entry in the Grand Theft Auto series since 2008's Grand Theft ... Roblox - online game platform and game creation system that allows users to program games and play games created by other users. Founded by David Baszucki and Erik Cassel in 2004 and released in... Baldur's Gate III - upcoming role-playing video game developed and published by Larian Studios for Microsoft Windows and the Stadia streaming service. It is the third main game in the Baldur's ... Alan Wake - action-adventure video game developed by Remedy Entertainment and published by Microsoft Studios, released for the Xbox 360 and Microsoft Windows. The story follows best-selling thri... Fortnite - online video game developed by Epic Games and released in 2017. It is available in three distinct game mode versions that otherwise share the same general gameplay and game engine: ... Super Mario RPG - is a role-playing video game developed by Square and published by Nintendo for the Super Nintendo Entertainment System in 1996. It was directed by Yoshihiko Maekawa and Chihiro Fujioka and produced by... Popular books Book of Revelation - The Book of Revelation is the final book of the New Testament, and consequently is also the final book of the Christian Bible. Its title is derived from the first word of the Koine Greek text: apok... Book of Genesis - account of the creation of the world, the early history of humanity, Israel's ancestors and the origins... Gospel of Matthew - The Gospel According to Matthew is the first book of the New Testament and one of the three synoptic gospels. It tells how Israel's Messiah, rejected and executed in Israel, pronounces judgement on ... Michelin Guide - Michelin Guides are a series of guide books published by the French tyre company Michelin for more than a century. The term normally refers to the annually published Michelin Red Guide , the oldest... Psalms - The Book of Psalms , commonly referred to simply as Psalms , the Psalter or "the Psalms", is the first book of the Ketuvim , the third section of the Hebrew Bible, and thus a book of th... Ecclesiastes - Ecclesiastes is one of 24 books of the Tanakh , where it is classified as one of the Ketuvim . Originally written c. 450–200 BCE, it is also among the canonical Wisdom literature of the Old Tes... The 48 Laws of Power - non-fiction book by American author Robert Greene. The book... Popular television series The Crown (TV series) - historical drama web television series about the reign of Queen Elizabeth II, created and principally written by Peter Morgan, and produced by Left Bank Pictures and Sony Pictures Tel... Friends - American sitcom television series, created by David Crane and Marta Kauffman, which aired on NBC from September 22, 1994, to May 6, 2004, lasting ten seasons. With an ensemble cast sta... Young Sheldon - spin-off prequel to The Big Bang Theory and begins with the character Sheldon... Modern Family - American television mockumentary family sitcom created by Christopher Lloyd and Steven Levitan for the American Broadcasting Company. It ran for eleven seasons, from September 23... Loki (TV series) - upcoming American web television miniseries created for Disney+ by Michael Waldron, based on the Marvel Comics character of the same name. It is set in the Marvel Cinematic Universe, shar... Game of Thrones - American fantasy drama television series created by David Benioff and D. B. Weiss for HBO. It... Shameless (American TV series) - American comedy-drama television series developed by John Wells which debuted on Showtime on January 9, 2011. It...

`&=`	and
=	or
`^=`	xor
`<<=`	shift left
`>>=`	shift right ; copies of the leftmost bit are shifted in from the left
`>>>=`	shift right. For positive numbers, `>>=` and `>>>=` yield the same result.

Property	Returned value rounded to 5 digits	Description
`Math.E`	2.7183	e \|: Natural logarithm base
`Math.LN2`	0.69315	Natural logarithm of 2
`Math.LN10`	2.3026	Natural logarithm of 10
`Math.LOG2E`	1.4427	Logarithm to the base 2 of
`Math.LOG10E`	0.43429	Logarithm to the base 10 of
`Math.PI`	3.14159	Pi\|: circumference/diameter of a circle
`Math.SQRT1_2`	0.70711	Square root of ½
`Math.SQRT2`	1.4142	Square root of 2

Example	Returned value rounded to 5 digits	Description
`Math.abs`	2.3	Absolute value: `? -x : x`
`Math.acos`	0.78540 rad. = 45°	Arccosine
`Math.asin`	0.78540 rad. = 45°	Arcsine
`Math.atan`	0.78540 rad. = 45°	Half circle arctangent
`Math.atan2`	-2.3562 rad. = -135°	Whole circle arctangent
`Math.ceil`	2	Ceiling: round up to smallest integer ≥ argument
`Math.cos`	0.70711	Cosine
`Math.exp`	2.7183	Exponential function: raised to this power
`Math.floor`	1	Floor: round down to largest integer ≤ argument
`Math.log`	1	Natural logarithm, base
`Math.max`	1	Maximum: `? x : y`
`Math.min`	-2	Minimum: `? x : y`
`Math.pow`	9	Exponentiation : `Math.pow` gives x^y
`Math.random`	0.17068	Pseudorandom number between 0 and 1
`Math.round`	2	Round to the nearest integer; half fractions are rounded up
`Math.sin`	0.70711	Sine
`Math.sqrt`	7	Square root
`Math.tan`	1	Tangent

`+`	addition
`-`	subtraction
`*`	multiplication
`/`	division
`%`	modulo
`**`	exponentiation

`+`	unary conversion of string to number
`-`	unary negation
`++`	increment
`--`	decrement

`&`	AND
	OR
`^`	XOR
!	NOT
`<<`	shift left
`>>`	shift right ; copies of the leftmost bit are shifted in from the left
`>>>`	shift right. For positive numbers, `>>` and `>>>` yield the same result.