   Link: manifest
   Link: license
   Link: canonical
   [ ] Open main menu
     * Home
     * Random
     * Nearby
     * Log in
     * Donate
     * About Wikipedia
     * Disclaimers
   Wikipedia
   _____________________
   Search

                               JavaScript syntax

   Article Talk
     * Language
     * Watch
     * Edit

   This article has multiple issues. Please help improve it or discuss these  
   issues on the talk page. (Learn how and when to remove these template      
   messages)                                                                  
                                                                              
   This article may be too long to read and navigate comfortably. The         
   readable prose size is 79 kilobytes. Please consider splitting content     
   into sub-articles, condensing it, or adding subheadings. Please discuss    
   this issue on the article's talk page. (May 2019)                          
                                                                              
   This article needs to be updated. The reason given is: New                 
   features/versions now in JavaScript. Please help update this article to    
   reflect recent events or newly available information. (November 2020)      
                                                                              
   (Learn how and when to remove this template message)                       

   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 (with the exception of document.write). 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.

Contents

     * 1 Origins
     * 2 Basics
          * 2.1 Case sensitivity
          * 2.2 Whitespace and semicolons
          * 2.3 Comments
     * 3 Variables
          * 3.1 Scoping and hoisting
          * 3.2 Declaration and assignment
          * 3.3 Examples
     * 4 Primitive data types
          * 4.1 Undefined
          * 4.2 Number
          * 4.3 BigInt
          * 4.4 String
          * 4.5 Boolean
          * 4.6 Type conversion
          * 4.7 Symbol
     * 5 Native objects
          * 5.1 Array
          * 5.2 Date
          * 5.3 Error
          * 5.4 Math
          * 5.5 Regular expression
               * 5.5.1 Character classes
               * 5.5.2 Character matching
               * 5.5.3 Repeaters
               * 5.5.4 Anchors
               * 5.5.5 Subexpression
               * 5.5.6 Flags
               * 5.5.7 Advanced methods
               * 5.5.8 Capturing groups
          * 5.6 Function
     * 6 Operators
          * 6.1 Arithmetic
          * 6.2 Assignment
               * 6.2.1 Destructuring assignment
               * 6.2.2 Spread/rest operator
          * 6.3 Comparison
          * 6.4 Logical
          * 6.5 Logical assignment
          * 6.6 Bitwise
          * 6.7 Bitwise Assignment
          * 6.8 String
          * 6.9 ??
     * 7 Control structures
          * 7.1 Compound statements
          * 7.2 If ... else
          * 7.3 Conditional (ternary) operator
          * 7.4 Switch statement
          * 7.5 For loop
          * 7.6 For ... in loop
          * 7.7 While loop
          * 7.8 Do ... while loop
          * 7.9 With
          * 7.10 Labels
     * 8 Functions
          * 8.1 Async/await
     * 9 Objects
          * 9.1 Creating objects
          * 9.2 Methods
          * 9.3 Constructors
          * 9.4 Inheritance
     * 10 Exception handling
     * 11 Native functions and methods
          * 11.1 eval (expression)
     * 12 See also
     * 13 References
     * 14 Further reading
     * 15 External links

OriginsEdit

   Brendan Eich summarized the ancestry of the syntax in the first paragraph
   of the JavaScript 1.1 specification^[1]^[2] as follows:

     JavaScript borrows most of its syntax from Java, but also inherits from
     Awk and Perl, with some indirect influence from Self in its object
     prototype system.

BasicsEdit

  Case sensitivityEdit

   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:

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

  Whitespace and semicolonsEdit

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

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

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

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

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

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

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

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

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

   Initial semicolons are also sometimes used at the start of JavaScript
   libraries, in case they are appended to another library that omits a
   trailing semicolon, as this can result in ambiguity of the initial
   statement.

   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;

  CommentsEdit

   Comment syntax is the same as in C++, Swift 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 */

VariablesEdit

   Variables in standard JavaScript have no type attached, so any value (each
   value has a type) can be stored in any variable. Starting with ES6, the
   6th version of the language, variables could be declared with var for
   function scoped variables, and let or const which are for block level
   variables. Before ES6, variables could only be declared with a var
   statement. Values assigned to variables declared with const cannot be
   changed, but its properties can. A variable's identifier must start with a
   letter, underscore (_), or dollar sign ($), while subsequent characters
   can also be digits (0-9). JavaScript is case sensitive, so the uppercase
   characters "A" through "Z" are different from the lowercase characters "a"
   through "z".

   Starting with JavaScript 1.5, ISO 8859-1 or Unicode letters (or \uXXXX
   Unicode escape sequences) can be used in identifiers.^[6] 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.^[citation needed]

  Scoping and hoistingEdit

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

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

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

   So, for example,

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

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

  Declaration and assignmentEdit

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

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

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

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

  ExamplesEdit

   Here are some examples of variable declarations and scope:

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

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

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

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

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

 f();

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

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

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

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

Primitive data typesEdit

   The JavaScript language provides six primitive data types:

     * Undefined
     * Number
     * BigInt
     * 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.

  UndefinedEdit

   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);                // test variable exists, but value not ...
                                   // ... defined, displays undefined
 console.log(testObj.myProp);      // testObj exists, property does not, ...
                                   // ... displays undefined
 console.log(undefined == null);   // unenforced type during check, displays true
 console.log(undefined === null);  // enforce type during check, displays false

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

   Functions like this won't work as expected:

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

   Here, calling isUndefined(my_var) raises a ReferenceError if
   Link: mw-deduplicated-inline-style
   my_var is an unknown identifier, whereas typeof my_var === 'undefined'
   doesn't.

  NumberEdit

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

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

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

   As a result, a routine such as the
   Link: mw-deduplicated-inline-style
   toFixed() method should be used to round numbers whenever they are
   formatted for output.

   Numbers may be specified in any of these notations:

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

   There's also a numeric separator,
   Link: mw-deduplicated-inline-style
   _ (the underscore), introduced in ES2021:

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

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

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

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

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

   Infinity and NaN are numbers:

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

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

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

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

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

 myNumericWrapper = new Number(123.456);

   However, NaN is not equal to itself:

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

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

  BigIntEdit

   BigInts can be used for arbitrarily large integers. Especially whole
   numbers larger than 2^53 - 1, which is the largest number JavaScript can
   reliably represent with the Number primitive and represented by the
   Number.MAX_SAFE_INTEGER constant.

   When dividing BigInts, the results are truncated.

  StringEdit

   A string in JavaScript is a sequence of characters. In JavaScript, strings
   can be created directly (as literals) by placing the series of characters
   between double (") or single (') quotes. Such strings must be written on a
   single line, but may include escaped newline characters (such as \n). The
   JavaScript standard allows the backquote character (`, a.k.a. grave accent
   or backtick) to quote multiline literal strings, but this is supported
   only on certain browsers as of 2016: Firefox and Chrome, but not Internet
   Explorer 11.^[10]

 var greeting = "Hello, World!";
 var anotherGreeting = 'Greetings, people of Earth.';

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

 var h = greeting.charAt(0);

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

 var h = greeting[0];

   However, JavaScript strings are immutable:

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

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

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

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

 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 \"

   The
   Link: mw-deduplicated-inline-style
   String constructor creates a string object (an object wrapping a string):

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

   These objects have a
   Link: mw-deduplicated-inline-style
   valueOf method returning the primitive string wrapped within them:

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

   Equality between two
   Link: mw-deduplicated-inline-style
   String objects does not behave as with string primitives:

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

  BooleanEdit

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

  Type conversionEdit

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

   When type conversion is required, JavaScript converts
   Link: mw-deduplicated-inline-style
   Boolean,
   Link: mw-deduplicated-inline-style
   Number,
   Link: mw-deduplicated-inline-style
   String, or
   Link: mw-deduplicated-inline-style
   Object operands as follows:^[11]

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

   Boolean
           If one of the operands is a Boolean, the Boolean operand is
           converted to 1 if it is
           Link: mw-deduplicated-inline-style
           true, or to 0 if it is
           Link: mw-deduplicated-inline-style
           false.

   Object
           If an object is compared with a number or string, JavaScript
           attempts to return the default value for the object. An object is
           converted to a primitive String or Number value, using the
           Link: mw-deduplicated-inline-style
           .valueOf() or
           Link: mw-deduplicated-inline-style
           .toString() 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.^[12] 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 :
   Link: mw-deduplicated-inline-style
   false, in the case of conjunction: (a && b), or
   Link: mw-deduplicated-inline-style
   true, in the case of disjunction: (a || b); otherwise the right–operand is
   returned. Automatic type coercion by the comparison operators may differ
   for cases of mixed Boolean and number-compatible operands (including
   strings that can be evaluated as a number, or objects that can be
   evaluated as such a string), 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: (
   Link: mw-deduplicated-inline-style
   !!), using the
   Link: mw-deduplicated-inline-style
   Boolean() function, or using the conditional operator: (c ? t : f).

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

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

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

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

   The new operator can be used to create an object wrapper for a Boolean
   primitive. However, the
   Link: mw-deduplicated-inline-style
   typeof operator does not return
   Link: mw-deduplicated-inline-style
   boolean for the object wrapper, it returns
   Link: mw-deduplicated-inline-style
   object. Because all objects evaluate as
   Link: mw-deduplicated-inline-style
   true, a method such as
   Link: mw-deduplicated-inline-style
   .valueOf(), or
   Link: mw-deduplicated-inline-style
   .toString(), must be used to retrieve the wrapped value. For explicit
   coercion to the Boolean type, Mozilla recommends that the
   Link: mw-deduplicated-inline-style
   Boolean() function (without
   Link: mw-deduplicated-inline-style
   new) be used in preference to the Boolean object.

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

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

  SymbolEdit

   New in ECMAScript6. A Symbol is a unique and immutable identifier.

   Example:

 var x = Symbol(1);
 var y = Symbol(1);
 x === y; // => false

 var symbolObject = {};
 var normalObject = {};

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

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

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

 normalObject[1]; // => 2

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

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

   There are also well known symbols.

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

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

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

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

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

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

Native objectsEdit

   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.

  ArrayEdit

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

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

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

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

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

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

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

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

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

 let myArray;

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

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

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

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

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

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

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

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

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

  DateEdit

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

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

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

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

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

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

  ErrorEdit

   Custom error messages can be created using the Error class:

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

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

  MathEdit

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

               Some of the constants contained in the Math object
   +------------------------------------------------------------------------+
   |                              | Returned |                              |
   |                              | value    |                              |
   | Property                     | rounded  | Description                  |
   |                              | to 5     |                              |
   |                              | digits   |                              |
   |------------------------------+----------+------------------------------|
   | Link:                        |          |                              |
   | mw-deduplicated-inline-style | 2.7183   | e: Natural logarithm base    |
   | Math.E                       |          |                              |
   |------------------------------+----------+------------------------------|
   | Link:                        |          |                              |
   | mw-deduplicated-inline-style | 0.69315  | Natural logarithm of 2       |
   | Math.LN2                     |          |                              |
   |------------------------------+----------+------------------------------|
   | Link:                        |          |                              |
   | mw-deduplicated-inline-style | 2.3026   | Natural logarithm of 10      |
   | Math.LN10                    |          |                              |
   |------------------------------+----------+------------------------------|
   | Link:                        |          |                              |
   | mw-deduplicated-inline-style | 1.4427   | Logarithm to the base 2 of e |
   | Math.LOG2E                   |          |                              |
   |------------------------------+----------+------------------------------|
   | Link:                        |          | Logarithm to the base 10 of  |
   | mw-deduplicated-inline-style | 0.43429  | e                            |
   | Math.LOG10E                  |          |                              |
   |------------------------------+----------+------------------------------|
   | Link:                        |          | π: circumference/diameter of |
   | mw-deduplicated-inline-style | 3.14159  | a circle                     |
   | Math.PI                      |          |                              |
   |------------------------------+----------+------------------------------|
   | Link:                        |          |                              |
   | mw-deduplicated-inline-style | 0.70711  | Square root of ½             |
   | Math.SQRT1_2                 |          |                              |
   |------------------------------+----------+------------------------------|
   | Link:                        |          |                              |
   | mw-deduplicated-inline-style | 1.4142   | Square root of 2             |
   | Math.SQRT2                   |          |                              |
   +------------------------------------------------------------------------+

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

  Regular expressionEdit

   Main article: Regular expression

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

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

    Character classesEdit

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

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

    Character matchingEdit

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

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

    RepeatersEdit

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

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

    AnchorsEdit

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

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

    SubexpressionEdit

 // ( )  - groups characters

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

    FlagsEdit

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

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

    Advanced methodsEdit

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

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

    Capturing groupsEdit

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

  FunctionEdit

   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('x', 'y', 'return x + y');
 add(1, 2); // => 3

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

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

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

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

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

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

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

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

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

   A function instance has properties and methods.

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

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

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

OperatorsEdit

   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('He' + 'llo'); // displays Hello

 // Add two numbers
 console.log(2 + 6);  // displays 8

 // Adding a number and a string results in concatenation (from left to right)
 console.log(2 + '2');    // displays 22
 console.log('$' + 3 + 4);  // displays $34, but $7 may have been expected
 console.log('$' + (3 + 4)); // displays $7
 console.log(3 + 4 + '7'); // displays 77, numbers stay numbers until a string is added

 // Convert a string to a number using the unary plus
 console.log(+'2' === 2); // displays true
 console.log(+'Hello'); // displays NaN

   Similarly, the '*' operator is overloaded: it can convert a string into a
   number.

 console.log(2 + '6'*1);  // displays 8
 console.log(3*'7'); // 21
 console.log('3'*'7'); // 21
 console.log('hello'*'world'); // displays NaN

  ArithmeticEdit

   JavaScript supports the following binary arithmetic operators:

   +  addition                                  
   -  subtraction                               
   *  multiplication                            
   /  division (returns a floating-point value) 
   %  modulo (returns the remainder)            
   ** exponentiation                            

   JavaScript supports the following unary arithmetic operators:

   +  unary conversion of string to number 
   -  unary negation (reverses the sign)   
   ++ increment (can be prefix or postfix) 
   -- decrement (can be prefix or postfix) 

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

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

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

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

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

  AssignmentEdit

    =  assign                    
   +=  add and assign            
   -=  subtract and assign       
   *=  multiply and assign       
   /=  divide and assign         
   %=  modulo and assign         
   **= exponentiation and assign 

   Assignment of primitive types

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

   Assignment of object types

 /**
  * To learn JavaScript objects...
  */
 var object_1 = {a: 1};          // assign reference of newly created object to object_1
 var object_2 = {a: 0};
 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() {
         console.log(object_1.a + " " + object_2.a + " " + object_3.a);
 }

    Destructuring assignmentEdit

   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;
 [a, b, c] = [3, 4, 5];
 console.log(a + ',' + b + ',' + c); // displays: 3,4,5
 e = {foo: 5, bar: 6, baz: ['Baz', 'Content']};
 var arr = [];
 ({baz: [arr[0], arr[3]], foo: a, bar: b}) = e;
 console.log(a + ',' + b + ',' + arr);   // displays: 5,6,Baz,,,Content
 [a, b] = [b, a];                // swap contents of a and b
 console.log(a + ',' + b);               // displays: 6,5

 [a, b, c] = [3, 4, 5]; // permutations
 [a, b, c] = [b, c, a];
 console.log(a + ',' + b + ',' + c); // displays: 4,5,3

    Spread/rest operatorEdit

   The ECMAScript 2015 standard introduces the "..." operator, for the
   related concepts of "spread syntax"^[13] and "rest parameters"^[14]

   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 "[...foo]" into "[foo[0], foo[1],
   foo[2]]", and "this.bar(...foo);" into "this.bar(foo[0], foo[1],
   foo[2]);".

 var a = [1, 2, 3, 4];
 // It can be used multiple times in the same expression
 var b = [...a, ...a]; // b = [1, 2, 3, 4, 1, 2, 3, 4];
 // It can be combined with non-spread items.
 var c = [5, 6, ...a, 7, 9]; // c = [5, 6, 1, 2, 3, 4, 7, 9];
 // For comparison, doing this without the spread operator
 // creates a nested array.
 var d = [a, a]; // d = [[1, 2, 3, 4], [1, 2, 3, 4]]
 // It works the same with function calls
 function foo(arg1, arg2, arg3) {
     console.log(arg1 + ':' + arg2 + ':' + arg3);
 }
 // You can use it even if it passes more parameters than the function will use
 foo(...a); // "1:2:3" → foo(a[0], a[1], a[2], a[3]);
 // You can mix it with non-spread parameters
 foo(5, ...a, 6); // "5:1:2" → foo(5, a[0], a[1], a[2], a[3], 6);
 // For comparison, doing this without the spread operator
 // assigns the array to arg1, and nothing to the other parameters.
 foo(a); // "1,2,3,4:undefined:undefined"

   When ... is used in a function declaration, it indicates a rest parameter.
   The rest parameter must be the final named parameter in the function's
   parameter list. It will be assigned an Array containing any arguments
   passed to the function in excess of the other named parameters. In other
   words, it gets "the rest" of the arguments passed to the function (hence
   the name).

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

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

   Rest parameters are similar to Javascript's arguments object, which is an
   array-like object that contains all of the parameters (named and unnamed)
   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. (However, there is a
   proposal to extend it to Objects in a future ECMAScript standard.^[15])

  ComparisonEdit

   ==  equal                              
   !=  not equal                          
    >  greater than                       
   >=  greater than or equal to           
    <  less than                          
   <=  less than or equal to              
   === identical (equal and of same type) 
   !== not identical                      

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

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

   See also String.

  LogicalEdit

   JavaScript provides four logical operators:

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

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

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

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

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

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

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

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

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

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

   The ternary operator can also be used for explicit conversion:

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

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

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

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

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

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

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

  Logical assignmentEdit

   ??= Nullish assignment     
   ||= Logical Or assignment  
   &&= Logical And assignment 

  BitwiseEdit

   This section needs expansion. You can help by adding to it. (April 2011) 

   JavaScript supports the following binary bitwise operators:

    &  AND                                                    
    |  OR                                                     
    ^  XOR                                                    
   !   NOT                                                    
   <<  shift left (zero fill at right)                        
   >>  shift right (sign-propagating); copies of the          
       leftmost bit (sign bit) are shifted in from the left   
   >>> shift right (zero fill at left). For positive numbers, 
       >> and >>> yield the same result.                      

   Examples:

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

   JavaScript supports the following unary bitwise operator:

   ~ NOT (inverts the bits) 

  Bitwise AssignmentEdit

   JavaScript supports the following binary assignment operators:

    &=  and                                                    
    |=  or                                                     
    ^=  xor                                                    
   <<=  shift left (zero fill at right)                        
   >>=  shift right (sign-propagating); copies of the          
        leftmost bit (sign bit) are shifted in from the left   
   >>>= shift right (zero fill at left). For positive numbers, 
        >>= and >>>= yield the same result.                    

   Examples:

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

  StringEdit

   =  assignment             
   +  concatenation          
   += concatenate and assign 

   Examples:

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

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

  ??Edit

   Link: mw-deduplicated-inline-style
   This section is an excerpt from Null coalescing operator §
   JavaScript.[edit]

   JavaScript's nearest operator is ??, the "nullish coalescing operator,"
   which was added to the standard in ECMAScript's 11th edition.^[16] In
   earlier versions, it could be used via a Babel plugin, and in TypeScript.
   It evaluates its left-hand operand and, if the result value is not
   "nullish" (null or undefined), takes that value as its result; otherwise,
   it evaluates the right-hand operand and takes the resulting value as its
   result.

   In the following example, a will be assigned the value of b if the value
   of b is not null or undefined, otherwise it will be assigned 3.

 const a = b ?? 3;

   Before the nullish coalescing operator, programmers would use the logical
   OR operator (||). But where ?? looks specifically for null or undefined,
   the || operator looks for any falsy value: null, undefined, "", 0, NaN,
   and of course, false.

   In the following example, a will be assigned the value of b if the value
   of b is truthy, otherwise it will be assigned 3.

 const a = b || 3;

Control structuresEdit

  Compound statementsEdit

   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 ... elseEdit

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

  Conditional (ternary) operatorEdit

   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 (condition) {
   result = expression;
  } else {
   result = alternative;
  }

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

  Switch statementEdit

   The syntax of the JavaScript switch statement is as follows:

  switch (expr) {
   case SOMEVALUE:
    // statements;
    break;
   case ANOTHERVALUE:
    // statements;
    break;
   default:
    // statements;
    break;
  }

     * break; is optional; however, it is usually needed, since otherwise
       code execution will continue to the body of the next case block.
     * Add a break statement to the end of the last case as a precautionary
       measure, in case additional cases are added later.
     * String literal values can also be used for the case values.
     * Expressions can be used instead of values.
     * The default case (optional) is executed when the expression does not
       match any other specified cases.
     * Braces are required.

  For loopEdit

   The syntax of the JavaScript for loop is as follows:

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

   or

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

  For ... in loopEdit

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

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

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

  While loopEdit

   The syntax of the JavaScript while loop is as follows:

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

  Do ... while loopEdit

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

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

  WithEdit

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

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

     * Note the absence of
       Link: mw-deduplicated-inline-style
       document. before each
       Link: mw-deduplicated-inline-style
       getElementById() invocation.

   The semantics are similar to the with statement of Pascal.

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

  LabelsEdit

   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,^[17] goto is not implemented in JavaScript.

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

FunctionsEdit

   A function is a block with a (possibly empty) 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
   Link: mw-deduplicated-inline-style
   undefined is returned.

 function gcd(number1, number2) {
   var difference = number1 - number2;
   if (difference == 0)
     return number1;
   return difference > 0 ? gcd(number2, diff) : gcd(number1, -difference);
 }
 console.log(gcd(60, 40)); // 20

 var mygcd = gcd; // mygcd is a reference to the same function as gcd. Note no argument ()s.
 console.log(mygcd(60, 40)); // 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
   Link: mw-deduplicated-inline-style
   undefined (that can be implicitly cast to false). Within the function, the
   arguments may also be accessed through the
   Link: mw-deduplicated-inline-style
   arguments object; this provides access to all arguments using indices
   (e.g. arguments[0], arguments[1], ... arguments[n]), including those
   beyond the number of named arguments. (While the arguments list has a
   .length property, it is not an instance of
   Link: mw-deduplicated-inline-style
   Array; it does not have methods such as
   Link: mw-deduplicated-inline-style
   .slice(),
   Link: mw-deduplicated-inline-style
   .sort(), etc.)

 function add7(x, y) {
   if (!y) {
     y = 7;
   }
   console.log(x + y + arguments.length);
 };
 add7(3); // 11
 add7(3, 4); // 9

   Primitive values (number, boolean, string) are passed by value. For
   objects, it is the reference to the object that is passed.

 var obj1 = {a : 1};
 var obj2 = {b : 2};
 function foo(p) {
   p = obj2; // Ignores actual parameter
   p.b = arguments[1];
 }
 foo(obj1, 3); // Does not affect obj1 at all. 3 is additional parameter
 console.log(obj1.a + " " + obj2.b); // 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() {
   var v = "fud";
   bar = function() { console.log(v) };
   baz = function(x) { v = x; };
 }
 foo();
 baz("Fugly");
 bar(); // Fugly (not fud) even though foo() has exited.
 console.log(v); // Top

  Async/awaitEdit

   Link: mw-deduplicated-inline-style
   Link: mw-deduplicated-inline-style
   This section is an excerpt from Async/await § In JavaScript.[edit]

   The await operator in JavaScript can only be used from inside an async
   function. If the parameter is a promise, execution of the async function
   will resume when the promise is resolved (unless the promise is rejected,
   in which case an error will be thrown that can be handled with normal
   JavaScript exception handling). If the parameter is not a promise, the
   parameter itself will be returned immediately.^[18]

   Many libraries provide promise objects that can also be used with await,
   as long as they match the specification for native JavaScript promises.
   However, promises from the jQuery library were not Promises/A+ compatible
   until jQuery 3.0.^[19]

   Here's an example (modified from this^[20] article):

 async function createNewDoc() {
   let response = await db.post({}); // post a new doc
   return db.get(response.id); // find by id
 }

 async function main() {
   try {
     let doc = await createNewDoc();
     console.log(doc);
   } catch (err) {
     console.log(err);
   }
 }
 main();

   Node.js version 8 includes a utility that enables using the standard
   library callback-based methods as promises.^[21]

ObjectsEdit

   For convenience, types are normally subdivided into primitives and
   objects. Objects are entities that have an identity (they are only equal
   to themselves) and that map property names to values ("slots" in
   prototype-based programming terminology). 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^[clarification needed], 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 (window, form, links, etc.).

  Creating objectsEdit

   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 = {index1: 'value 1', index2: 'value 2'};

 // Custom constructor (see below)

   Object literals and array literals allow one to easily create flexible
   data structures:

 var myStructure = {
   name: {
     first: "Mel",
     last: "Smith"
   },
   age: 33,
   hobbies: ["chess", "jogging"]
 };

   This is the basis for JSON, which is a simple notation that uses
   JavaScript-like syntax for data exchange.

  MethodsEdit

   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
   Link: mw-deduplicated-inline-style
   this is just automatically set to the object instance to the left of the "
   Link: mw-deduplicated-inline-style
   .". (There are also
   Link: mw-deduplicated-inline-style
   call and
   Link: mw-deduplicated-inline-style
   apply methods that can set
   Link: mw-deduplicated-inline-style
   this explicitly—some packages such as jQuery do unusual things with
   Link: mw-deduplicated-inline-style
   this.)

   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
   Link: mw-deduplicated-inline-style
   new keyword, as is the norm,
   Link: mw-deduplicated-inline-style
   this 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() { return this.prefix + "X"; }

 function Foo(yz) {
   this.prefix = "a-";
   if (yz > 0) {
     this.pyz = function() { return this.prefix + "Y"; };
   } else {
     this.pyz = function() { return this.prefix + "Z"; };
   }
   this.m1 = px;
   return this;
 }

 var foo1 = new Foo(1);
 var foo2 = new Foo(0);
 foo2.prefix = "b-";

 console.log("foo1/2 " + foo1.pyz() + 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 = {"prefix": "c-"};
 baz.m4 = px; // No need for a constructor to make an object.

 console.log("m1/m3/m4 " + foo1.m1() + foo1.m3() + baz.m4());
 // m1/m3/m4 a-X a-X c-X

 foo1.m2(); // Throws an exception, because foo1.m2 doesn't exist.

  ConstructorsEdit

   Constructor functions simply assign values to slots of a newly created
   object. The values may be data or other functions.

   Example: Manipulating an object:

 function MyObject(attributeA, attributeB) {
   this.attributeA = attributeA;
   this.attributeB = attributeB;
 }

 MyObject.staticC = "blue"; // On MyObject Function, not object
 console.log(MyObject.staticC); // blue

 object = new MyObject('red', 1000);

 console.log(object.attributeA); // red
 console.log(object["attributeB"]); // 1000

 console.log(object.staticC); // undefined
 object.attributeC = new Date(); // add a new property

 delete object.attributeB; // remove a property of object
 console.log(object.attributeB); // undefined

 delete object; // remove the whole Object (rarely used)
 console.log(object.attributeA); // 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 (for example,
 // x = new Foo() 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" (using C++/Java terminology) as shown
   below. (The function object also has a special prototype property, as
   discussed in the "Inheritance" section below.)

   Object deletion is rarely used as the scripting engine will garbage
   collect objects that are no longer being referenced.

  InheritanceEdit

   JavaScript supports inheritance hierarchies through prototyping in the
   manner of Self.

   In the following example, the
   Link: mw-deduplicated-inline-style
   Derived class inherits from the
   Link: mw-deduplicated-inline-style
   Base class. When
   Link: mw-deduplicated-inline-style
   d is created as
   Link: mw-deduplicated-inline-style
   Derived, the reference to the base instance of
   Link: mw-deduplicated-inline-style
   Base is copied to
   Link: mw-deduplicated-inline-style
   d.base.

   Derive does not contain a value for
   Link: mw-deduplicated-inline-style
   aBaseFunction, so it is retrieved from
   Link: mw-deduplicated-inline-style
   aBaseFunction when
   Link: mw-deduplicated-inline-style
   aBaseFunction is accessed. This is made clear by changing the value of
   Link: mw-deduplicated-inline-style
   base.aBaseFunction, which is reflected in the value of
   Link: mw-deduplicated-inline-style
   d.aBaseFunction.

   Some implementations allow the prototype to be accessed or set explicitly
   using the
   Link: mw-deduplicated-inline-style
   __proto__ slot as shown below.

 function Base() {
   this.anOverride = function() { console.log("Base::anOverride()"); };

   this.aBaseFunction = function() { console.log("Base::aBaseFunction()"); };
 }

 function Derived() {
   this.anOverride = function() { console.log("Derived::anOverride()"); };
 }

 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() { console.log("Base::aNEWBaseFunction()"); }

 d.anOverride();    // Derived::anOverride()
 d.aBaseFunction(); // Base::aNEWBaseFunction()
 console.log(d.aBaseFunction == Derived.prototype.aBaseFunction); // true

 console.log(d.__proto__ == base); // 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() { return "One"; }
 function m2() { return "Two"; }
 function m3() { return "Three"; }

 function Base() {}

 Base.prototype.m = m2;
 bar = new Base();
 console.log("bar.m " + bar.m()); // bar.m Two

 function Top() { this.m = m3; }
 t = new Top();

 foo = new Base();
 Base.prototype = t;
 // No effect on foo, the *reference* to t is copied.
 console.log("foo.m " + foo.m()); // foo.m Two

 baz = new Base();
 console.log("baz.m " + baz.m()); // baz.m Three

 t.m = m1; // Does affect baz, and any other derived classes.
 console.log("baz.m1 " + baz.m()); // baz.m1 One

   In practice many variations of these themes are used, and it can be both
   powerful and confusing.

Exception handlingEdit

   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 {
   // Statements in which exceptions might be thrown
 } catch(errorValue) {
   // Statements that execute in the event of an exception
 } finally {
   // Statements that execute afterward either way
 }

   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
   Link: mw-deduplicated-inline-style
   throw(errorValue), 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 { statement; }
 catch (e if e == "InvalidNameException")  { statement; }
 catch (e if e == "InvalidIdException")    { statement; }
 catch (e if e == "InvalidEmailException") { statement; }
 catch (e)                                 { statement; }

   In a browser, the
   Link: mw-deduplicated-inline-style
   onerror event is more commonly used to trap exceptions.

 onerror = function (errorValue, url, lineNr) {...; return true;};

Native functions and methodsEdit

   Link: mw-deduplicated-inline-style
   (Not related to Web browsers.)

  eval (expression)Edit

   Evaluates the first parameter as an expression, which can include
   assignment statements. Variables local to functions can be referenced by
   the expression. However, eval represents a major security risk, as it
   allows a bad actor to execute arbitrary code, so its use is
   discouraged.^[22]

 > (function foo() {
 ...   var x = 7;
 ...   console.log("val " + eval("x + 2"));
 ... })();
 val 9
 undefined

See alsoEdit

     * Comparison of JavaScript-based source code editors
     * JavaScript

ReferencesEdit

    1. ^ JavaScript 1.1 specification
    2. ^ "Chapter 1. Basic JavaScript". speakingjs.com. Retrieved 22
       September 2020.
    3. ^
       Link: mw-deduplicated-inline-style
       Flanagan, David (2006). JavaScript: The definitive Guide. p. 16.
       ISBN 978-0-596-10199-2. Omitting semicolons is not a good programming
       practice; you should get into the habit of inserting them.
    4. ^ ^a ^b ^c "JavaScript Semicolon Insertion: Everything you need to
       know", ~inimino/blog/, Friday, 28 May 2010
    5. ^ "Semicolons in JavaScript are optional", by Mislav Marohnić, 7 May
       2010
    6. ^
       Link: mw-deduplicated-inline-style
       "Values, Variables, and Literals - MDC". Mozilla Developer Network. 16
       September 2010. Archived from the original on 29 June 2011. Retrieved
       1 February 2020.
    7. ^
       Link: mw-deduplicated-inline-style
       "JavaScript Hoisting". W3Schools. In JavaScript, a variable can be
       declared after it has been used. In other words; a variable can be
       used before it has been declared.
    8. ^ "JavaScript Scoping and Hoisting", Ben Cherry, Adequately Good,
       2010-02-08
    9. ^ ECMA-262 5e edition clarified this behavior with the Declarative
       Environment Record and Object Environment Record. With this formalism,
       the global object is the Object Environment Record of the global
       Lexical Environment (the global scope).
   10. ^
       Link: mw-deduplicated-inline-style
       "Template literals". MDN Web Docs. Retrieved 2 May 2018.
   11. ^
       Link: mw-deduplicated-inline-style
       "Comparison Operators - MDC Doc Center". Mozilla. 5 August 2010.
       Retrieved 5 March 2011.
   12. ^
       Link: mw-deduplicated-inline-style
       "The Elements of JavaScript Style". Douglas Crockford. Retrieved 5
       March 2011.
   13. ^
       Link: mw-deduplicated-inline-style
       "Spread syntax".
   14. ^
       Link: mw-deduplicated-inline-style
       "rest parameters".
   15. ^
       Link: mw-deduplicated-inline-style
       "Ecmascript". Archived from the original on 9 August 2016.
   16. ^
       Link: mw-deduplicated-inline-style
       "ECMAScript 2020 Language Specification". Ecma International. June
       2020.
   17. ^ ECMA-262, Edition 3, 7.5.3 Future Reserved Words
   18. ^
       Link: mw-deduplicated-inline-style
       "await - JavaScript (MDN)". Retrieved 2 May 2017.
   19. ^
       Link: mw-deduplicated-inline-style
       "jQuery Core 3.0 Upgrade Guide". Retrieved 2 May 2017.
   20. ^
       Link: mw-deduplicated-inline-style
       "Taming the asynchronous beast with ES7". Retrieved 12 November 2015.
   21. ^
       Link: mw-deduplicated-inline-style
       Foundation, Node.js. "Node v8.0.0 (Current) - Node.js". Node.js.
   22. ^
       Link: mw-deduplicated-inline-style
       "eval()". MDN Web Docs. Retrieved 29 January 2020.

Further readingEdit

     * Danny Goodman: JavaScript Bible, Wiley, John & Sons,
       Link: mw-deduplicated-inline-style
       ISBN 0-7645-3342-8.
     * David Flanagan, Paula Ferguson: JavaScript: The Definitive Guide,
       O'Reilly & Associates,
       Link: mw-deduplicated-inline-style
       ISBN 0-596-10199-6.
     * Thomas A. Powell, Fritz Schneider: JavaScript: The Complete Reference,
       McGraw-Hill Companies,
       Link: mw-deduplicated-inline-style
       ISBN 0-07-219127-9.
     * Axel Rauschmayer: Speaking JavaScript: An In-Depth Guide for
       Programmers, 460 pages, O'Reilly Media, 25 February 2014,
       Link: mw-deduplicated-inline-style
       ISBN 978-1449365035. (free online edition)
     * Emily Vander Veer: JavaScript For Dummies, 4th Edition, Wiley,
       Link: mw-deduplicated-inline-style
       ISBN 0-7645-7659-3.

External linksEdit

   Wikibooks has a book on the topic of: JavaScript 

     * A re-introduction to JavaScript - Mozilla Developer Center
     * JavaScript Loops
     * ECMAScript standard references: ECMA-262
     * Interactive JavaScript Lessons - example-based
     * JavaScript on About.com: lessons and explanation
     * JavaScript Training
     * Mozilla Developer Center Core References for JavaScript versions 1.5,
       1.4, 1.3 and 1.2
     * Mozilla JavaScript Language Documentation
   Retrieved from
   "https://en.wikipedia.org/w/index.php?title=JavaScript_syntax&oldid=1081135200"
   Last edited on 5 April 2022, at 14:28
   Wikipedia
     * This page was last edited on 5 April 2022, at 14:28 (UTC).
     * Content is available under CC BY-SA 3.0 unless otherwise noted.
     * Privacy policy
     * About Wikipedia
     * Disclaimers
     * Contact Wikipedia
     * Terms of Use
     * Desktop
     * Developers
     * Statistics
     * Cookie statement
