JavaScript语法
JavaScript是编写该语言程序的一套规则。
JavaScript标准库缺少官方标准的文本输出函数（除了codice_1）。由于JavaScript主要用于在现代网页浏览器上执行客户端脚本，几乎所有浏览器都支持codice_2函数。下述举例中使用标准文本输出的console对象的log函数。
Brendan Eich summarized the ancestry of the syntax in the first paragraph of the JavaScript 1.1 specification as follows:
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 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.
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 "codice_3", open bracket "codice_4", slash "codice_5", plus "codice_6", and minus "codice_7". 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: a = b + c
// 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 'codice_3' or 'codice_9', 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. For example: a = b + c
// 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 codice_10, codice_11, codice_12, codice_13, 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. codice_10 and codice_11 take an optional value, while codice_12 and codice_13 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; 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
/* Comments /* may not be nested */ Syntax error */ 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 codice_18 for function scoped variables, and codice_19 or codice_20 which are for block level variables. Before ES6, variables could only be declared with a codice_18 statement. Values assigned to variables declared with codice_20 cannot be changed, but its properties can. A variable's identifier must start with a letter, underscore (codice_23), or dollar sign (codice_24), while subsequent characters can also be digits (codice_25). 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 codice_26 Unicode escape sequences) 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.
Variables declared with codice_18 are lexically scoped at a function level, while ones with codice_19 or codice_20 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. This is referred to as "", and it is equivalent to variables being forward declared at the top of the function or block.
With codice_18, codice_19, and codice_20 statements, only the declaration is hoisted; assignments are not hoisted. 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. This means that values cannot be accessed before they are declared; forward reference is not possible. With codice_18 a variable's value is codice_34 until it is initialized. Variables declared with codice_19 or codice_20 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 codice_18, codice_19, or codice_20 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 codice_19 keyword.
Variables declared outside a scope are in 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 codice_41 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. As a consequence, a variable never declared will be global, if assigned. Declaring a variable (with the keyword codice_18) 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.
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() {
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 The JavaScript language provides six primitive data types: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.
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, ... var testObj = {}; console.log(test); // test variable exists, but value not ... console.log(testObj.myProp); // testObj exists, property does not, ... 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 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(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 codice_43 raises a if is an unknown identifier, whereas doesn't.
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 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 ... There's also a numeric separator, (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 ... 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 BigInts can be used for arbitrarily large integers. Especially whole numbers larger than 2 - 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.
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. var greeting = "Hello, World!"; var anotherGreeting = 'Greetings, people of Earth.'; Individual characters within a string can be accessed using the method (provided by ). 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 ... 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 constructor creates a string object (an object wrapping a string): var greeting = new String("Hello, World!"); These objects have a 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 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.
JavaScript 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 (the complement of the previous list) evaluate as , including the strings , and any object.
Automatic type coercion by the equality comparison operators (codice_44 and codice_45) can be avoided by using the type checked comparison operators (codice_46 and codice_47).
When type conversion is required, JavaScript converts , , , or operands as follows:
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: (codice_48), or , in the case of disjunction: (codice_49); 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: (), using the function, or using the conditional operator: (codice_50). // 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 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 (without ) be used in preference to the Boolean object. 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) { } else if ([] && {} && b && typeof b === "object" && b.toString() === "false") {
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 codice_51; if something implements codice_51, 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
// for..of loops automatically iterate values for (const value of x) {
// Sets are also iterable: [Symbol.iterator] in Set.prototype; // true
for (const value of new Set(['apple', 'orange'])) {
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.
An Array is a JavaScript object prototyped from the codice_53 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, codice_54, codice_55, and codice_56).
As in the , arrays use a zero-based indexing scheme: A value that is inserted into an empty array by means of the codice_56 method occupies the 0th index of the array. var myArray = []; // Point the variable myArray to a newly ... 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 codice_58 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 codice_58 property will remove larger indices.
Elements of codice_53s 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 codice_53 literal or the codice_53 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 and only uses space for these two elements, just like any other object. The codice_58 of the array will still be reported as 58. The maximum length of an array is 4,294,967,295 which corresponds to 32-bit binary number (11111111111111111111111111111111).
One can use the object declaration literal to create objects that behave much like associative arrays in other languages: 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"}, cats[0]["size"]; // results in "large"
dogs = {rover: {color: "brown", size: "large"}, dogs["spot"]["size"]; // results in "small" dogs.rover.color; // results in "brown"
A codice_64 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 codice_64 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 codice_66: 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() + ' '
// Built-in toString returns something like 'Mon Mar 01 2010 14:25:30 GMT-0500 (EST)': console.log(d);
Custom error messages can be created using the codice_67 class: throw new Error("Something went wrong."); These can be caught by try...catch...finally blocks as described in the section on exception handling.
The object contains various math-related constants (for example, ) and functions (for example, cosine). (Note that the object has no constructor, unlike or . All its methods are "static", that is "class" methods.) All the trigonometric functions use angles expressed in radians, not degrees or grads.
/expression/.test(string); // returns Boolean "string".search(/expression/); // returns position Number "string".replace(/expression/, replacement);
// Here are some examples if (/Tom/.test("My name is Tom")) console.log("Hello Tom!"); console.log("My name is Tom".search(/Tom/)); // == 11 (letters before Tom) console.log("My name is Tom".replace(/Tom/, "John")); // == "My name is John"
// \d - digit // \D - non digit // \s - space // \S - non space // \w - word char // \W - non word // [ ] - one of // [^] - one not of // - - range
if (/\d/.test('0')) console.log('Digit'); if (/[0-9]/.test('6')) console.log('Digit'); if (/[13579]/.test('1')) console.log('Odd number'); if (/\S\S\s\S\S\S\S/.test('My name')) console.log('Format OK'); if (/\w\w\w/.test('Tom')) console.log('Hello Tom'); if (/[a-zA-Z]/.test('B')) console.log('Letter');
// A...Z a...z 0...9 - alphanumeric // \u0000...\uFFFF - Unicode hexadecimal // \x00...\xFF - ASCII hexadecimal // \t - tab // \n - new line // \r - CR // . - any character // | - OR
if (/T.m/.test('Tom')) console.log ('Hi Tom, Tam or Tim'); if (/A|B/.test("A")) console.log ('A or B');
// ? - 0 or 1 match // * - 0 or more // + - 1 or more // {n} - exactly n // {n,} - n or more // {0,n} - n or less // {n,m} - range n to m
if (/ab?c/.test("ac")) console.log("OK"); // match: "ac", "abc" if (/ab*c/.test("ac")) console.log("OK"); // match: "ac", "abc", "abbc", "abbbc" etc. if (/ab+c/.test("abc")) console.log("OK"); // match: "abc", "abbc", "abbbc" etc. if (/ab{3}c/.test("abbbc")) console.log("OK"); // match: "abbbc" if (/ab{3,}c/.test("abbbc")) console.log("OK"); // match: "abbbc", "abbbbc", "abbbbbc" etc. if (/ab{1,3}c/.test("abc")) console.log("OK"); // match: "abc", "abbc", "abbbc"
// ^ - string starts with // $ - string ends with
if (/^My/.test("My name is Tom")) console.log ("Hi!"); if (/Tom$/.test("My name is Tom")) console.log ("Hi Tom!");
// ( ) - groups characters
if (/water(mark)?/.test("watermark")) console.log("Here is water!"); // match: "water", "watermark", if (/(Tom)|(John)/.test("John")) console.log("Hi Tom or John!");
// /g - global // /i - ignore upper/lower case // /m - allow matches to span multiple lines
console.log("hi tom!".replace(/Tom/i, "John")); // == "hi John!" console.log("ratatam".replace(/ta/, "tu")); // == "ratutam" console.log("ratatam".replace(/ta/g, "tu")); // == "ratutum"
my_array = my_string.split(my_delimiter); // example my_array = "dog,cat,cow".split(","); // my_array==["dog","cat","cow"];
my_array = my_string.match(my_expression); // example my_array = "We start at 11:30, 12:15 and 16:45".match(/\d\d:\d\d/g); // my_array==["11:30","12:15","16:45"];
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) { } else console.log("Did not find a valid date!"); Every function in JavaScript is an instance of the codice_68 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) { 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 codice_69 of the global object instead of inheriting it from where it was called / what it was called on, unlike the codice_70 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) { 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) {
A function instance has properties and methods. function subtract(x, y) {
console.log(subtract.length); // => 2, arity of the function (number of arguments) console.log(subtract.toString()); "function subtract(x, y) { 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 JavaScript supports the following binary arithmetic operators:
JavaScript supports the following unary arithmetic operators:
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 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 /** 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 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 function message() {
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
The ECMAScript 2015 standard introduces the "codice_71" 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, "codice_71" transforms "codice_73" into "codice_74", and "codice_75" into "codice_76". 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) {
// 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 codice_71 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 codice_53 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) {
foo(1, 2, 3, 4, 5); // "3" → c = [3, 4, 5] foo('a', 'b'); // "0" → c = [] Rest parameters are similar to Javascript's codice_79 object, which is an array-like object that contains all of the parameters (named and unnamed) in the current function call. Unlike codice_79, however, rest parameters are true codice_53 objects, so methods such as codice_82 and codice_83 can be used on them directly.
The codice_71 operator can only be used with codice_53 objects. (However, there is a proposal to extend it to codice_86s in a future ECMAScript standard.)
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.
JavaScript provides four logical operators:
In the context of a logical operation, any expression evaluates to true except the following:
The Boolean function can be used to explicitly convert to a primitive of type codice_99: // 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 (codice_100) 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.
JavaScript supports the following binary bitwise operators:
Examples: x=11 & 6; console.log(x); // 2 JavaScript supports the following unary bitwise operator:
JavaScript supports the following binary assignment operators:
Examples: x=7; console.log(x); // 7 x«=3; console.log(x); // 7->14->28->56
Examples: str = "ab" + "cd"; // "abcd" str += "e"; // "abcde"
str2 = "2" + 2; // "22", not "4" or 4.
A pair of curly brackets codice_101 and an enclosed sequence of statements constitute a compound statement, which can be used wherever a statement can be used.
if (expr) { } else if (expr2) { } else {
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. is the same as:
Unlike the "if" statement, the conditional operator cannot omit its "else-branch".
The syntax of the JavaScript switch statement is as follows:The syntax of the JavaScript for loop is as follows: or The syntax of the JavaScript codice_103 is as follows: for (var property_name in some_object) {The syntax of the JavaScript while loop is as follows: while (condition) { The syntax of the JavaScript codice_105 is as follows: do { } while (condition); 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) {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 ), this statement is not allowed in "strict mode".
JavaScript supports nested labels in most implementations. Loops or blocks can be labelled for the break statement, and loops for codice_13. Although codice_107 is a reserved word, codice_108 is not implemented in JavaScript. loop1: for (var a = 0; a < 10; a++) { block1: { goto block1; // Parse error.
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 is returned. function gcd(segmentA, segmentB) { 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 (that can be implicitly cast to false). Within the function, the arguments may also be accessed through the object; this provides access to all arguments using indices (e.g. ), including those beyond the number of named arguments. (While the arguments list has a codice_109 property, it is "not" an instance of ; it does not have methods such as , , etc.) function add7(x, y) { 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) { 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() { foo(); baz("Fugly"); bar(); // Fugly (not fud) even though foo() has exited. console.log(v); // Top 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, which ordinary associative arrays do not have.
JavaScript has several kinds of built-in objects, namely codice_53, codice_99, codice_64, codice_68, codice_114, codice_115, codice_86, codice_117 and codice_118. 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.).
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 = {
This is the basis for JSON, which is a simple notation that uses JavaScript-like syntax for data exchange.
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 "". (There are also ' and ' methods that can set ' explicitly—some packages such as jQuery do unusual things with "".)
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 Foo(yz) {
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.
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) {
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, // 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 codice_119 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.
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
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.
Base.prototype.m = m2; bar = new Base(); console.log("bar.m " + bar.m()); // bar.m Two
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.
JavaScript includes a codice_120 exception handling statement to handle run-time errors.
The codice_120 statement catches exceptions resulting from an error or a throw statement. Its syntax is as follows: try { } catch(errorValue) { } 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: In a browser, the event is more commonly used to trap exceptions.
onerror = function (errorValue, url, lineNr) {...; return true;}; Evaluates the first parameter as an expression, which can include assignment statements. Variables local to functions can be referenced by the expression. However, represents a major security risk, as it allows a bad actor to execute arbitrary code, so its use is discouraged.
> (function foo() { ... var x = 7; ... console.log("val " + eval("x + 2")); val 9 undefined