This part of the JavaScript section on MDN serves as a repository of facts about the JavaScript language. Read more about this reference.
This chapter documents all the JavaScript standard built-in objects, along with their methods and properties.
These global properties return a simple value; they have no properties or methods.
These global functions—functions which are called globally rather than on an object—directly return their results to the caller.
eval()uneval() \nisFinite()isNaN()parseFloat()parseInt()decodeURI()decodeURIComponent()encodeURI()encodeURIComponent()escape() \nunescape() \nThese are the fundamental, basic objects upon which all other objects are based. This includes objects that represent general objects, functions, and errors.
ObjectFunctionBooleanSymbolErrorEvalErrorInternalErrorRangeErrorReferenceErrorSyntaxErrorTypeErrorURIErrorThese are the base objects representing numbers, dates, and mathematical calculations.
These objects represent strings and support manipulating them.
These objects represent collections of data which are ordered by an index value. This includes (typed) arrays and array-like constructs.
ArrayInt8ArrayUint8ArrayUint8ClampedArrayInt16ArrayUint16ArrayInt32ArrayUint32ArrayFloat32ArrayFloat64ArrayThese objects represent collections which use keys; these contain elements which are iterable in the order of insertion.
These objects represent and interact with structured data buffers and data coded using JavaScript Object Notation (JSON).
ArrayBufferSharedArrayBuffer \nAtomics \nDataViewJSONAdditions to the ECMAScript core for language-sensitive functionalities.
WebAssemblyWebAssembly.ModuleWebAssembly.InstanceWebAssembly.MemoryWebAssembly.TableWebAssembly.CompileErrorWebAssembly.LinkErrorWebAssembly.RuntimeErrorThis chapter documents all the JavaScript statements and declarations.
For an alphabetical listing see the sidebar on the left.
BlockbreakcontinueEmptyif...elseswitchthrowtry...catchvarletconstfunctionfunction*async functionreturnclassdo...whileforfor each...in\nfor...infor...offor await...ofwhiledebuggerexportimportimport.metalabelbreak or continue statement.with\nThis chapter documents all the JavaScript expressions and operators.
For an alphabetical listing see the sidebar on the left.
Basic keywords and general expressions in JavaScript.
thisthis keyword refers to a special property of an execution context.functionfunction keyword defines a function expression.classclass keyword defines a class expression.function*function* keyword defines a generator function expression.yieldyield*async functionasync function defines an async function expression.await[]{}/ab+c/i( )Left values are the destination of an assignment.
object.property and object[\"property\"]).newnew operator creates an instance of a constructor.new.target refers to the constructor that was invoked by new.supersuper keyword calls the parent constructor....objPostfix/prefix increment and postfix/prefix decrement operators.
A++A--++A--AA unary operation is operation with only one operand.
deletedelete operator deletes a property from an object.voidvoid operator discards an expression's return value.typeoftypeof operator determines the type of a given object.+-~!Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value.
+-/*%**A comparison operator compares its operands and returns a Boolean value based on whether the comparison is true.
inin operator determines whether an object has a given property.instanceofinstanceof operator determines whether an object is an instance of another object.<><=>=Note: => is not an operator, but the notation for Arrow functions.
The result of evaluating an equality operator is always of type Boolean based on whether the comparison is true.
Operations to shift all bits of the operand.
<<>>>>>Bitwise operators treat their operands as a set of 32 bits (zeros and ones) and return standard JavaScript numerical values.
Logical operators are typically used with boolean (logical) values, and when they are, they return a boolean value.
(condition ? ifTrue : ifFalse)The conditional operator returns one of two values based on the logical value of the condition.
An assignment operator assigns a value to its left operand based on the value of its right operand.
=*=/=%=+=-=<<=>>=>>>=&=^=|=[a, b] = [1, 2]{a, b} = {a:1, b:2}\nDestructuring assignment allows you to assign the properties of an array or object to variables using syntax that looks similar to array or object literals.
,function keyword can be used to define a legacy generator function inside an expression. To make the function a legacy generator, the function body should contains at least one yield expression.[for (x of y) x] Obsolete since Gecko 58\n(for (x of y) y) Obsolete since Gecko 58\nThis chapter documents how to work with JavaScript functions to develop your applications.
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference\n
JavaScript's strict mode, introduced in ECMAScript 5, is a way to opt in to a restricted variant of JavaScript, thereby implicitly opting-out of \"sloppy mode\". Strict mode isn't just a subset: it intentionally has different semantics from normal code. Browsers not supporting strict mode will run strict mode code with different behavior from browsers that do, so don't rely on strict mode without feature-testing for support for the relevant aspects of strict mode. Strict mode code and non-strict mode code can coexist, so scripts can opt into strict mode incrementally.
Strict mode makes several changes to normal JavaScript semantics:
See transitioning to strict mode, if you want to change your code to work in the restricted variant of JavaScript.
Strict mode applies to entire scripts or to individual functions. It doesn't apply to block statements enclosed in {} braces; attempting to apply it to such contexts does nothing. eval code, Function code, event handler attributes, strings passed to WindowTimers.setTimeout(), and related functions are entire scripts, and invoking strict mode in them works as expected.
To invoke strict mode for an entire script, put the exact statement \"use strict\"; (or 'use strict';) before any other statements.
// Whole-script strict mode syntax\n'use strict';\nvar v = \"Hi! I'm a strict mode script!\";\n
This syntax has a trap that has already bitten a major site: it isn't possible to blindly concatenate conflicting scripts. Consider concatenating a strict mode script with a non-strict mode script: the entire concatenation looks strict! The inverse is also true: non-strict plus strict looks non-strict. Obviously, concatentation of scripts is never ideal, but if you must, consider enabling strict on a function-by-function basis.
You can also take the approach of wrapping the entire contents of a script in a function and having that outer function use strict mode. This eliminates the concatenation problem and it means that you have to explicitly export any shared variables out of the function scope.
Likewise, to invoke strict mode for a function, put the exact statement \"use strict\"; (or 'use strict';) in the function's body before any other statements.
function strict() {\n // Function-level strict mode syntax\n 'use strict';\n function nested() { return 'And so am I!'; }\n return \"Hi! I'm a strict mode function! \" + nested();\n}\nfunction notStrict() { return \"I'm not strict.\"; }\n ECMAScript 2015 introduced JavaScript modules and therefore a 3rd way to enter strict mode. The entire contents of JavaScript modules are automatically in strict mode, with no statement needed to initiate it.
function strict() {\n // because this is a module, I'm strict by default\n}\nexport default strict;\n Strict mode changes both syntax and runtime behavior. Changes generally fall into these categories: changes converting mistakes into errors (as syntax errors or at runtime), changes simplifying how the particular variable for a given use of a name is computed, changes simplifying eval and arguments, changes making it easier to write \"secure\" JavaScript, and changes anticipating future ECMAScript evolution.
Strict mode changes some previously-accepted mistakes into errors. JavaScript was designed to be easy for novice developers, and sometimes it gives operations which should be errors non-error semantics. Sometimes this fixes the immediate problem, but sometimes this creates worse problems in the future. Strict mode treats these mistakes as errors so that they're discovered and promptly fixed.
First, strict mode makes it impossible to accidentally create global variables. In normal JavaScript mistyping a variable in an assignment creates a new property on the global object and continues to \"work\" (although future failure is possible: likely, in modern JavaScript). Assignments, which would accidentally create global variables, instead throw an error in strict mode:
'use strict';\n // Assuming a global variable mistypedVariable exists\nmistypeVariable = 17; // this line throws a ReferenceError due to the \n // misspelling of variable\n
Second, strict mode makes assignments which would otherwise silently fail to throw an exception. For example, NaN is a non-writable global variable. In normal code assigning to NaN does nothing; the developer receives no failure feedback. In strict mode assigning to NaN throws an exception. Any assignment that silently fails in normal code (assignment to a non-writable global or property, assignment to a getter-only property, assignment to a new property on a non-extensible object) will throw in strict mode:
'use strict';\n\n// Assignment to a non-writable global\nvar undefined = 5; // throws a TypeError\nvar Infinity = 5; // throws a TypeError\n\n// Assignment to a non-writable property\nvar obj1 = {};\nObject.defineProperty(obj1, 'x', { value: 42, writable: false });\nobj1.x = 9; // throws a TypeError\n\n// Assignment to a getter-only property\nvar obj2 = { get x() { return 17; } };\nobj2.x = 5; // throws a TypeError\n\n// Assignment to a new property on a non-extensible object\nvar fixed = {};\nObject.preventExtensions(fixed);\nfixed.newProp = 'ohai'; // throws a TypeError\n Third, strict mode makes attempts to delete undeletable properties throw (where before the attempt would simply have no effect):
'use strict';\ndelete Object.prototype; // throws a TypeError\n
Fourth, strict mode prior to Gecko 34 requires that all properties named in an object literal be unique. The normal code may duplicate property names, with the last one determining the property's value. But since only the last one does anything, the duplication is simply a vector for bugs, if the code is modified to change the property value other than by changing the last instance. Duplicate property names are a syntax error in strict mode:
This is no longer the case in ECMAScript 2015 (bug 1041128).
'use strict';\nvar o = { p: 1, p: 2 }; // !!! syntax error\n Fifth, strict mode requires that function parameter names be unique. In normal code the last duplicated argument hides previous identically-named arguments. Those previous arguments remain available through arguments[i], so they're not completely inaccessible. Still, this hiding makes little sense and is probably undesirable (it might hide a typo, for example), so in strict mode duplicate argument names are a syntax error:
function sum(a, a, c) { // !!! syntax error\n 'use strict';\n return a + a + c; // wrong if this code ran\n}\n Sixth, a strict mode in ECMAScript 5 forbids octal syntax. The octal syntax isn't part of ECMAScript 5, but it's supported in all browsers by prefixing the octal number with a zero: 0644 === 420 and \"\\045\" === \"%\". In ECMAScript 2015 Octal number is supported by prefixing a number with \"0o\". i.e.
var a = 0o10; // ES2015: Octal
Novice developers sometimes believe a leading zero prefix has no semantic meaning, so they use it as an alignment device — but this changes the number's meaning! A leading zero syntax for the octals is rarely useful and can be mistakenly used, so strict mode makes it a syntax error:
'use strict';\nvar sum = 015 + // !!! syntax error\n 197 +\n 142;\n\nvar sumWithOctal = 0o10 + 8;\nconsole.log(sumWithOctal); // 16\n
Seventh, strict mode in ECMAScript 2015 forbids setting properties on primitive values. Without strict mode, setting properties is simply ignored (no-op), with strict mode, however, a TypeError is thrown.
(function() {\n'use strict';\n\nfalse.true = ''; // TypeError\n(14).sailing = 'home'; // TypeError\n'with'.you = 'far away'; // TypeError\n\n})(); Strict mode simplifies how variable names map to particular variable definitions in the code. Many compiler optimizations rely on the ability to say that variable X is stored in that location: this is critical to fully optimizing JavaScript code. JavaScript sometimes makes this basic mapping of name to variable definition in the code impossible to perform until runtime. Strict mode removes most cases where this happens, so the compiler can better optimize strict mode code.
First, strict mode prohibits with. The problem with with is that any name inside the block might map either to a property of the object passed to it, or to a variable in surrounding (or even global) scope, at runtime: it's impossible to know which beforehand. Strict mode makes with a syntax error, so there's no chance for a name in a with to refer to an unknown location at runtime:
'use strict';\nvar x = 17;\nwith (obj) { // !!! syntax error\n // If this weren't strict mode, would this be var x, or\n // would it instead be obj.x? It's impossible in general\n // to say without running the code, so the name can't be\n // optimized.\n x;\n}\n The simple alternative of assigning the object to a short name variable, then accessing the corresponding property on that variable, stands ready to replace with.
Second, eval of strict mode code does not introduce new variables into the surrounding scope. In normal code eval(\"var x;\") introduces a variable x into the surrounding function or the global scope. This means that, in general, in a function containing a call to eval every name not referring to an argument or local variable must be mapped to a particular definition at runtime (because that eval might have introduced a new variable that would hide the outer variable). In strict mode eval creates variables only for the code being evaluated, so eval can't affect whether a name refers to an outer variable or some local variable:
var x = 17;\nvar evalX = eval(\"'use strict'; var x = 42; x;\");\nconsole.assert(x === 17);\nconsole.assert(evalX === 42);\n
If the function eval is invoked by an expression of the form eval(...) in strict mode code, the code will be evaluated as strict mode code. The code may explicitly invoke strict mode, but it's unnecessary to do so.
function strict1(str) {\n 'use strict';\n return eval(str); // str will be treated as strict mode code\n}\nfunction strict2(f, str) {\n 'use strict';\n return f(str); // not eval(...): str is strict if and only\n // if it invokes strict mode\n}\nfunction nonstrict(str) {\n return eval(str); // str is strict if and only \n // if it invokes strict mode\n}\n\nstrict1(\"'Strict mode code!'\");\nstrict1(\"'use strict'; 'Strict mode code!'\");\nstrict2(eval, \"'Non-strict code.'\");\nstrict2(eval, \"'use strict'; 'Strict mode code!'\");\nnonstrict(\"'Non-strict code.'\");\nnonstrict(\"'use strict'; 'Strict mode code!'\");\n Thus names in strict mode eval code behave identically to names in strict mode code not being evaluated as the result of eval.
Third, strict mode forbids deleting plain names. delete name in strict mode is a syntax error:
'use strict';\n\nvar x;\ndelete x; // !!! syntax error\n\neval('var y; delete y;'); // !!! syntax error eval and arguments simplerStrict mode makes arguments and eval less bizarrely magical. Both involve a considerable amount of magical behavior in normal code: eval to add or remove bindings and to change binding values, and arguments by its indexed properties aliasing named arguments. Strict mode makes great strides toward treating eval and arguments as keywords, although full fixes will not come until a future edition of ECMAScript.
First, the names eval and arguments can't be bound or assigned in language syntax. All these attempts to do so are syntax errors:
'use strict';\neval = 17;\narguments++;\n++eval;\nvar obj = { set p(arguments) { } };\nvar eval;\ntry { } catch (arguments) { }\nfunction x(eval) { }\nfunction arguments() { }\nvar y = function eval() { };\nvar f = new Function('arguments', \"'use strict'; return 17;\");\n Second, strict mode code doesn't alias properties of arguments objects created within it. In normal code within a function whose first argument is arg, setting arg also sets arguments[0], and vice versa (unless no arguments were provided or arguments[0] is deleted). arguments objects for strict mode functions store the original arguments when the function was invoked. arguments[i] does not track the value of the corresponding named argument, nor does a named argument track the value in the corresponding arguments[i].
function f(a) {\n 'use strict';\n a = 42;\n return [a, arguments[0]];\n}\nvar pair = f(17);\nconsole.assert(pair[0] === 42);\nconsole.assert(pair[1] === 17);\n Third, arguments.callee is no longer supported. In normal code arguments.callee refers to the enclosing function. This use case is weak: simply name the enclosing function! Moreover, arguments.callee substantially hinders optimizations like inlining functions, because it must be made possible to provide a reference to the un-inlined function if arguments.callee is accessed. arguments.callee for strict mode functions is a non-deletable property which throws an error when set or retrieved:
'use strict';\nvar f = function() { return arguments.callee; };\nf(); // throws a TypeError\n Strict mode makes it easier to write \"secure\" JavaScript. Some websites now provide ways for users to write JavaScript which will be run by the website on behalf of other users. JavaScript in browsers can access the user's private information, so such JavaScript must be partially transformed before it is run, to censor access to forbidden functionality. JavaScript's flexibility makes it effectively impossible to do this without many runtime checks. Certain language functions are so pervasive that performing runtime checks has a considerable performance cost. A few strict mode tweaks, plus requiring that user-submitted JavaScript be strict mode code and that it be invoked in a certain manner, substantially reduce the need for those runtime checks.
First, the value passed as this to a function in strict mode is not forced into being an object (a.k.a. \"boxed\"). For a normal function, this is always an object: either the provided object if called with an object-valued this; the value, boxed, if called with a Boolean, string, or number this; or the global object if called with an undefined or null this. (Use call, apply, or bind to specify a particular this.) Not only is automatic boxing a performance cost, but exposing the global object in browsers is a security hazard because the global object provides access to functionality that \"secure\" JavaScript environments must restrict. Thus for a strict mode function, the specified this is not boxed into an object, and if unspecified, this will be undefined:
'use strict';\nfunction fun() { return this; }\nconsole.assert(fun() === undefined);\nconsole.assert(fun.call(2) === 2);\nconsole.assert(fun.apply(null) === null);\nconsole.assert(fun.call(undefined) === undefined);\nconsole.assert(fun.bind(true)() === true);\n That means, among other things, that in browsers it's no longer possible to reference the window object through this inside a strict mode function.
Second, in strict mode it's no longer possible to \"walk\" the JavaScript stack via commonly-implemented extensions to ECMAScript. In normal code with these extensions, when a function fun is in the middle of being called, fun.caller is the function that most recently called fun, and fun.arguments is the arguments for that invocation of fun. Both extensions are problematic for \"secure\" JavaScript because they allow \"secured\" code to access \"privileged\" functions and their (potentially unsecured) arguments. If fun is in strict mode, both fun.caller and fun.arguments are non-deletable properties which throw when set or retrieved:
function restricted() {\n 'use strict';\n restricted.caller; // throws a TypeError\n restricted.arguments; // throws a TypeError\n}\nfunction privilegedInvoker() {\n return restricted();\n}\nprivilegedInvoker();\n Third, arguments for strict mode functions no longer provide access to the corresponding function call's variables. In some old ECMAScript implementations arguments.caller was an object whose properties aliased variables in that function. This is a security hazard because it breaks the ability to hide privileged values via function abstraction; it also precludes most optimizations. For these reasons no recent browsers implement it. Yet because of its historical functionality, arguments.caller for a strict mode function is also a non-deletable property which throws when set or retrieved:
'use strict';\nfunction fun(a, b) {\n 'use strict';\n var v = 12;\n return arguments.caller; // throws a TypeError\n}\nfun(1, 2); // doesn't expose v (or a or b)\n Future ECMAScript versions will likely introduce new syntax, and strict mode in ECMAScript 5 applies some restrictions to ease the transition. It will be easier to make some changes if the foundations of those changes are prohibited in strict mode.
First, in strict mode, a short list of identifiers become reserved keywords. These words are implements, interface, let, package, private, protected, public, static, and yield. In strict mode, then, you can't name or use variables or arguments with these names.
function package(protected) { // !!!\n 'use strict';\n var implements; // !!!\n\n interface: // !!!\n while (true) {\n break interface; // !!!\n }\n\n function private() { } // !!!\n}\nfunction fun(static) { 'use strict'; } // !!!\n\n Two Mozilla-specific caveats: First, if your code is JavaScript 1.7 or greater (for example in chrome code or when using the right <script type=\"\">) and is strict mode code, let and yield have the functionality they've had since those keywords were first introduced. But strict mode code on the web, loaded with <script src=\"\"> or <script>...</script>, won't be able to use let/yield as identifiers. Second, while ES5 unconditionally reserves the words class, enum, export, extends, import, and super, before Firefox 5 Mozilla reserved them only in strict mode.
Second, strict mode prohibits function statements, not at the top level of a script or function. In normal mode in browsers, function statements are permitted \"everywhere\". This is not part of ES5 (or even ES3)! It's an extension with incompatible semantics in different browsers. Note that function statements outside top level are permitted in ES2015.
'use strict';\nif (true) {\n function f() { } // !!! syntax error\n f();\n}\n\nfor (var i = 0; i < 5; i++) {\n function f2() { } // !!! syntax error\n f2();\n}\n\nfunction baz() { // kosher\n function eit() { } // also kosher\n}\n This prohibition isn't strict mode proper because such function statements are an extension of basic ES5. But it is the recommendation of the ECMAScript committee, and browsers will implement it.
The major browsers now implement strict mode. However, don't blindly depend on it since there still are numerous Browser versions used in the wild that only have partial support for strict mode or do not support it at all (e.g. Internet Explorer below version 10!). Strict mode changes semantics. Relying on those changes will cause mistakes and errors in browsers which don't implement strict mode. Exercise caution in using strict mode, and back up reliance on strict mode with feature tests that check whether relevant parts of strict mode are implemented. Finally, make sure to test your code in browsers that do and don't support strict mode. If you test only in browsers that don't support strict mode, you're very likely to have problems in browsers that do, and vice versa.
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode\n
The EvalError object indicates an error regarding the global eval() function. This exception is not thrown by JavaScript anymore, however the EvalError object remains for compatibility.
new EvalError([message[, fileName[, lineNumber]]])
messagefileName \nlineNumber \nEvalError.prototypeEvalError object.The global EvalError contains no methods of its own, however, it does inherit some methods through the prototype chain.
EvalError.prototype.constructorEvalError.prototype.messageEvalError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.EvalError.prototype.nameError.EvalError.prototype.fileNameError.EvalError.prototype.lineNumberError.EvalError.prototype.columnNumberError.EvalError.prototype.stackError.Although the EvalError prototype object does not contain any methods of its own, EvalError instances do inherit some methods through the prototype chain.
EvalError is not used in the current ECMAScript specification and will thus not be thrown by the runtime. However, the object itself remains for backwards compatibility with earlier versions of the specification.
try {\n throw new EvalError('Hello', 'someFile.js', 10);\n} catch (e) {\n console.log(e instanceof EvalError); // true\n console.log(e.message); // \"Hello\"\n console.log(e.name); // \"EvalError\"\n console.log(e.fileName); // \"someFile.js\"\n console.log(e.lineNumber); // 10\n console.log(e.columnNumber); // 0\n console.log(e.stack); // \"@Scratchpad/2:2:9\\n\"\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'EvalError' in that specification. | Standard | Not used in this specification. Present for backward compatibility. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'EvalError' in that specification. | Standard | Not used in this specification. Present for backward compatibility. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'EvalError' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError\n
The GeneratorFunction creates a new generator function object. In JavaScript every generator function is actually a GeneratorFunction object.
Note that GeneratorFunction is not a global object. It could be obtained by evaluating the following code.
Object.getPrototypeOf(function*(){}).constructor\n new GeneratorFunction ([arg1[, arg2[, ...argN]],] functionBody)
arg1, arg2, ... argNx\", \"theValue\", or \"a,b\".functionBodygenerator function objects created with the GeneratorFunction constructor are parsed when the function is created. This is less efficient than declaring a generator function with a function* expression and calling it within your code, because such functions are parsed with the rest of the code.
All arguments passed to the function are treated as the names of the identifiers of the parameters in the function to be created, in the order in which they are passed.
Note: generator function created with the GeneratorFunction constructor do not create closures to their creation contexts; they always are created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the GeneratorFunction constructor was called. This is different from using eval with code for a generator function expression.
Invoking the GeneratorFunction constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.
GeneratorFunction.lengthGeneratorFunction constructor's length property whose value is 1.GeneratorFunction.prototypeGeneratorFunction prototype objectGeneratorFunction.constructorGeneratorFunction.GeneratorFunction.prototype.prototype%GeneratorPrototype%.GeneratorFunction instancesGeneratorFunction instances inherit methods and properties from GeneratorFunction.prototype. As with all constructors, you can change the constructor's prototype object to make changes to all GeneratorFunction instances.
GeneratorFunction constructorvar GeneratorFunction = Object.getPrototypeOf(function*(){}).constructor\nvar g = new GeneratorFunction('a', 'yield a * 2');\nvar iterator = g(10);\nconsole.log(iterator.next().value); // 20\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'GeneratorFunction' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'GeneratorFunction' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n26 | \nNo | \nYes | \n? | \n
prototype | \nYes | \nYes | \n26 | \nNo | \nYes | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n? | \n26 | \n? | \n? | \nYes | \n
prototype | \nYes | \nYes | \n? | \n26 | \n? | \n? | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
prototype | \n? | \n
function* functionfunction* expressionFunctionfunction statementfunction expression\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/GeneratorFunction\n
The AsyncFunction creates a new async function object. In JavaScript every asynchronous function is actually an AsyncFunction object.
Note that AsyncFunction is not a global object. It could be obtained by evaluating the following code.
Object.getPrototypeOf(async function(){}).constructor\n new AsyncFunction([arg1[, arg2[, ...argN]],] functionBody)
arg1, arg2, ... argNx\", \"theValue\", or \"a,b\".functionBodyasync function objects created with the AsyncFunction constructor are parsed when the function is created. This is less efficient than declaring an async function with an async function expression and calling it within your code, because such functions are parsed with the rest of the code.
All arguments passed to the function are treated as the names of the identifiers of the parameters in the function to be created, in the order in which they are passed.
Note: async functions created with the AsyncFunction constructor do not create closures to their creation contexts; they are always created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the AsyncFunction constructor was called. This is different from using eval with code for an async function expression.
Invoking the AsyncFunction constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.
AsyncFunction.lengthAsyncFunction constructor's length property whose value is 1.AsyncFunction.prototypeAsyncFunction prototype objectAsyncFunction.constructorAsyncFunction.AsyncFunction.prototype[@@toStringTag]AsyncFunction instancesAsyncFunction instances inherit methods and properties from AsyncFunction.prototype. As with all constructors, you can change the constructor's prototype object to make changes to all AsyncFunction instances.
AsyncFunction constructorfunction resolveAfter2Seconds(x) {\n return new Promise(resolve => {\n setTimeout(() => {\n resolve(x);\n }, 2000);\n });\n}\n\nvar AsyncFunction = Object.getPrototypeOf(async function(){}).constructor\n\nvar a = new AsyncFunction('a', \n 'b', \n 'return await resolveAfter2Seconds(a) + await resolveAfter2Seconds(b);');\n\na(10, 20).then(v => {\n console.log(v); // prints 30 after 4 seconds\n});\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'AsyncFunction object' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n55 | \n? | \n52 | \nNo | \n42 | \n? | \n
prototype | \n55 | \n? | \n52 | \nNo | \n42 | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n55 | \n55 | \n? | \n52 | \n42 | \n? | \n6.0 | \n
prototype | \n? | \n55 | \n? | \n52 | \n42 | \n? | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 7.6.0\n
| \n
prototype | \n 7.6.0\n
| \n
async function functionasync function expressionFunctionfunction statementfunction expression\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction\n
The Intl.NumberFormat object is a constructor for objects that enable language sensitive number formatting.
new Intl.NumberFormat([locales[, options]])\nIntl.NumberFormat.call(this[, locales[, options]])\n
localesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page. The following Unicode extension key is allowed:
nu\"arab\", \"arabext\", \"bali\", \"beng\", \"deva\", \"fullwide\", \"gujr\", \"guru\", \"hanidec\", \"khmr\", \"knda\", \"laoo\", \"latn\", \"limb\", \"mlym\", \"mong\", \"mymr\", \"orya\", \"tamldec\", \"telu\", \"thai\", \"tibt\".optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.style\"decimal\" for plain number formatting, \"currency\" for currency formatting, and \"percent\" for percent formatting; the default is \"decimal\".currency\"USD\" for the US dollar, \"EUR\" for the euro, or \"CNY\" for the Chinese RMB — see the Current currency & funds code list. There is no default value; if the style is \"currency\", the currency property must be provided.currencyDisplay\"symbol\" to use a localized currency symbol such as €, \"code\" to use the ISO currency code, \"name\" to use a localized currency name such as \"dollar\"; the default is \"symbol\".useGroupingtrue and false; the default is true.The following properties fall into two groups: minimumIntegerDigits, minimumFractionDigits, and maximumFractionDigits in one group, minimumSignificantDigits and maximumSignificantDigits in the other. If at least one property from the second group is defined, then the first group is ignored.
minimumIntegerDigitsminimumFractionDigitsmaximumFractionDigitsminimumFractionDigits and 3; the default for currency formatting is the larger of minimumFractionDigits and the number of minor unit digits provided by the ISO 4217 currency code list (2 if the list doesn't provide that information); the default for percent formatting is the larger of minimumFractionDigits and 0.minimumSignificantDigitsmaximumSignificantDigitsIntl.NumberFormat.prototypeIntl.NumberFormat.supportedLocalesOf()NumberFormat instancesNumberFormat instances inherit the following properties from their prototype:
Intl.NumberFormat.prototype.constructorIntl.NumberFormat.Intl.NumberFormat.prototype.formatNumberFormat object.NumberFormat instances inherit the following methods from their prototype:
Intl.NumberFormat.prototype.formatToParts()Array of objects representing the number string in parts that can be used for custom locale-aware formatting.Intl.NumberFormat.prototype.resolvedOptions()In basic use without specifying a locale, a formatted string in the default locale and with default options is returned.
var number = 3500;\n\nconsole.log(new Intl.NumberFormat().format(number));\n// → '3,500' if in US English locale\n
locales\nThis example shows some of the variations in localized number formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:
var number = 123456.789;\n\n// German uses comma as decimal separator and period for thousands\nconsole.log(new Intl.NumberFormat('de-DE').format(number));\n// → 123.456,789\n\n// Arabic in most Arabic speaking countries uses real Arabic digits\nconsole.log(new Intl.NumberFormat('ar-EG').format(number));\n// → ١٢٣٤٥٦٫٧٨٩\n\n// India uses thousands/lakh/crore separators\nconsole.log(new Intl.NumberFormat('en-IN').format(number));\n// → 1,23,456.789\n\n// the nu extension key requests a numbering system, e.g. Chinese decimal\nconsole.log(new Intl.NumberFormat('zh-Hans-CN-u-nu-hanidec').format(number));\n// → 一二三,四五六.七八九\n\n// when requesting a language that may not be supported, such as\n// Balinese, include a fallback language, in this case Indonesian\nconsole.log(new Intl.NumberFormat(['ban', 'id']).format(number));\n// → 123.456,789\n options\nThe results can be customized using the options argument:
var number = 123456.789;\n\n// request a currency format\nconsole.log(new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(number));\n// → 123.456,79 €\n\n// the Japanese yen doesn't use a minor unit\nconsole.log(new Intl.NumberFormat('ja-JP', { style: 'currency', currency: 'JPY' }).format(number));\n// → ￥123,457\n\n// limit to three significant digits\nconsole.log(new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).format(number));\n// → 1,23,000\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
prototype | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
format | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
\nformatToParts \n | \n 63\n
| \n? | \n58 | \n? | \n? | \n? | \n
resolvedOptions | \n24 | \n12 | \n29 | \n11 | \n15 | \n10 | \n
supportedLocalesOf | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4.4 | \n26 | \nYes | \n56 | \n37 | \n10 | \nYes | \n
prototype | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
format | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
\nformatToParts \n | \nNo | \n 63\n
| \n? | \n? | \n? | \n? | \nNo | \n
resolvedOptions | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
supportedLocalesOf | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
prototype | \n? | \n
format | \n? | \n
\nformatToParts \n | \n? | \n
resolvedOptions | \n? | \n
supportedLocalesOf | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat\n
The JSON object contains methods for parsing JavaScript Object Notation (JSON) and converting values to JSON. It can't be called or constructed, and aside from its two method properties, it has no interesting functionality of its own.
JSON is a syntax for serializing objects, arrays, numbers, strings, booleans, and null. It is based upon JavaScript syntax but is distinct from it: some JavaScript is not JSON.
Objects and Arrays: Property names must be double-quoted strings; trailing commas are forbidden.
Numbers: Leading zeros are prohibited (in JSON.stringify zeros will be ignored, but in JSON.parse it will throw SyntaxError); a decimal point must be followed by at least one digit.
Any JSON text is a valid JavaScript expression – but only in JavaScript engines that have implemented the proposal to make all JSON text valid ECMA-262. In engines that haven't implemented the proposal, U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR are allowed in string literals and property keys in JSON; but their use in these features in JavaScript literals is a SyntaxError.
Consider this example where JSON.parse() parses the string as JSON and eval executes the string as JavaScript:
var code = '\"\\u2028\\u2029\"';\nJSON.parse(code); // evaluates to \"\\u2028\\u2029\" in all engines\neval(code); // throws a SyntaxError in old engines\n
The full JSON syntax is as follows:
JSON = null\n or true or false\n or JSONNumber\n or JSONString\n or JSONObject\n or JSONArray\n\nJSONNumber = - PositiveNumber\n or PositiveNumber\nPositiveNumber = DecimalNumber\n or DecimalNumber . Digits\n or DecimalNumber . Digits ExponentPart\n or DecimalNumber ExponentPart\nDecimalNumber = 0\n or OneToNine Digits\nExponentPart = e Exponent\n or E Exponent\nExponent = Digits\n or + Digits\n or - Digits\nDigits = Digit\n or Digits Digit\nDigit = 0 through 9\nOneToNine = 1 through 9\n\nJSONString = \"\"\n or \" StringCharacters \"\nStringCharacters = StringCharacter\n or StringCharacters StringCharacter\nStringCharacter = any character\n except \" or \\ or U+0000 through U+001F\n or EscapeSequence\nEscapeSequence = \\\" or \\/ or \\\\ or \\b or \\f or \\n or \\r or \\t\n or \\u HexDigit HexDigit HexDigit HexDigit\nHexDigit = 0 through 9\n or A through F\n or a through f\n\nJSONObject = { }\n or { Members }\nMembers = JSONString : JSON\n or Members , JSONString : JSON\n\nJSONArray = [ ]\n or [ ArrayElements ]\nArrayElements = JSON\n or ArrayElements , JSON\n Insignificant whitespace may be present anywhere except within a JSONNumber (numbers must contain no whitespace) or JSONString (where it is interpreted as the corresponding character in the string, or would cause an error). The tab character (U+0009), carriage return (U+000D), line feed (U+000A), and space (U+0020) characters are the only valid whitespace characters.
JSON.parse()JSON.stringify()| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'JSON' in that specification. | Standard | Initial definition. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'JSON' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'JSON' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n3.5 | \n8 | \n10.5 | \n4 | \n
parse | \nYes | \nYes | \n3.5 | \n8 | \n10.5 | \n4 | \n
stringify | \nYes | \nYes | \n3.5 | \n8 | \n10.5 | \n4 | \n
| JavaScript is a superset of JSON | \n66 | \nNo | \n62 | \nNo | \n53 | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
parse | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
stringify | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| JavaScript is a superset of JSON | \n66 | \n66 | \nNo | \n62 | \n53 | \nYes | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
parse | \nYes | \n
stringify | \nYes | \n
| JavaScript is a superset of JSON | \n10.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON\n
The Generator object is returned by a generator function and it conforms to both the iterable protocol and the iterator protocol.
function* gen() { \n yield 1;\n yield 2;\n yield 3;\n}\n\nvar g = gen(); // \"Generator { }\" Generator.prototype.next()yield expression.Generator.prototype.return()Generator.prototype.throw()function* idMaker() {\n var index = 0;\n while(true)\n yield index++;\n}\n\nvar gen = idMaker(); // \"Generator { }\"\n\nconsole.log(gen.next().value); // 0\nconsole.log(gen.next().value); // 1\nconsole.log(gen.next().value); // 2\n// ... Firefox (SpiderMonkey) also implemented an earlier version of generators in JavaScript 1.7, where the star (*) in the function declaration was not necessary (you just use the yield keyword in the function body). However, legacy generators support has been removed since Firefox 58 (released on January 23, 2018) (bug 1083482).
Generator.prototype.next() \nyield expression. This corresponds to next() in the ES2015 generator object.Generator.prototype.close() \nnext() an StopIteration error will be thrown. This corresponds to the return() method in the ES2015 generator object.Generator.prototype.send() \nyield expression, and returns a value yielded by the next yield expression. send(x) corresponds to next(x) in the ES2015 generator object.Generator.prototype.throw() \nthrow() method in the ES2015 generator object.function fibonacci() {\n var a = yield 1;\n yield a * 2;\n}\n\nvar it = fibonacci();\nconsole.log(it); // \"Generator { }\"\nconsole.log(it.next()); // 1\nconsole.log(it.send(10)); // 20\nconsole.log(it.close()); // undefined\nconsole.log(it.next()); // throws StopIteration (as the generator is now closed)\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Generator objects' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Generator objects' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n39 | \n13 | \n26 | \nNo | \nYes | \n10 | \n
next | \n39 | \n13 | \n26 | \nNo | \nYes | \n10 | \n
return | \n50 | \n13 | \n38 | \nNo | \n37 | \n10 | \n
throw | \n39 | \n13 | \n26 | \nNo | \nYes | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n13 | \n26 | \nYes | \n10 | \nYes | \n
next | \nYes | \nYes | \n13 | \n26 | \nYes | \n10 | \nYes | \n
return | \n? | \n50 | \n13 | \n38 | \nYes | \n10 | \n5.0 | \n
throw | \nYes | \nYes | \n13 | \n26 | \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
next | \nYes | \n
return | \n6.0.0 | \n
throw | \n 4.0.0\n
| \n
StopIterationfunctionfunction expressionFunctionfunction*function* expressionGeneratorFunction\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator\n
The Boolean object is an object wrapper for a boolean value.
new Boolean([value])
valueBoolean object.The value passed as the first parameter is converted to a boolean value, if necessary. If the value is omitted or is 0, -0, null, false, NaN, undefined, or the empty string (\"\"), the object has an initial value of false. All other values, including any object or the string \"false\", create an object with an initial value of true.
Do not confuse the primitive Boolean values true and false with the true and false values of the Boolean object.
Any object of which the value is not undefined or null, including a Boolean object whose value is false, evaluates to true when passed to a conditional statement. For example, the condition in the following if statement evaluates to true:
var x = new Boolean(false);\nif (x) {\n // this code is executed\n}\n This behavior does not apply to Boolean primitives. For example, the condition in the following if statement evaluates to false:
var x = false;\nif (x) {\n // this code is not executed\n}\n Do not use a Boolean object to convert a non-boolean value to a boolean value. Instead, use Boolean as a function to perform this task:
var x = Boolean(expression); // preferred\nvar x = new Boolean(expression); // don't use\n
If you specify any object, including a Boolean object whose value is false, as the initial value of a Boolean object, the new Boolean object has a value of true.
var myFalse = new Boolean(false); // initial value of false\nvar g = Boolean(myFalse); // initial value of true\nvar myString = new String('Hello'); // string object\nvar s = Boolean(myString); // initial value of true\n Do not use a Boolean object in place of a Boolean primitive.
Note: When the non-standard property document.all is used as an argument for this constructor, the result is a Boolean object with the value false. This property is legacy and non-standard and should not be used.
Boolean.lengthBoolean.prototypeBoolean constructor.While the global Boolean object contains no methods of its own, it does inherit some methods through the prototype chain:
Boolean instancesAll Boolean instances inherit from Boolean.prototype. As with all constructors, the prototype object dictates instances' inherited properties and methods.
Boolean.prototype.constructorBoolean function by default.Boolean.prototype.toSource() \nBoolean object; you can use this string to create an equivalent object. Overrides the Object.prototype.toSource() method.Boolean.prototype.toString()\"true\" or \"false\" depending upon the value of the object. Overrides the Object.prototype.toString() method.Boolean.prototype.valueOf()Boolean object. Overrides the Object.prototype.valueOf() method.Boolean objects with an initial value of false\nvar bNoParam = new Boolean();\nvar bZero = new Boolean(0);\nvar bNull = new Boolean(null);\nvar bEmptyString = new Boolean('');\nvar bfalse = new Boolean(false);\n Boolean objects with an initial value of true\nvar btrue = new Boolean(true);\nvar btrueString = new Boolean('true');\nvar bfalseString = new Boolean('false');\nvar bSuLin = new Boolean('Su Lin');\nvar bArrayProto = new Boolean([]);\nvar bObjProto = new Boolean({});\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Boolean' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Boolean' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Boolean' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
valueOf | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
valueOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
prototype | \nYes | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
valueOf | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean\n
The Intl object is the namespace for the ECMAScript Internationalization API, which provides language sensitive string comparison, number formatting, and date and time formatting. The constructors for Collator, NumberFormat, and DateTimeFormat objects are properties of the Intl object. This page documents these properties as well as functionality common to the internationalization constructors and other language sensitive functions.
Intl.CollatorIntl.DateTimeFormatIntl.NumberFormatIntl.PluralRulesIntl.getCanonicalLocales()The internationalization constructors as well as several language sensitive methods of other constructors (listed under See also) use a common pattern for identifying locales and determing the one they will actually use: they all accept locales and options arguments, and negotiate the requested locale(s) against the locales they support using an algorithm specified in the options.localeMatcher property.
locales argumentThe locales argument must be either a string holding a BCP 47 language tag, or an array of such language tags. If the locales argument is not provided or is undefined, the runtime's default locale is used.
A BCP 47 language tag defines a language and minimally contains a primary language code. In its most common form it can contain, in order: a language code, a script code, and a country or region code, all separated by hyphens. While the tag is not case sensitive, it is recommended to use title case for script code, upper case for country and region codes and lower case for everything else.
Examples:
\"hi\": Hindi (primary language).\"de-AT\": German as used in Austria (primary language with country code).\"zh-Hans-CN\": Chinese written in simplified characters as used in China (primary language with script and country codes).The subtags identifying languages, scripts, countries (regions), and (rarely used) variants in BCP 47 language tags can be found in the IANA Language Subtag Registry.
BCP 47 also allows for extensions. JavaScript internationalization functions use the \"u\" (Unicode) extension, which can be used to request additional customization of Collator, NumberFormat, or DateTimeFormat objects. Examples:
\"de-DE-u-co-phonebk\": Use the phonebook variant of the German sort order, which expands umlauted vowels to character pairs: ä → ae, ö → oe, ü → ue.\"th-TH-u-nu-thai\": Use Thai digits (๐, ๑, ๒, ๓, ๔, ๕, ๖, ๗, ๘, ๙) in number formatting.\"ja-JP-u-ca-japanese\": Use the Japanese calendar in date and time formatting, so that 2013 is expressed as the year 25 of the Heisei period, or 平成25.\"en-GB-u-ca-islamic\": use British English with the Islamic (Hijri) calendar, where the Gregorian date 14 October, 2017 is the Hijri date 24 Muharram, 1439.The locales argument, after stripping off all Unicode extensions, is interpreted as a prioritized request from the application. The runtime compares it against the locales it has available and picks the best one available. Two matching algorithms exist: the \"lookup\" matcher follows the Lookup algorithm specified in BCP 47; the \"best fit\" matcher lets the runtime provide a locale that's at least, but possibly more, suited for the request than the result of the Lookup algorithm. If the application doesn't provide a locales argument, or the runtime doesn't have a locale that matches the request, then the runtime's default locale is used. The matcher can be selected using a property of the options argument (see below).
If the selected language tag had a Unicode extension substring, that extension is now used to customize the constructed object or the behavior of the function. Each constructor or function supports only a subset of the keys defined for the Unicode extension, and the supported values often depend on the language tag. For example, the \"co\" key (collation) is only supported by Collator, and its \"phonebk\" value is only supported for German.
options argumentThe options argument must be an object with properties that vary between constructors and functions. If the options argument is not provided or is undefined, default values are used for all properties.
One property is supported by all language sensitive constructors and functions: The localeMatcher property, whose value must be a string \"lookup\" or \"best fit\" and which selects one of the locale matching algorithms described above.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Internationalization API 1.0 (ECMA-402) The definition of 'Intl' in that specification. | Standard | Initial definition. |
| ECMAScript Internationalization API 2.0 (ECMA-402) The definition of 'Intl' in that specification. | Standard | |
| ECMAScript Internationalization API 4.0 (ECMA-402) The definition of 'Intl' in that specification. | Draft | Added Intl.getCanonicalLocales in the 4th edition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
getCanonicalLocales | \n54 | \n16 | \n48 | \nNo | \nNo | \n11 | \n
Collator | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
DateTimeFormat | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
NumberFormat | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
PluralRules | \n63 | \nYes | \n58 | \nNo | \n50 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
getCanonicalLocales | \nNo | \nNo | \nNo | \n56 | \nNo | \n11 | \nNo | \n
Collator | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
DateTimeFormat | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
NumberFormat | \n4.4 | \n26 | \nYes | \n56 | \n37 | \n10 | \nYes | \n
PluralRules | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
getCanonicalLocales | \nNo | \n
Collator | \n? | \n
DateTimeFormat | \n? | \n
NumberFormat | \n? | \n
PluralRules | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl\n
The Float32Array typed array represents an array of 32-bit floating point numbers (corresponding to the C float data type) in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).
new Float32Array(); // new in ES2017\nnew Float32Array(length);\nnew Float32Array(typedArray);\nnew Float32Array(object);\nnew Float32Array(buffer [, byteOffset [, length]]);
For more information about the constructor syntax and the parameters, see TypedArray.
Float32Array.BYTES_PER_ELEMENT4 in the case of an Float32Array.Float32Array.prototype.length.Float32Array.nameFloat32Array type: \"Float32Array\".Float32Array.prototypeFloat32Array.from()Float32Array from an array-like or iterable object. See also Array.from().Float32Array.of()Float32Array with a variable number of arguments. See also Array.of().Float32Array prototypeAll Float32Array objects inherit from %TypedArray%.prototype.
Float32Array.prototype.constructorFloat32Array constructor by default.Float32Array.prototype.buffer Read only \nArrayBuffer referenced by the Float32Array Fixed at construction time and thus read only.Float32Array.prototype.byteLength Read only \nFloat32Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nFloat32Array.prototype.byteOffset Read only \nFloat32Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nFloat32Array.prototype.length Read only \nFloat32Array. Fixed at construction time and thus read only.\nFloat32Array.prototype.copyWithin()Array.prototype.copyWithin().Float32Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().Float32Array.prototype.every()Array.prototype.every().Float32Array.prototype.fill()Array.prototype.fill().Float32Array.prototype.filter()Array.prototype.filter().Float32Array.prototype.find()undefined if not found. See also Array.prototype.find().Float32Array.prototype.findIndex()Array.prototype.findIndex().Float32Array.prototype.forEach()Array.prototype.forEach().Float32Array.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().Float32Array.prototype.indexOf()Array.prototype.indexOf().Float32Array.prototype.join()Array.prototype.join().Float32Array.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().Float32Array.prototype.lastIndexOf()Array.prototype.lastIndexOf().Float32Array.prototype.map()Array.prototype.map().Float32Array.prototype.move() Unimplemented\nFloat32Array.prototype.copyWithin().Float32Array.prototype.reduce()Array.prototype.reduce().Float32Array.prototype.reduceRight()Array.prototype.reduceRight().Float32Array.prototype.reverse()Array.prototype.reverse().Float32Array.prototype.set()Float32Array.prototype.slice()Array.prototype.slice().Float32Array.prototype.some()Array.prototype.some().Float32Array.prototype.sort()Array.prototype.sort().Float32Array.prototype.subarray()Float32Array from the given start and end element index.Float32Array.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().Float32Array.prototype.toLocaleString()Array.prototype.toLocaleString().Float32Array.prototype.toString()Array.prototype.toString().Float32Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Different ways to create a Float32Array:
// From a length\nvar float32 = new Float32Array(2);\nfloat32[0] = 42;\nconsole.log(float32[0]); // 42\nconsole.log(float32.length); // 2\nconsole.log(float32.BYTES_PER_ELEMENT); // 4\n\n// From an array\nvar arr = new Float32Array([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Float32Array([21, 31]);\nvar y = new Float32Array(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(16);\nvar z = new Float32Array(buffer, 0, 4);\n\n// From an iterable \nvar iterable = function*(){ yield* [1,2,3]; }(); \nvar float32 = new Float32Array(iterable); \n// Float32Array[1, 2, 3]\n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray constructors' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray constructors' in that specification. | Draft | ECMAScript 2017 changed the Float32Array constructor to use the ToIndex operation and allows constructors with no arguments. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nFloat32Array() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nFloat32Array() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\nFloat32Array() without new throws | \n0.12 | \n
| Iterable in constructor | \n4.0.0 | \n
| Constructor without arguments | \n? | \n
Starting with ECMAScript 2015, Float32Array constructors require to be constructed with a new operator. Calling a Float32Array constructor as a function without new, will throw a TypeError from now on.
var dv = Float32Array([1, 2, 3]);\n// TypeError: calling a builtin Float32Array constructor\n// without new is forbidden
var dv = new Float32Array([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array\n
The ArrayBuffer object is used to represent a generic, fixed-length raw binary data buffer. You cannot directly manipulate the contents of an ArrayBuffer; instead, you create one of the typed array objects or a DataView object which represents the buffer in a specific format, and use that to read and write the contents of the buffer.
new ArrayBuffer(length)\n
lengthA new ArrayBuffer object of the specified size. Its contents are initialized to 0.
A RangeError is thrown if the length is larger than Number.MAX_SAFE_INTEGER (>= 2 ** 53) or negative.
The ArrayBuffer constructor creates a new ArrayBuffer of the given length in bytes.
ArrayBuffer.lengthArrayBuffer constructor's length property whose value is 1.get ArrayBuffer[@@species]ArrayBuffer.prototypeArrayBuffer objects.ArrayBuffer.isView(arg)true if arg is one of the ArrayBuffer views, such as typed array objects or a DataView. Returns false otherwise.ArrayBuffer.transfer(oldBuffer [, newByteLength]) \nArrayBuffer whose contents are taken from the oldBuffer's data and then is either truncated or zero-extended by newByteLength.All ArrayBuffer instances inherit from ArrayBuffer.prototype.
ArrayBuffer constructor.ArrayBuffer.prototype.byteLength Read only \nArrayBuffer.prototype.slice()ArrayBuffer whose contents are a copy of this ArrayBuffer's bytes from begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.ArrayBuffer.slice() \nArrayBuffer.prototype.slice().In this example, we create a 8-byte buffer with a Int32Array view referring to the buffer:
var buffer = new ArrayBuffer(8);\nvar view = new Int32Array(buffer);
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'ArrayBuffer' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'ArrayBuffer' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nArrayBuffer() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
byteLength | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
isView | \nYes | \nYes | \n29 | \n11 | \nYes | \nYes | \n
prototype | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
slice | \nYes | \nYes | \n 12\n
| \n11 | \nYes | \n6 | \n
\ntransfer \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
@@species | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nArrayBuffer() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
byteLength | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
isView | \nYes | \nYes | \nYes | \n29 | \nYes | \nYes | \nYes | \n
prototype | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
slice | \nYes | \nYes | \nYes | \n 14\n
| \nYes | \n6 | \nYes | \n
\ntransfer \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
@@species | \n? | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\nArrayBuffer() without new throws | \n0.12 | \n
byteLength | \nYes | \n
isView | \nYes | \n
prototype | \nYes | \n
slice | \nYes | \n
\ntransfer \n | \nNo | \n
@@species | \n 6.5.0\n
| \n
Starting with ECMAScript 2015, ArrayBuffer constructors require to be constructed with a new operator. Calling an ArrayBuffer constructor as a function without new, will throw a TypeError from now on.
var dv = ArrayBuffer(10);\n// TypeError: calling a builtin ArrayBuffer constructor \n// without new is forbidden
var dv = new ArrayBuffer(10);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer\n
The Int16Array typed array represents an array of twos-complement 16-bit signed integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).
new Int16Array(); // new in ES2017\nnew Int16Array(length);\nnew Int16Array(typedArray);\nnew Int16Array(object);\nnew Int16Array(buffer [, byteOffset [, length]]);
For more information about the constructor syntax and the parameters, see TypedArray.
Int16Array.BYTES_PER_ELEMENT2 in the case of an Int16Array.Int16Array.prototype.length.Int16Array.nameInt16Array type: \"Int16Array\".Int16Array.prototypeInt16Array.from()Int16Array from an array-like or iterable object. See also Array.from().Int16Array.of()Int16Array with a variable number of arguments. See also Array.of().Int16Array prototypeAll Int16Array objects inherit from %TypedArray%.prototype.
Int16Array.prototype.constructorInt16Array constructor by default.Int16Array.prototype.buffer Read only \nArrayBuffer referenced by the Int16Array Fixed at construction time and thus read only.Int16Array.prototype.byteLength Read only \nInt16Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nInt16Array.prototype.byteOffset Read only \nInt16Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nInt16Array.prototype.length Read only \nInt16Array. Fixed at construction time and thus read only.\nInt16Array.prototype.copyWithin()Array.prototype.copyWithin().Int16Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().Int16Array.prototype.every()Array.prototype.every().Int16Array.prototype.fill()Array.prototype.fill().Int16Array.prototype.filter()Array.prototype.filter().Int16Array.prototype.find()undefined if not found. See also Array.prototype.find().Int16Array.prototype.findIndex()Array.prototype.findIndex().Int16Array.prototype.forEach()Array.prototype.forEach().Int16Array.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().Int16Array.prototype.indexOf()Array.prototype.indexOf().Int16Array.prototype.join()Array.prototype.join().Int16Array.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().Int16Array.prototype.lastIndexOf()Array.prototype.lastIndexOf().Int16Array.prototype.map()Array.prototype.map().Int16Array.prototype.move() Unimplemented\nInt16Array.prototype.copyWithin().Int16Array.prototype.reduce()Array.prototype.reduce().Int16Array.prototype.reduceRight()Array.prototype.reduceRight().Int16Array.prototype.reverse()Array.prototype.reverse().Int16Array.prototype.set()Int16Array.prototype.slice()Array.prototype.slice().Int16Array.prototype.some()Array.prototype.some().Int16Array.prototype.sort()Array.prototype.sort().Int16Array.prototype.subarray()Int16Array from the given start and end element index.Int16Array.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().Int16Array.prototype.toLocaleString()Array.prototype.toLocaleString().Int16Array.prototype.toString()Array.prototype.toString().Int16Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Different ways to create an Int16Array:
// From a length\nvar int16 = new Int16Array(2);\nint16[0] = 42;\nconsole.log(int16[0]); // 42\nconsole.log(int16.length); // 2\nconsole.log(int16.BYTES_PER_ELEMENT); // 2\n\n// From an array\nvar arr = new Int16Array([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Int16Array([21, 31]);\nvar y = new Int16Array(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(8);\nvar z = new Int16Array(buffer, 0, 4);\n\n// From an iterable\nvar iterable = function*(){ yield* [1,2,3]; }();\nvar int16 = new Int16Array(iterable);\n// Int16Array[1, 2, 3]\n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray constructors' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray constructors' in that specification. | Draft | ECMAScript 2017 changed the Int16Array constructor to use the ToIndex operation and allows constructors with no arguments. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nInt16Array() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nInt16Array() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\nInt16Array() without new throws | \n0.12 | \n
| Iterable in constructor | \n4.0.0 | \n
| Constructor without arguments | \n? | \n
Starting with ECMAScript 2015, Int16Array constructors require to be constructed with a new operator. Calling a Int16Array constructor as a function without new, will throw a TypeError from now on.
var dv = Int16Array([1, 2, 3]);\n// TypeError: calling a builtin Int16Array constructor\n// without new is forbidden
var dv = new Int16Array([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int16Array\n
The Float64Array typed array represents an array of 64-bit floating point numbers (corresponding to the C double data type) in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).
new Float64Array(); // new in ES2017\nnew Float64Array(length);\nnew Float64Array(typedArray);\nnew Float64Array(object);\nnew Float64Array(buffer [, byteOffset [, length]]);
For more information about the constructor syntax and the parameters, see TypedArray.
Float64Array.BYTES_PER_ELEMENT8 in the case of an Float64Array.Float64Array.prototype.length.Float64Array.nameFloat64Array type: \"Float64Array\".Float64Array.prototypeFloat64Array.from()Float64Array from an array-like or iterable object. See also Array.from().Float64Array.of()Float64Array with a variable number of arguments. See also Array.of().Float64Array prototypeAll Float64Array objects inherit from %TypedArray%.prototype.
Float64Array.prototype.constructorFloat64Array constructor by default.Float64Array.prototype.buffer Read only \nArrayBuffer referenced by the Float64Array Fixed at construction time and thus read only.Float64Array.prototype.byteLength Read only \nFloat64Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nFloat64Array.prototype.byteOffset Read only \nFloat64Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nFloat64Array.prototype.length Read only \nFloat64Array. Fixed at construction time and thus read only.\nFloat64Array.prototype.copyWithin()Array.prototype.copyWithin().Float64Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().Float64Array.prototype.every()Array.prototype.every().Float64Array.prototype.fill()Array.prototype.fill().Float64Array.prototype.filter()Array.prototype.filter().Float64Array.prototype.find()undefined if not found. See also Array.prototype.find().Float64Array.prototype.findIndex()Array.prototype.findIndex().Float64Array.prototype.forEach()Array.prototype.forEach().Float64Array.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().Float64Array.prototype.indexOf()Array.prototype.indexOf().Float64Array.prototype.join()Array.prototype.join().Float64Array.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().Float64Array.prototype.lastIndexOf()Array.prototype.lastIndexOf().Float64Array.prototype.map()Array.prototype.map().Float64Array.prototype.move() Unimplemented\nFloat64Array.prototype.copyWithin().Float64Array.prototype.reduce()Array.prototype.reduce().Float64Array.prototype.reduceRight()Array.prototype.reduceRight().Float64Array.prototype.reverse()Array.prototype.reverse().Float64Array.prototype.set()Float64Array.prototype.slice()Array.prototype.slice().Float64Array.prototype.some()Array.prototype.some().Float64Array.prototype.sort()Array.prototype.sort().Float64Array.prototype.subarray()Float64Array from the given start and end element index.Float64Array.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().Float64Array.prototype.toLocaleString()Array.prototype.toLocaleString().Float64Array.prototype.toString()Array.prototype.toString().Float64Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Different ways to create a Float64Array:
// From a length\nvar float64 = new Float64Array(2);\nfloat64[0] = 42;\nconsole.log(float64[0]); // 42\nconsole.log(float64.length); // 2\nconsole.log(float64.BYTES_PER_ELEMENT); // 8\n\n// From an array\nvar arr = new Float64Array([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Float64Array([21, 31]);\nvar y = new Float64Array(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(32);\nvar z = new Float64Array(buffer, 0, 4);\n\n// From an iterable \nvar iterable = function*(){ yield* [1,2,3]; }();\nvar float64 = new Float64Array(iterable);\n// Float64Array[1, 2, 3]\n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray constructors' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray constructors' in that specification. | Draft | ECMAScript 2017 changed the Float64Array constructor to use the ToIndex operation and allows constructors with no arguments. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nFloat64Array() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nFloat64Array() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\nFloat64Array() without new throws | \n0.12 | \n
| Iterable in constructor | \n4.0.0 | \n
| Constructor without arguments | \n? | \n
Starting with ECMAScript 2015, Float64Array constructors require to be constructed with a new operator. Calling a Float64Array constructor as a function without new, will throw a TypeError from now on.
var dv = Float64Array([1, 2, 3]);\n// TypeError: calling a builtin Float64Array constructor\n// without new is forbidden
var dv = new Float64Array([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array\n
The global Infinity property is a numeric value representing infinity.
Property attributes of Infinity\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Infinity
Infinity is a property of the global object, or in other words, a variable in global scope.
The initial value of Infinity is Number.POSITIVE_INFINITY. The value Infinity (positive infinity) is greater than any other number. Mathematically, this value behaves the same as infinity; for example, any positive number multiplied by Infinity equals Infinity, and any number divided by Infinity equals 0.
As defined by the ECMAScript 5 specification, Infinity is read-only (implemented in JavaScript 1.8.5 / Firefox 4).
console.log(Infinity ); /* Infinity */ \nconsole.log(Infinity + 1 ); /* Infinity */ \nconsole.log(Math.pow(10, 1000)); /* Infinity */ \nconsole.log(Math.log(0) ); /* -Infinity */ \nconsole.log(1 / Infinity ); /* 0 */ \n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3 |
| ECMAScript 5.1 (ECMA-262) The definition of 'Infinity' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Infinity' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Infinity' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity\n
The Int32Array typed array represents an array of twos-complement 32-bit signed integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).
new Int32Array(); // new in ES2017\nnew Int32Array(length);\nnew Int32Array(typedArray);\nnew Int32Array(object);\nnew Int32Array(buffer [, byteOffset [, length]]);
For more information about the constructor syntax and the parameters, see TypedArray.
Int32Array.BYTES_PER_ELEMENT4 in the case of an Int32Array.Int32Array.prototype.length.Int32Array.nameInt32Array type: \"Int32Array\".Int32Array.prototypeInt32Array.from()Int32Array from an array-like or iterable object. See also Array.from().Int32Array.of()Int32Array with a variable number of arguments. See also Array.of().Int32Array prototypeAll Int32Array objects inherit from %TypedArray%.prototype.
Int32Array.prototype.constructorInt32Array constructor by default.Int32Array.prototype.buffer Read only \nArrayBuffer referenced by the Int32Array Fixed at construction time and thus read only.Int32Array.prototype.byteLength Read only \nInt32Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nInt32Array.prototype.byteOffset Read only \nInt32Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nInt32Array.prototype.length Read only \nInt32Array. Fixed at construction time and thus read only.\nInt32Array.prototype.copyWithin()Array.prototype.copyWithin().Int32Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().Int32Array.prototype.every()Array.prototype.every().Int32Array.prototype.fill()Array.prototype.fill().Int32Array.prototype.filter()Array.prototype.filter().Int32Array.prototype.find()undefined if not found. See also Array.prototype.find().Int32Array.prototype.findIndex()Array.prototype.findIndex().Int32Array.prototype.forEach()Array.prototype.forEach().Int32Array.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().Int32Array.prototype.indexOf()Array.prototype.indexOf().Int32Array.prototype.join()Array.prototype.join().Int32Array.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().Int32Array.prototype.lastIndexOf()Array.prototype.lastIndexOf().Int32Array.prototype.map()Array.prototype.map().Int32Array.prototype.move() Unimplemented\nInt32Array.prototype.copyWithin().Int32Array.prototype.reduce()Array.prototype.reduce().Int32Array.prototype.reduceRight()Array.prototype.reduceRight().Int32Array.prototype.reverse()Array.prototype.reverse().Int32Array.prototype.set()Int32Array.prototype.slice()Array.prototype.slice().Int32Array.prototype.some()Array.prototype.some().Int32Array.prototype.sort()Array.prototype.sort().Int32Array.prototype.subarray()Int32Array from the given start and end element index.Int32Array.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().Int32Array.prototype.toLocaleString()Array.prototype.toLocaleString().Int32Array.prototype.toString()Array.prototype.toString().Int32Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Different ways to create an Int32Array:
// From a length\nvar int32 = new Int32Array(2);\nint32[0] = 42;\nconsole.log(int32[0]); // 42\nconsole.log(int32.length); // 2\nconsole.log(int32.BYTES_PER_ELEMENT); // 4\n\n// From an array\nvar arr = new Int32Array([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Int32Array([21, 31]);\nvar y = new Int32Array(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(16);\nvar z = new Int32Array(buffer, 0, 4);\n\n// From an iterable \nvar iterable = function*(){ yield* [1,2,3]; }(); \nvar int32 = new Int32Array(iterable);\n// Int32Array[1, 2, 3] \n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray constructors' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray constructors' in that specification. | Draft | ECMAScript 2017 changed the Int32Array constructor to use the ToIndex operation and allows constructors with no arguments. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nInt32Array() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nInt32Array() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\nInt32Array() without new throws | \n0.12 | \n
| Iterable in constructor | \n4.0.0 | \n
| Constructor without arguments | \n? | \n
Starting with ECMAScript 2015, Int32Array constructors require to be constructed with a new operator. Calling a Int32Array constructor as a function without new, will throw a TypeError from now on.
var dv = Int32Array([1, 2, 3]);\n// TypeError: calling a builtin Int32Array constructor\n// without new is forbidden
var dv = new Int32Array([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array\n
The Int8Array typed array represents an array of twos-complement 8-bit signed integers. The contents are initialized to 0. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).
new Int8Array(); // new in ES2017\nnew Int8Array(length);\nnew Int8Array(typedArray);\nnew Int8Array(object);\nnew Int8Array(buffer [, byteOffset [, length]]);
For more information about the constructor syntax and the parameters, see TypedArray.
Int8Array.BYTES_PER_ELEMENT1 in the case of an Int8Array.Int8Array.prototype.length.Int8Array.nameInt8Array type: \"Int8Array\".Int8Array.prototypeInt8Array.from()Int8Array from an array-like or iterable object. See also Array.from().Int8Array.of()Int8Array with a variable number of arguments. See also Array.of().Int8Array prototypeAll Int8Array objects inherit from %TypedArray%.prototype.
Int8Array.prototype.constructorInt8Array constructor by default.Int8Array.prototype.buffer Read only \nArrayBuffer referenced by the Int8Array Fixed at construction time and thus read only.Int8Array.prototype.byteLength Read only \nInt8Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nInt8Array.prototype.byteOffset Read only \nInt8Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nInt8Array.prototype.length Read only \nInt8Array. Fixed at construction time and thus read only.\nInt8Array.prototype.copyWithin()Array.prototype.copyWithin().Int8Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().Int8Array.prototype.every()Array.prototype.every().Int8Array.prototype.fill()Array.prototype.fill().Int8Array.prototype.filter()Array.prototype.filter().Int8Array.prototype.find()undefined if not found. See also Array.prototype.find().Int8Array.prototype.findIndex()Array.prototype.findIndex().Int8Array.prototype.forEach()Array.prototype.forEach().Int8Array.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().Int8Array.prototype.indexOf()Array.prototype.indexOf().Int8Array.prototype.join()Array.prototype.join().Int8Array.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().Int8Array.prototype.lastIndexOf()Array.prototype.lastIndexOf().Int8Array.prototype.map()Array.prototype.map().Int8Array.prototype.move() Unimplemented\nInt8Array.prototype.copyWithin().Int8Array.prototype.reduce()Array.prototype.reduce().Int8Array.prototype.reduceRight()Array.prototype.reduceRight().Int8Array.prototype.reverse()Array.prototype.reverse().Int8Array.prototype.set()Int8Array.prototype.slice()Array.prototype.slice().Int8Array.prototype.some()Array.prototype.some().Int8Array.prototype.sort()Array.prototype.sort().Int8Array.prototype.subarray()Int8Array from the given start and end element index.Int8Array.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().Int8Array.prototype.toLocaleString()Array.prototype.toLocaleString().Int8Array.prototype.toString()Array.prototype.toString().Int8Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Different ways to create an Int8Array:
// From a length\nvar int8 = new Int8Array(2);\nint8[0] = 42;\nconsole.log(int8[0]); // 42\nconsole.log(int8.length); // 2\nconsole.log(int8.BYTES_PER_ELEMENT); // 1\n\n// From an array\nvar arr = new Int8Array([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Int8Array([21, 31]);\nvar y = new Int8Array(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(8);\nvar z = new Int8Array(buffer, 1, 4);\n\n// From an iterable\nvar iterable = function*(){ yield* [1,2,3]; }();\nvar int8 = new Int8Array(iterable);\n// Int8Array[1, 2, 3]\n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray constructors' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray constructors' in that specification. | Draft | ECMAScript 2017 changed the Int8Array constructor to use the ToIndex operation and allows constructors with no arguments. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nInt8Array() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nInt8Array() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\nInt8Array() without new throws | \n0.12 | \n
| Iterable in constructor | \n4.0.0 | \n
| Constructor without arguments | \n? | \n
Starting with ECMAScript 2015, Int8Array constructors require to be constructed with a new operator. Calling a Int8Array constructor as a function without new, will throw a TypeError from now on.
var dv = Int8Array([1, 2, 3]);\n// TypeError: calling a builtin Int8Array constructor \n// without new is forbidden
var dv = new Int8Array([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int8Array\n
The Intl.Collator object is a constructor for collators, objects that enable language sensitive string comparison.
new Intl.Collator([locales[, options]])\nIntl.Collator.call(this[, locales[, options]])
localesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page. The following Unicode extension keys are allowed:
co\"big5han\", \"dict\", \"direct\", \"ducet\", \"gb2312\", \"phonebk\", \"phonetic\", \"pinyin\", \"reformed\", \"searchjl\", \"stroke\", \"trad\", \"unihan\". The \"standard\" and \"search\" values are ignored; they are replaced by the options property usage (see below).kn\"true\" and \"false\". This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence.kf\"upper\", \"lower\", or \"false\" (use the locale's default). This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence.optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.usage\"sort\" and \"search\"; the default is \"sort\".sensitivityWhich differences in the strings should lead to non-zero result values. Possible values are:
\"base\": Only strings that differ in base letters compare as unequal. Examples: a ≠ b, a = á, a = A.\"accent\": Only strings that differ in base letters or accents and other diacritic marks compare as unequal. Examples: a ≠ b, a ≠ á, a = A.\"case\": Only strings that differ in base letters or case compare as unequal. Examples: a ≠ b, a = á, a ≠ A.\"variant\": Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal. Other differences may also be taken into consideration. Examples: a ≠ b, a ≠ á, a ≠ A.The default is \"variant\" for usage \"sort\"; it's locale dependent for usage \"search\".
ignorePunctuationtrue and false; the default is false.numerictrue and false; the default is false. This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence. Implementations are not required to support this property.caseFirst\"upper\", \"lower\", or \"false\" (use the locale's default); the default is \"false\". This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence. Implementations are not required to support this property.The Intl.Collator object has the following properties and methods:
Intl.Collator.prototypeIntl.Collator.supportedLocalesOf()Collator instancesCollator instances inherit the following properties from their prototype:
Intl.Collator.prototype.compareIntl.Collator object.Intl.Collator.prototype.constructorIntl.Collator.Collator instances inherit the following methods from their prototype:
Intl.Collator.prototype.resolvedOptions()Collator\nThe following example demonstrates the different potential results for a string occurring before, after, or at the same level as another:
console.log(new Intl.Collator().compare('a', 'c')); // → a negative value\nconsole.log(new Intl.Collator().compare('c', 'a')); // → a positive value\nconsole.log(new Intl.Collator().compare('a', 'a')); // → 0\n Note that the results shown in the code above can vary between browsers and browser versions. This is because the values are implementation-specific. That is, the specification requires only that the before and after values are negative and positive.
locales\nThe results provided by Collator.prototype.compare() vary between languages. In order to get the sort order of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:
// in German, ä sorts with a\nconsole.log(new Intl.Collator('de').compare('ä', 'z'));\n// → a negative value\n\n// in Swedish, ä sorts after z\nconsole.log(new Intl.Collator('sv').compare('ä', 'z'));\n// → a positive value\n options\nThe results provided by Collator.prototype.compare() can be customized using the options argument:
// in German, ä has a as the base letter\nconsole.log(new Intl.Collator('de', { sensitivity: 'base' }).compare('ä', 'a'));\n// → 0\n\n// in Swedish, ä and a are separate base letters\nconsole.log(new Intl.Collator('sv', { sensitivity: 'base' }).compare('ä', 'a'));\n// → a positive value\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
\ncaseFirst option | \nYes | \n? | \n55 | \n? | \nYes | \n11 | \n
prototype | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
compare | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
resolvedOptions | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
supportedLocalesOf | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
\ncaseFirst option | \nYes | \nYes | \n? | \n56 | \nYes | \n11 | \nYes | \n
prototype | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
compare | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
resolvedOptions | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
supportedLocalesOf | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\ncaseFirst option | \n? | \n
prototype | \n? | \n
compare | \n? | \n
resolvedOptions | \n? | \n
supportedLocalesOf | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator\n
The Error constructor creates an error object. Instances of Error objects are thrown when runtime errors occur. The Error object can also be used as a base object for user-defined exceptions. See below for standard built-in error types.
new Error([message[, fileName[, lineNumber]]])
messagefileName \nfileName property on the created Error object. Defaults to the name of the file containing the code that called the Error() constructor.lineNumber \nlineNumber property on the created Error object. Defaults to the line number containing the Error() constructor invocation.Runtime errors result in new Error objects being created and thrown.
This page documents the use of the Error object itself and its use as a constructor function. For a list of properties and methods inherited by Error instances, see Error.prototype.
When Error is used like a function -- without new, it will return an Error object. Therefore, a mere call to Error will produce the same output that constructing an Error object via the new keyword would.
// this:\nconst x = Error('I was created using a function call!');\n// has the same functionality as this:\nconst y = new Error('I was constructed via the \"new\" keyword!');\n Besides the generic Error constructor, there are seven other core error constructors in JavaScript. For client-side exceptions, see Exception handling statements.
EvalErroreval().InternalError \nRangeErrorReferenceErrorSyntaxErroreval().TypeErrorURIErrorencodeURI() or decodeURI() are passed invalid parameters.Error.prototypeError instances.The global Error object contains no methods of its own, however, it does inherit some methods from the prototype chain.
All Error instances and instances of non-generic errors inherit from Error.prototype. As with all constructor functions, you can use the prototype of the constructor to add properties or methods to all instances created with that constructor.
Error.prototype.constructorError.prototype.messageError.prototype.name Non-standard
This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.
Error.prototype.descriptionmessage.Error.prototype.numberError.prototype.fileNameError.prototype.lineNumberError.prototype.columnNumberError.prototype.stackError.prototype.toSource() \nError object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.Error.prototype.toString()Object.prototype.toString() method.Usually you create an Error object with the intention of raising it using the throw keyword. You can handle the error using the try...catch construct:
try {\n throw new Error('Whoops!');\n} catch (e) {\n console.log(e.name + ': ' + e.message);\n}\n You can choose to handle only specific error types by testing the error type with the error's constructor property or, if you're writing for modern JavaScript engines, instanceof keyword:
try {\n foo.bar();\n} catch (e) {\n if (e instanceof EvalError) {\n console.log(e.name + ': ' + e.message);\n } else if (e instanceof RangeError) {\n console.log(e.name + ': ' + e.message);\n }\n // ... etc\n}\n You might want to define your own error types deriving from Error to be able to throw new MyError() and use instanceof MyError to check the kind of error in the exception handler. This results in cleaner and more consistent error handling code. See \"What's a good way to extend Error in JavaScript?\" on StackOverflow for an in-depth discussion.
Babel can handle Custom Error Class methods, but only when they are declared with Object.defineProperty(). Otherwise, Babel and other transpilers will not correctly handle the following code without additional configuration.
Some browsers include the CustomError constructor in the stack trace when using ES2015 classes.
class CustomError extends Error {\n constructor(foo = 'bar', ...params) {\n // Pass remaining arguments (including vendor specific ones) to parent constructor\n super(...params);\n\n // Maintains proper stack trace for where our error was thrown (only available on V8)\n if (Error.captureStackTrace) {\n Error.captureStackTrace(this, CustomError);\n }\n\n // Custom debugging information\n this.foo = foo;\n this.date = new Date();\n }\n}\n\ntry {\n throw new CustomError('baz', 'bazMessage');\n} catch(e){\n console.log(e.foo); //baz\n console.log(e.message); //bazMessage\n console.log(e.stack); //stacktrace\n} All browsers include the CustomError constructor in the stack trace when using a prototypal declaration.
function CustomError(foo, message, fileName, lineNumber) {\n var instance = new Error(message, fileName, lineNumber);\n instance.foo = foo;\n Object.setPrototypeOf(instance, Object.getPrototypeOf(this));\n if (Error.captureStackTrace) {\n Error.captureStackTrace(instance, CustomError);\n }\n return instance;\n}\n\nCustomError.prototype = Object.create(Error.prototype, {\n constructor: {\n value: Error,\n enumerable: false,\n writable: true,\n configurable: true\n }\n});\n\nif (Object.setPrototypeOf){\n Object.setPrototypeOf(CustomError, Error);\n} else {\n CustomError.__proto__ = Error;\n}\n\n\ntry {\n throw new CustomError('baz', 'bazMessage');\n} catch(e){\n console.log(e.foo); //baz\n console.log(e.message) ;//bazMessage\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Error' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Error' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Error' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
prototype | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
\ncolumnNumber \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
\nfileName \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
\nlineNumber \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
message | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
name | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
\nstack \n | \nYes | \nYes | \n1 | \n10 | \nYes | \n6 | \n
\ntoSource \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ncolumnNumber \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
\nfileName \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
\nlineNumber \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
message | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
name | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nstack \n | \nYes | \nYes | \nYes | \n4 | \nYes | \n6 | \nYes | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
prototype | \nYes | \n
\ncolumnNumber \n | \nNo | \n
\nfileName \n | \nNo | \n
\nlineNumber \n | \nNo | \n
message | \nYes | \n
name | \nYes | \n
\nstack \n | \nYes | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error\n
The Intl.DateTimeFormat object is a constructor for objects that enable language-sensitive date and time formatting.
new Intl.DateTimeFormat([locales[, options]])\nIntl.DateTimeFormat.call(this[, locales[, options]])
localesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page. The following Unicode extension keys are allowed:
nu\"arab\", \"arabext\", \"bali\", \"beng\", \"deva\", \"fullwide\", \"gujr\", \"guru\", \"hanidec\", \"khmr\", \"knda\", \"laoo\", \"latn\", \"limb\", \"mlym\", \"mong\", \"mymr\", \"orya\", \"tamldec\", \"telu\", \"thai\", \"tibt\".ca\"buddhist\", \"chinese\", \"coptic\", \"ethioaa\", \"ethiopic\", \"gregory\", \"hebrew\", \"indian\", \"islamic\", \"islamicc\", \"iso8601\", \"japanese\", \"persian\", \"roc\".hc\"h11\", \"h12\", \"h23\", \"h24\".optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.timeZone\"UTC\"; the default is the runtime's default time zone. Implementations may also recognize the time zone names of the IANA time zone database, such as \"Asia/Shanghai\", \"Asia/Kolkata\", \"America/New_York\".hour12true and false; the default is locale dependent. This option overrides the hc language tag and/or the hourCycle option in case both are present.hourCycle\"h11\", \"h12\", \"h23\", or \"h24\". This option overrides the hc language tag, if both are present, and the hour12 option takes precedence in case both options have been specified.formatMatcher\"basic\" and \"best fit\"; the default is \"best fit\". See the following paragraphs for information about the use of this property.The following properties describe the date-time components to use in formatted output, and their desired representations. Implementations are required to support at least the following subsets:
weekday, year, month, day, hour, minute, second\nweekday, year, month, day\nyear, month, day\nyear, month\nmonth, day\nhour, minute, second\nhour, minute\nImplementations may support other subsets, and requests will be negotiated against all available subset-representation combinations to find the best match. Two algorithms are available for this negotiation and selected by the formatMatcher property: A fully specified \"basic\" algorithm and an implementation-dependent \"best fit\" algorithm.
weekday\"narrow\", \"short\", \"long\".era\"narrow\", \"short\", \"long\".year\"numeric\", \"2-digit\".month\"numeric\", \"2-digit\", \"narrow\", \"short\", \"long\".day\"numeric\", \"2-digit\".hour\"numeric\", \"2-digit\".minute\"numeric\", \"2-digit\".second\"numeric\", \"2-digit\".timeZoneName\"short\", \"long\".The default value for each date-time component property is undefined, but if all component properties are undefined, then year, month, and day are assumed to be \"numeric\".
Intl.DateTimeFormat.prototypeIntl.DateTimeFormat.supportedLocalesOf()DateTimeFormat instancesDateTimeFormat instances inherit the following properties from their prototype:
Intl.DateTimeFormat.prototype.constructorIntl.DateTimeFormat.Intl.DateTimeFormat.prototype.formatDateTimeFormat object.DateTimeFormat instances inherit the following methods from their prototype:
Intl.DateTimeFormat.prototype.formatToParts()Array of objects representing the date string in parts that can be used for custom locale-aware formatting.Intl.DateTimeFormat.prototype.resolvedOptions()DateTimeFormat\nIn basic use without specifying a locale, DateTimeFormat uses the default locale and default options.
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));\n\n// toLocaleString without arguments depends on the implementation,\n// the default locale, and the default time zone\nconsole.log(new Intl.DateTimeFormat().format(date));\n// → \"12/19/2012\" if run with en-US locale (language) and time zone America/Los_Angeles (UTC-0800)\n
locales\nThis example shows some of the variations in localized date and time formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));\n\n// Results below use the time zone of America/Los_Angeles (UTC-0800, Pacific Standard Time)\n\n// US English uses month-day-year order\nconsole.log(new Intl.DateTimeFormat('en-US').format(date));\n// → \"12/19/2012\"\n\n// British English uses day-month-year order\nconsole.log(new Intl.DateTimeFormat('en-GB').format(date));\n// → \"19/12/2012\"\n\n// Korean uses year-month-day order\nconsole.log(new Intl.DateTimeFormat('ko-KR').format(date));\n// → \"2012. 12. 19.\"\n\n// Arabic in most Arabic speaking countries uses real Arabic digits\nconsole.log(new Intl.DateTimeFormat('ar-EG').format(date));\n// → \"١٩/١٢/٢٠١٢\"\n\n// for Japanese, applications may want to use the Japanese calendar,\n// where 2012 was the year 24 of the Heisei era\nconsole.log(new Intl.DateTimeFormat('ja-JP-u-ca-japanese').format(date));\n// → \"24/12/19\"\n\n// when requesting a language that may not be supported, such as\n// Balinese, include a fallback language, in this case Indonesian\nconsole.log(new Intl.DateTimeFormat(['ban', 'id']).format(date));\n// → \"19/12/2012\"\n options\nThe date and time formats can be customized using the options argument:
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));\n\n// request a weekday along with a long date\nvar options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };\nconsole.log(new Intl.DateTimeFormat('de-DE', options).format(date));\n// → \"Donnerstag, 20. Dezember 2012\"\n\n// an application may want to use UTC and make that visible\noptions.timeZone = 'UTC';\noptions.timeZoneName = 'short';\nconsole.log(new Intl.DateTimeFormat('en-US', options).format(date));\n// → \"Thursday, December 20, 2012, GMT\"\n\n// sometimes you want to be more precise\noptions = {\n hour: 'numeric', minute: 'numeric', second: 'numeric', \n timeZone: 'Australia/Sydney',\n timeZoneName: 'short'\n};\nconsole.log(new Intl.DateTimeFormat('en-AU', options).format(date));\n// → \"2:00:00 pm AEDT\"\n\n// sometimes even the US needs 24-hour time\noptions = {\n year: 'numeric', month: 'numeric', day: 'numeric',\n hour: 'numeric', minute: 'numeric', second: 'numeric',\n hour12: false,\n timeZone: 'America/Los_Angeles' \n};\nconsole.log(new Intl.DateTimeFormat('en-US', options).format(date));\n// → \"12/19/2012, 19:00:00\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
IANA time zone names in timeZone option | \n24 | \n? | \n52 | \n? | \n15 | \n10 | \n
hourCycle | \n? | \nYes | \n58 | \n? | \n? | \n? | \n
prototype | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
format | \n24 | \n12 | \n29 | \n11 | \n15 | \n10 | \n
formatToParts | \n 57\n
| \nYes | \n51 | \nNo | \nYes | \n11 | \n
resolvedOptions | \n24 | \n12 | \n29 | \n11 | \n15 | \n10 | \n
supportedLocalesOf | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
IANA time zone names in timeZone option | \n? | \n26 | \n? | \n56 | \n? | \n10 | \nYes | \n
hourCycle | \n? | \n? | \n? | \n58 | \n? | \n? | \n? | \n
prototype | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
format | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
formatToParts | \nYes | \n57 | \nNo | \n56 | \nNo | \n11 | \n7.0 | \n
resolvedOptions | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
supportedLocalesOf | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
IANA time zone names in timeZone option | \n? | \n
hourCycle | \n? | \n
prototype | \n? | \n
format | \n? | \n
formatToParts | \nYes | \n
resolvedOptions | \n? | \n
supportedLocalesOf | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat\n
The Intl.PluralRules object is a constructor for objects that enable plural sensitive formatting and plural language rules.
new Intl.PluralRules([locales[, options]])\n
localesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page.
optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.type\"cardinal\" for cardinal numbers (refering to the quantity of things). This is the default value.\"ordinal\" for ordinal number (refering to the ordering or ranking of things, e.g. \"1st\", \"2nd\", \"3rd\" in English).Intl.PluralRules.prototypeIntl.PluralRules.supportedLocalesOf()PluralRules instances inherit the following properties from their prototype:
Intl.PluralRules.prototype.constructorIntl.PluralRules.PluralRules instances inherit the following methods from their prototype:
Intl.PluralRules.prototype.resolvedOptions()Intl.PluralRules.prototype.select()String indicating which plurar rule to use for locale-aware formatting.In basic use without specifying a locale, a formatted string in the default locale and with default options is returned. This is useful to distinguish between singular and plural forms, e.g. \"dog\" and \"dogs\".
var pr = new Intl.PluralRules();\n\npr.select(0);\n// → 'other' if in US English locale\n\npr.select(1); \n// → 'one' if in US English locale\n\npr.select(2);\n// → 'other' if in US English locale\n
This example shows some of the variations in localized plural rules. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:
// Arabic has different plural rules\n\nnew Intl.PluralRules('ar-EG').select(0);\n// → 'zero'\nnew Intl.PluralRules('ar-EG').select(1); \n// → 'one'\nnew Intl.PluralRules('ar-EG').select(2);\n// → 'two'\nnew Intl.PluralRules('ar-EG').select(6);\n// → 'few'\nnew Intl.PluralRules('ar-EG').select(18);\n// → 'many'\n The results can be customized using the options argument, which has one property called type which you can set to ordinal. This is useful to figure out the ordinal indicator, e.g. \"1st\", \"2nd\", \"3rd\", \"4th\", \"42nd\" and so forth.
var pr = new Intl.PluralRules('en-US', { type: 'ordinal' });\n\npr.select(0);\n// → 'other'\npr.select(1);\n// → 'one'\npr.select(2);\n// → 'two'\npr.select(3);\n// → 'few'\npr.select(4);\n// → 'other'\npr.select(42);\n// → 'two'\n | Specification | Status | Comment |
|---|---|---|
| Intl Plural Rules Draft | Draft | Initial definition |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n63 | \nYes | \n58 | \nNo | \n50 | \nNo | \n
prototype | \n63 | \nYes | \n58 | \nNo | \n50 | \nNo | \n
resolvedOptions | \n63 | \nYes | \n58 | \nNo | \n50 | \nNo | \n
select | \n63 | \nYes | \n58 | \nNo | \n50 | \nNo | \n
supportedLocalesOf | \n63 | \nYes | \n58 | \nNo | \n50 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
prototype | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
resolvedOptions | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
select | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
supportedLocalesOf | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
prototype | \nNo | \n
resolvedOptions | \nNo | \n
select | \nNo | \n
supportedLocalesOf | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules\n
The RangeError object indicates an error when a value is not in the set or range of allowed values.
new RangeError([message[, fileName[, lineNumber]]])
messagefileName \nlineNumber \nA RangeError is thrown when trying to pass a value as an argument to a function that does not allow a range that includes the value. This can be encountered when passing a value that is not one of the allowed string values to String.prototype.normalize(), or when attempting to create an array of an illegal length with the Array constructor, or when passing bad values to the numeric methods Number.toExponential(), Number.toFixed() or Number.toPrecision().
RangeError.prototypeRangeError object.The global RangeError contains no methods of its own, however, it does inherit some methods through the prototype chain.
RangeError instancesRangeError.prototype.constructorRangeError.prototype.messageRangeError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.RangeError.prototype.nameError.RangeError.prototype.fileNameError.RangeError.prototype.lineNumberError.RangeError.prototype.columnNumberError.RangeError.prototype.stackError.Although the RangeError prototype object does not contain any methods of its own, RangeError instances do inherit some methods through the prototype chain.
RangeError (for numeric values)function check(n)\n{\n if(!(n >= -500 && n <= 500))\n {\n throw new RangeError(\"The argument must be between -500 and 500.\");\n }\n}\n\ntry\n{\n check(2000);\n}\ncatch(error)\n{\n if(error instanceof RangeError)\n {\n // Handle the error.\n }\n} RangeError (for non-numeric values)function check(value)\n{\n if([\"apple\", \"banana\", \"carrot\"].includes(value) === false)\n {\n throw new RangeError(\"The argument must be an \\\"apple\\\", \\\"banana\\\", or \\\"carrot\\\".\");\n }\n}\n\ntry\n{\n check(\"cabbage\");\n}\ncatch(error)\n{\n if(error instanceof RangeError)\n {\n // Handle the error.\n }\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RangeError' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RangeError' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RangeError' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
ErrorRangeError.prototypeArrayNumber.toExponential()Number.toFixed()Number.toPrecision()String.prototype.normalize()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError\n
The ReferenceError object represents an error when a non-existent variable is referenced.
new ReferenceError([message[, fileName[, lineNumber]]])
messagefileName \nlineNumber \nA ReferenceError is thrown when trying to dereference a variable that has not been declared.
ReferenceError.prototypeReferenceError object.ReferenceError instancesReferenceError.prototype.constructorReferenceError.prototype.messageReferenceError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.ReferenceError.prototype.nameError.ReferenceError.prototype.fileNameError.ReferenceError.prototype.lineNumberError.ReferenceError.prototype.columnNumberError.ReferenceError.prototype.stackError.Although the ReferenceError prototype object does not contain any methods of its own, ReferenceError instances do inherit some methods through the prototype chain.
ReferenceError\ntry {\n var a = undefinedVariable;\n} catch (e) {\n console.log(e instanceof ReferenceError); // true\n console.log(e.message); // \"undefinedVariable is not defined\"\n console.log(e.name); // \"ReferenceError\"\n console.log(e.fileName); // \"Scratchpad/1\"\n console.log(e.lineNumber); // 2\n console.log(e.columnNumber); // 6\n console.log(e.stack); // \"@Scratchpad/2:2:7\\n\"\n}\n ReferenceError\ntry {\n throw new ReferenceError('Hello', 'someFile.js', 10);\n} catch (e) {\n console.log(e instanceof ReferenceError); // true\n console.log(e.message); // \"Hello\"\n console.log(e.name); // \"ReferenceError\"\n console.log(e.fileName); // \"someFile.js\"\n console.log(e.lineNumber); // 10\n console.log(e.columnNumber); // 0\n console.log(e.stack); // \"@Scratchpad/2:2:9\\n\"\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'ReferenceError' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'ReferenceError' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'ReferenceError' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError\n
The Function creates a new Function object. Calling the constructor directly can create functions dynamically, but suffers from security and similar (but far less significant) performance issues to eval. However, unlike eval, the Function constructor creates functions which execute in the global scope only.
Every JavaScript function is actually a Function object. This can be seen with the code (function(){}).constructor === Function which returns true.
new Function ([arg1[, arg2[, ...argN]],] functionBody)
arg1, arg2, ... argNx\", \"theValue\", or \"a,b\".functionBodyFunction objects created with the Function constructor are parsed when the function is created. This is less efficient than declaring a function with a function expression or function statement and calling it within your code because such functions are parsed with the rest of the code.
All arguments passed to the function are treated as the names of the identifiers of the parameters in the function to be created, in the order in which they are passed.
Invoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.
Function\nThe global Function object has no methods or properties of its own. However, since it is a function itself, it does inherit some methods and properties through the prototype chain from Function.prototype.
Function prototype objectFunction.prototype.arguments \nFunction. Use the arguments object available within the function instead.Function.arity length property instead.Function.prototype.caller \nFunction.prototype.lengthFunction.prototype.nameFunction.displayName \nFunction.prototype.constructorObject.prototype.constructor for more details.Function.prototype.apply()Array object.Function.prototype.bind()Function.prototype.call()Function.prototype.isGenerator() \ntrue if the function is a generator; otherwise returns false.Function.prototype.toSource() \nObject.prototype.toSource method.Function.prototype.toString()Object.prototype.toString method.Function instancesFunction instances inherit methods and properties from Function.prototype. As with all constructors, you can change the constructor's prototype object to make changes to all Function instances.
Function constructorThe following code creates a Function object that takes two arguments.
// Example can be run directly in your JavaScript console\n\n// Create a function that takes two arguments and returns the sum of those arguments\nvar adder = new Function('a', 'b', 'return a + b');\n\n// Call the function\nadder(2, 6);\n// > 8\n The arguments \"a\" and \"b\" are formal argument names that are used in the function body, \"return a + b\".
Functions created with the Function constructor do not create closures to their creation contexts; they always are created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the Function constructor was created. This is different from using eval with code for a function expression.
var x = 10;\n\nfunction createFunction1() {\n var x = 20;\n return new Function('return x;'); // this |x| refers global |x|\n}\n\nfunction createFunction2() {\n var x = 20;\n function f() {\n return x; // this |x| refers local |x| above\n }\n return f;\n}\n\nvar f1 = createFunction1();\nconsole.log(f1()); // 10\nvar f2 = createFunction2();\nconsole.log(f2()); // 20\n While this code works in web browsers, f1() will produce a ReferenceError in Node.js, as x will not be found. This is because the top-level scope in Node is not the global scope, and x will be local to the module.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Function' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\narguments \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\narity \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
\ncaller \n | \nYes | \nYes | \n1 | \n8 | \nYes | \nYes | \n
\ndisplayName \n | \n? | \n? | \n13 | \n? | \n? | \n? | \n
length | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
name | \n15 | \n14 | \n1 | \nNo | \nYes | \nYes | \n
prototype | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
apply | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
bind | \n7 | \nYes | \n4 | \n9 | \n11.6 | \n5.1 | \n
call | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nisGenerator \n | \nNo | \nNo | \n5 — 58 | \nNo | \nNo | \nNo | \n
\ntoSource \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \n1 | \n5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\narguments \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\narity \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
\ncaller \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ndisplayName \n | \n? | \n? | \n? | \n14 | \n? | \n? | \n? | \n
length | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
name | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
apply | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
bind | \n4 | \n18 | \nYes | \n4 | \n11.5 | \n6 | \nYes | \n
call | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nisGenerator \n | \nNo | \nNo | \nNo | \n5 — 58 | \nNo | \nNo | \nNo | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\narguments \n | \nYes | \n
\narity \n | \nNo | \n
\ncaller \n | \nYes | \n
\ndisplayName \n | \n? | \n
length | \nYes | \n
name | \nYes | \n
prototype | \nYes | \n
apply | \nYes | \n
bind | \nYes | \n
call | \nYes | \n
\nisGenerator \n | \nNo | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
Functions and function scopefunction statementfunction expressionfunction* statementfunction* expressionAsyncFunctionGeneratorFunction\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function\n
The global NaN property is a value representing Not-A-Number.
Property attributes of NaN\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
NaN
NaN is a property of the global object.
The initial value of NaN is Not-A-Number — the same as the value of Number.NaN. In modern browsers, NaN is a non-configurable, non-writable property. Even when this is not the case, avoid overriding it.
It is rather rare to use NaN in a program. It is the returned value when Math functions fail (Math.sqrt(-1)) or when a function trying to parse a number fails (parseInt(\"blabla\")).
NaN\nNaN compares unequal (via ==, !=, ===, and !==) to any other value -- including to another NaN value. Use Number.isNaN() or isNaN() to most clearly determine whether a value is NaN. Or perform a self-comparison: NaN, and only NaN, will compare unequal to itself.
NaN === NaN; // false\nNumber.NaN === NaN; // false\nisNaN(NaN); // true\nisNaN(Number.NaN); // true\n\nfunction valueIsNaN(v) { return v !== v; }\nvalueIsNaN(1); // false\nvalueIsNaN(NaN); // true\nvalueIsNaN(Number.NaN); // true\n However, do note the difference between isNaN() and Number.isNaN(): the former will return true if the value is currently NaN, or if it is going to be NaN after it is coerced to a number, while the latter will return true only if the value is currently NaN:
isNaN('hello world'); // returns 'true'.\nNumber.isNaN('hello world'); // returns 'false'.\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3 |
| ECMAScript 5.1 (ECMA-262) The definition of 'NaN' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'NaN' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NaN' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN\n
The TypeError object represents an error when a value is not of the expected type.
new TypeError([message[, fileName[, lineNumber]]])
messagefileName \nlineNumber \nA TypeError is thrown when an operand or argument passed to a function is incompatible with the type expected by that operator or function.
TypeError.prototypeTypeError object.The global TypeError contains no methods of its own, however, it does inherit some methods through the prototype chain.
TypeError instancesTypeError.prototype.constructorTypeError.prototype.messageTypeError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.TypeError.prototype.nameError.TypeError.prototype.fileNameError.TypeError.prototype.lineNumberError.TypeError.prototype.columnNumberError.TypeError.prototype.stackError.Although the TypeError prototype object does not contain any methods of its own, TypeError instances do inherit some methods through the prototype chain.
TypeError\ntry {\n null.f();\n} catch (e) {\n console.log(e instanceof TypeError); // true\n console.log(e.message); // \"null has no properties\"\n console.log(e.name); // \"TypeError\"\n console.log(e.fileName); // \"Scratchpad/1\"\n console.log(e.lineNumber); // 2\n console.log(e.columnNumber); // 2\n console.log(e.stack); // \"@Scratchpad/2:2:3\\n\"\n}\n TypeError\ntry {\n throw new TypeError('Hello', \"someFile.js\", 10);\n} catch (e) {\n console.log(e instanceof TypeError); // true\n console.log(e.message); // \"Hello\"\n console.log(e.name); // \"TypeError\"\n console.log(e.fileName); // \"someFile.js\"\n console.log(e.lineNumber); // 10\n console.log(e.columnNumber); // 0\n console.log(e.stack); // \"@Scratchpad/2:2:9\\n\"\n}\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError\n
Reflect is a built-in object that provides methods for interceptable JavaScript operations. The methods are the same as those of proxy handlers. Reflect is not a function object, so it's not constructible.
Unlike most global objects, Reflect is not a constructor. You cannot use it with a new operator or invoke the Reflect object as a function. All properties and methods of Reflect are static (just like the Math object).
The Reflect object provides the following static functions which have the same names as the proxy handler methods. Some of these methods are the same as corresponding methods on Object.
Reflect.apply()args parameter. See also Function.prototype.apply().Reflect.construct()new operator as a function. Equivalent to calling new target(...args). Provides also the optional possibility to specify a different prototype.Reflect.defineProperty()Object.defineProperty(). Returns a Boolean.Reflect.deleteProperty()delete operator as a function. Equivalent to calling delete target[name].Reflect.get()Reflect.getOwnPropertyDescriptor()Object.getOwnPropertyDescriptor(). Returns a property descriptor of the given property if it exists on the object, undefined otherwise.Reflect.getPrototypeOf()Object.getPrototypeOf().Reflect.has()in operator as function. Returns a boolean indicating whether an own or inherited property exists.Reflect.isExtensible()Object.isExtensible().Reflect.ownKeys()Reflect.preventExtensions()Object.preventExtensions(). Returns a Boolean.Reflect.set()Boolean that is true if the update was successful.Reflect.setPrototypeOf()| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect' in that specification. | Draft | Reflect.enumerate has been removed. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
apply | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
construct | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
defineProperty | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
deleteProperty | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
\nenumerate \n | \nNo | \n? — 15 | \nNo | \nNo | \nNo | \nNo | \n
get | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
getOwnPropertyDescriptor | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
getPrototypeOf | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
has | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
isExtensible | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
ownKeys | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
preventExtensions | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
set | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
setPrototypeOf | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
apply | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
construct | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
defineProperty | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
deleteProperty | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
\nenumerate \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
get | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
getOwnPropertyDescriptor | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
getPrototypeOf | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
has | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
isExtensible | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
ownKeys | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
preventExtensions | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
set | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
setPrototypeOf | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
apply | \n6.0.0 | \n
construct | \n6.0.0 | \n
defineProperty | \n6.0.0 | \n
deleteProperty | \n6.0.0 | \n
\nenumerate \n | \nNo | \n
get | \n6.0.0 | \n
getOwnPropertyDescriptor | \n6.0.0 | \n
getPrototypeOf | \n6.0.0 | \n
has | \n6.0.0 | \n
isExtensible | \n6.0.0 | \n
ownKeys | \n6.0.0 | \n
preventExtensions | \n6.0.0 | \n
set | \n6.0.0 | \n
setPrototypeOf | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect\n
The SyntaxError object represents an error when trying to interpret syntactically invalid code.
A SyntaxError is thrown when the JavaScript engine encounters tokens or token order that does not conform to the syntax of the language when parsing code.
new SyntaxError([message[, fileName[, lineNumber]]])
message Optional\nfileName Optional \nlineNumber Optional \nSyntaxError.prototypeSyntaxError object.The global SyntaxError contains no methods of its own, however, it does inherit some methods through the prototype chain.
SyntaxError instancesSyntaxError.prototype.constructorSyntaxError.prototype.messageSyntaxError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.SyntaxError.prototype.nameError.SyntaxError.prototype.fileNameError.SyntaxError.prototype.lineNumberError.SyntaxError.prototype.columnNumberError.SyntaxError.prototype.stackError.Although the SyntaxError prototype object does not contain any methods of its own, SyntaxError instances do inherit some methods through the prototype chain.
SyntaxError\ntry {\n eval('hoo bar');\n} catch (e) {\n console.log(e instanceof SyntaxError); // true\n console.log(e.message); // \"missing ; before statement\"\n console.log(e.name); // \"SyntaxError\"\n console.log(e.fileName); // \"Scratchpad/1\"\n console.log(e.lineNumber); // 1\n console.log(e.columnNumber); // 4\n console.log(e.stack); // \"@Scratchpad/1:2:3\\n\"\n}\n SyntaxError\ntry {\n throw new SyntaxError('Hello', 'someFile.js', 10);\n} catch (e) {\n console.log(e instanceof SyntaxError); // true\n console.log(e.message); // \"Hello\"\n console.log(e.name); // \"SyntaxError\"\n console.log(e.fileName); // \"someFile.js\"\n console.log(e.lineNumber); // 10\n console.log(e.columnNumber); // 0\n console.log(e.stack); // \"@Scratchpad/2:11:9\\n\"\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'SyntaxError' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'SyntaxError' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'SyntaxError' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
ErrorSyntaxError.prototype\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError\n
The URIError object represents an error when a global URI handling function was used in a wrong way.
new URIError([message[, fileName[, lineNumber]]])
messagefileName \nlineNumber \nA URIError is thrown when the global URI handling functions are passed a malformed URI.
URIError.prototypeURIError object.The global URIError contains no methods of its own, however, it does inherit some methods through the prototype chain.
URIError instancesURIError.prototype.constructorURIError.prototype.messageURIError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.URIError.prototype.nameError.URIError.prototype.fileNameError.URIError.prototype.lineNumberError.URIError.prototype.columnNumberError.URIError.prototype.stackError.Although the URIError prototype object does not contain any methods of its own, URIError instances do inherit some methods through the prototype chain.
URIError\ntry {\n decodeURIComponent('%');\n} catch (e) {\n console.log(e instanceof URIError); // true\n console.log(e.message); // \"malformed URI sequence\"\n console.log(e.name); // \"URIError\"\n console.log(e.fileName); // \"Scratchpad/1\"\n console.log(e.lineNumber); // 2\n console.log(e.columnNumber); // 2\n console.log(e.stack); // \"@Scratchpad/2:2:3\\n\"\n}\n URIError\ntry {\n throw new URIError('Hello', 'someFile.js', 10);\n} catch (e) {\n console.log(e instanceof URIError); // true\n console.log(e.message); // \"Hello\"\n console.log(e.name); // \"URIError\"\n console.log(e.fileName); // \"someFile.js\"\n console.log(e.lineNumber); // 10\n console.log(e.columnNumber); // 0\n console.log(e.stack); // \"@Scratchpad/2:2:9\\n\"\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) The definition of 'URIError' in that specification. | Standard | Initial definition |
| ECMAScript 5.1 (ECMA-262) The definition of 'URIError' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'URIError' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'URIError' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError\n
The Map object holds key-value pairs and remembers the original insertion order of the keys. Any value (both objects and primitive values) may be used as either a key or a value.
new Map([iterable])
iterableArray or other iterable object whose elements are key-value pairs (arrays with two elements, e.g. [[ 1, 'one' ],[ 2, 'two' ]]). Each key-value pair is added to the new Map; null values are treated as undefined.A Map object iterates its elements in insertion order — a for...of loop returns an array of [key, value] for each iteration.
Key equality is based on the \"SameValueZero\" algorithm: NaN is considered the same as NaN (even though NaN !== NaN) and all other values are considered equal according to the semantics of the === operator. In the current ECMAScript specification -0 and +0 are considered equal, although this was not so in earlier drafts. See \"Value equality for -0 and 0\" in the browser compatibility table for details.
Objects are similar to Maps in that both let you set keys to values, retrieve those values, delete keys, and detect whether something is stored at a key. Because of this (and because there were no built-in alternatives), Objects have been used as Maps historically; however, there are important differences that make using a Map preferable in certain cases:
Object are Strings and Symbols, whereas they can be any value for a Map, including functions, objects, and any primitive.Map easily with the size property, while the number of properties in an Object must be determined manually.Map is an iterable and can thus be directly iterated, whereas iterating over an Object requires obtaining its keys in some fashion and iterating over them.Object has a prototype, so there are default keys in the map that could collide with your keys if you're not careful. As of ES5 this can be bypassed by using map = Object.create(null), but this is seldom done.Map may perform better in scenarios involving frequent addition and removal of key pairs.Map.lengthlength property is 0.get Map[@@species]Map.prototypeMap constructor. Allows the addition of properties to all Map objects.Map instancesAll Map instances inherit from Map.prototype.
Map.prototype.constructorMap function by default.Map.prototype.sizeMap object.Map.prototype.clear()Map object.Map.prototype.delete(key)true if an element in the Map object existed and has been removed, or false if the element does not exist. Map.prototype.has(key) will return false afterwards.Map.prototype.entries()Iterator object that contains[key, value] for each element in the Map object in insertion order.Map.prototype.forEach(callbackFn[, thisArg])Map object, in insertion order. If a thisArg parameter is provided to forEach, it will be used as the this value for each callback.Map.prototype.get(key)key, or undefined if there is none.Map.prototype.has(key)key in the Map object or not.Map.prototype.keys()Iterator object that contains the keys for each element in the Map object in insertion order.Map.prototype.set(key, value)key in the Map object. Returns the Map object.Map.prototype.values()Iterator object that contains the values for each element in the Map object in insertion order.Map.prototype[@@iterator]()Iterator object that contains[key, value] for each element in the Map object in insertion order.Map objectvar myMap = new Map();\n\nvar keyString = 'a string',\n keyObj = {},\n keyFunc = function() {};\n\n// setting the values\nmyMap.set(keyString, \"value associated with 'a string'\");\nmyMap.set(keyObj, 'value associated with keyObj');\nmyMap.set(keyFunc, 'value associated with keyFunc');\n\nmyMap.size; // 3\n\n// getting the values\nmyMap.get(keyString); // \"value associated with 'a string'\"\nmyMap.get(keyObj); // \"value associated with keyObj\"\nmyMap.get(keyFunc); // \"value associated with keyFunc\"\n\nmyMap.get('a string'); // \"value associated with 'a string'\"\n // because keyString === 'a string'\nmyMap.get({}); // undefined, because keyObj !== {}\nmyMap.get(function() {}) // undefined, because keyFunc !== function () {}\n NaN as Map keysNaN can also be used as a key. Even though every NaN is not equal to itself (NaN !== NaN is true), the following example works because NaNs are indistinguishable from each other:
var myMap = new Map();\nmyMap.set(NaN, 'not a number');\n\nmyMap.get(NaN); // \"not a number\"\n\nvar otherNaN = Number('foo');\nmyMap.get(otherNaN); // \"not a number\"\n Maps with for..of\nMaps can be iterated using a for..of loop:
var myMap = new Map();\nmyMap.set(0, 'zero');\nmyMap.set(1, 'one');\nfor (var [key, value] of myMap) {\n console.log(key + ' = ' + value);\n}\n// 0 = zero\n// 1 = one\n\nfor (var key of myMap.keys()) {\n console.log(key);\n}\n// 0\n// 1\n\nfor (var value of myMap.values()) {\n console.log(value);\n}\n// zero\n// one\n\nfor (var [key, value] of myMap.entries()) {\n console.log(key + ' = ' + value);\n}\n// 0 = zero\n// 1 = one\n Maps with forEach()\nMaps can be iterated using the forEach() method:
myMap.forEach(function(value, key) {\n console.log(key + ' = ' + value);\n});\n// Will show 2 logs; first with \"0 = zero\" and second with \"1 = one\"\n Array objectsvar kvArray = [['key1', 'value1'], ['key2', 'value2']];\n\n// Use the regular Map constructor to transform a 2D key-value Array into a map\nvar myMap = new Map(kvArray);\n\nmyMap.get('key1'); // returns \"value1\"\n\n// Use the Array.from function to transform a map into a 2D key-value Array\nconsole.log(Array.from(myMap)); // Will show you exactly the same Array as kvArray\n\n// Or use the keys or values iterators and convert them to an array\nconsole.log(Array.from(myMap.keys())); // Will show [\"key1\", \"key2\"]\n Maps\nJust like Arrays, Maps can be cloned:
var original = new Map([\n [1, 'one']\n]);\n\nvar clone = new Map(original);\n\nconsole.log(clone.get(1)); // one\nconsole.log(original === clone); // false. Useful for shallow comparison
Keep in mind that the data itself is not cloned
Maps can be merged, maintaining key uniqueness:
var first = new Map([\n [1, 'one'],\n [2, 'two'],\n [3, 'three'],\n]);\n\nvar second = new Map([\n [1, 'uno'],\n [2, 'dos']\n]);\n\n// Merge two maps. The last repeated key wins.\n// Spread operator essentially converts a Map to an Array\nvar merged = new Map([...first, ...second]);\n\nconsole.log(merged.get(1)); // uno\nconsole.log(merged.get(2)); // dos\nconsole.log(merged.get(3)); // three
Maps can be merged with Arrays, too:
var first = new Map([\n [1, 'one'],\n [2, 'two'],\n [3, 'three'],\n]);\n\nvar second = new Map([\n [1, 'uno'],\n [2, 'dos']\n]);\n\n// Merge maps with an array. The last repeated key wins.\nvar merged = new Map([...first, ...second, [1, 'eins']]);\n\nconsole.log(merged.get(1)); // eins\nconsole.log(merged.get(2)); // dos\nconsole.log(merged.get(3)); // three
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
new Map(iterable) | \n38 | \n12 | \n13 | \nNo | \n25 | \n9 | \n
new Map(null) | \nYes | \n12 | \n37 | \n11 | \nYes | \n9 | \n
\nMap() without new throws | \nYes | \n12 | \n42 | \n11 | \nYes | \n9 | \n
| Key equality for -0 and 0 | \n38 | \n12 | \n29 | \nNo | \n25 | \n9 | \n
clear | \n38 | \n12 | \n19 | \n11 | \n25 | \n8 | \n
delete | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
entries | \n38 | \n12 | \n20 | \nNo | \n25 | \n8 | \n
forEach | \n38 | \n12 | \n25 | \n11 | \n25 | \n8 | \n
get | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
has | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
keys | \n38 | \n12 | \n20 | \nNo | \n25 | \n8 | \n
prototype | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
set | \n38 | \n12 | \n13 | \n11\n
| \n25 | \n8 | \n
size | \n38 | \n12 | \n 19\n
| \n11 | \n25 | \n8 | \n
values | \n38 | \n12 | \n20 | \nNo | \n25 | \n8 | \n
@@iterator | \nYes | \nYes | \n 36\n
| \nNo | \nYes | \nYes | \n
@@species | \n51 | \n13 | \n41 | \nNo | \n38 | \n10 | \n
@@toStringTag | \n44 | \nNo | \nNo | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
new Map(iterable) | \n38 | \n38 | \n12 | \n14 | \n25 | \n9 | \nYes | \n
new Map(null) | \nYes | \nYes | \n12 | \n37 | \nYes | \n9 | \nYes | \n
\nMap() without new throws | \nYes | \nYes | \n12 | \n42 | \nYes | \n9 | \nYes | \n
| Key equality for -0 and 0 | \n38 | \n38 | \n12 | \n29 | \n25 | \n9 | \nYes | \n
clear | \n38 | \n38 | \n12 | \n19 | \n25 | \n8 | \nYes | \n
delete | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
entries | \n38 | \n38 | \n12 | \n20 | \n25 | \n8 | \nYes | \n
forEach | \n38 | \n38 | \n12 | \n25 | \n25 | \n8 | \nYes | \n
get | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
has | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
keys | \n38 | \n38 | \n12 | \n20 | \n25 | \n8 | \nYes | \n
prototype | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
set | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
size | \n38 | \n38 | \n12 | \n 19\n
| \n25 | \n8 | \nYes | \n
values | \n38 | \n38 | \n12 | \n20 | \n25 | \n8 | \nYes | \n
@@iterator | \nYes | \nYes | \nYes | \n 36\n
| \nYes | \nYes | \nYes | \n
@@species | \n51 | \n51 | \n13 | \n41 | \n38 | \n10 | \n5.0 | \n
@@toStringTag | \n44 | \n44 | \nNo | \nNo | \nNo | \nNo | \n4.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
new Map(iterable) | \n0.12 | \n
new Map(null) | \n 0.12\n
| \n
\nMap() without new throws | \n0.12 | \n
| Key equality for -0 and 0 | \n4.0.0 | \n
clear | \n0.12 | \n
delete | \n 0.12\n
| \n
entries | \n0.12 | \n
forEach | \n0.12 | \n
get | \nYes | \n
has | \nYes | \n
keys | \n0.12 | \n
prototype | \nYes | \n
set | \nYes | \n
size | \n0.12 | \n
values | \n0.12 | \n
@@iterator | \n0.12 | \n
@@species | \n 6.5.0\n
| \n
@@toStringTag | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map\n
The Proxy object is used to define custom behavior for fundamental operations (e.g. property lookup, assignment, enumeration, function invocation, etc).
var p = new Proxy(target, handler);\n
targetProxy. It can be any sort of object, including a native array, a function or even another proxy.handlerProxy.revocable()Proxy object.The handler object is a placeholder object which contains traps for Proxy.
All traps are optional. If a trap has not been defined, the default behavior is to forward the operation to the target.
handler.getPrototypeOf()Object.getPrototypeOf.handler.setPrototypeOf()Object.setPrototypeOf.handler.isExtensible()Object.isExtensible.handler.preventExtensions()Object.preventExtensions.handler.getOwnPropertyDescriptor()Object.getOwnPropertyDescriptor.handler.defineProperty()Object.defineProperty.handler.has()in operator.handler.get()handler.set()handler.deleteProperty()delete operator.handler.ownKeys()Object.getOwnPropertyNames and Object.getOwnPropertySymbols.handler.apply()handler.construct()new operator.Some non-standard traps are obsolete and have been removed.
In this simple example the number 37 gets returned as the default value when the property name is not in the object. It is using the get handler.
var handler = {\n get: function(obj, prop) {\n return prop in obj ?\n obj[prop] :\n 37;\n }\n};\n\nvar p = new Proxy({}, handler);\np.a = 1;\np.b = undefined;\n\nconsole.log(p.a, p.b); // 1, undefined\nconsole.log('c' in p, p.c); // false, 37\n In this example, we are using a native JavaScript object to which our proxy will forward all operations that are applied to it.
var target = {};\nvar p = new Proxy(target, {});\n\np.a = 37; // operation forwarded to the target\n\nconsole.log(target.a); // 37. The operation has been properly forwarded\n Note that while this \"no-op\" works for JavaScript objects it does not work for native browser objects like DOM Elements. See this for one solution.
With a Proxy, you can easily validate the passed value for an object. This example uses the set handler.
let validator = {\n set: function(obj, prop, value) {\n if (prop === 'age') {\n if (!Number.isInteger(value)) {\n throw new TypeError('The age is not an integer');\n }\n if (value > 200) {\n throw new RangeError('The age seems invalid');\n }\n }\n\n // The default behavior to store the value\n obj[prop] = value;\n\n // Indicate success\n return true;\n }\n};\n\nlet person = new Proxy({}, validator);\n\nperson.age = 100;\nconsole.log(person.age); // 100\nperson.age = 'young'; // Throws an exception\nperson.age = 300; // Throws an exception A function proxy could easily extend a constructor with a new constructor. This example uses the construct and apply handlers.
function extend(sup, base) {\n var descriptor = Object.getOwnPropertyDescriptor(\n base.prototype, 'constructor'\n );\n base.prototype = Object.create(sup.prototype);\n var handler = {\n construct: function(target, args) {\n var obj = Object.create(base.prototype);\n this.apply(target, obj, args);\n return obj;\n },\n apply: function(target, that, args) {\n sup.apply(that, args);\n base.apply(that, args);\n }\n };\n var proxy = new Proxy(base, handler);\n descriptor.value = proxy;\n Object.defineProperty(base.prototype, 'constructor', descriptor);\n return proxy;\n}\n\nvar Person = function(name) {\n this.name = name;\n};\n\nvar Boy = extend(Person, function(name, age) {\n this.age = age;\n});\n\nBoy.prototype.sex = 'M';\n\nvar Peter = new Boy('Peter', 13);\nconsole.log(Peter.sex); // \"M\"\nconsole.log(Peter.name); // \"Peter\"\nconsole.log(Peter.age); // 13 Sometimes you want to toggle the attribute or class name of two different elements. Here's how using the set handler.
let view = new Proxy({\n selected: null\n},\n{\n set: function(obj, prop, newval) {\n let oldval = obj[prop];\n\n if (prop === 'selected') {\n if (oldval) {\n oldval.setAttribute('aria-selected', 'false');\n }\n if (newval) {\n newval.setAttribute('aria-selected', 'true');\n }\n }\n\n // The default behavior to store the value\n obj[prop] = newval;\n\n // Indicate success\n return true;\n }\n});\n\nlet i1 = view.selected = document.getElementById('item-1');\nconsole.log(i1.getAttribute('aria-selected')); // 'true'\n\nlet i2 = view.selected = document.getElementById('item-2');\nconsole.log(i1.getAttribute('aria-selected')); // 'false'\nconsole.log(i2.getAttribute('aria-selected')); // 'true' The products proxy object evaluates the passed value and converts it to an array if needed. The object also supports an extra property called latestBrowser both as a getter and a setter.
let products = new Proxy({\n browsers: ['Internet Explorer', 'Netscape']\n},\n{\n get: function(obj, prop) {\n // An extra property\n if (prop === 'latestBrowser') {\n return obj.browsers[obj.browsers.length - 1];\n }\n\n // The default behavior to return the value\n return obj[prop];\n },\n set: function(obj, prop, value) {\n // An extra property\n if (prop === 'latestBrowser') {\n obj.browsers.push(value);\n return true;\n }\n\n // Convert the value if it is not an array\n if (typeof value === 'string') {\n value = [value];\n }\n\n // The default behavior to store the value\n obj[prop] = value;\n\n // Indicate success\n return true;\n }\n});\n\nconsole.log(products.browsers); // ['Internet Explorer', 'Netscape']\nproducts.browsers = 'Firefox'; // pass a string (by mistake)\nconsole.log(products.browsers); // ['Firefox'] <- no problem, the value is an array\n\nproducts.latestBrowser = 'Chrome';\nconsole.log(products.browsers); // ['Firefox', 'Chrome']\nconsole.log(products.latestBrowser); // 'Chrome' This proxy extends an array with some utility features. As you see, you can flexibly \"define\" properties without using Object.defineProperties. This example can be adapted to find a table row by its cell. In that case, the target will be table.rows.
let products = new Proxy([\n { name: 'Firefox', type: 'browser' },\n { name: 'SeaMonkey', type: 'browser' },\n { name: 'Thunderbird', type: 'mailer' }\n],\n{\n get: function(obj, prop) {\n // The default behavior to return the value; prop is usually an integer\n if (prop in obj) {\n return obj[prop];\n }\n\n // Get the number of products; an alias of products.length\n if (prop === 'number') {\n return obj.length;\n }\n\n let result, types = {};\n\n for (let product of obj) {\n if (product.name === prop) {\n result = product;\n }\n if (types[product.type]) {\n types[product.type].push(product);\n } else {\n types[product.type] = [product];\n }\n }\n\n // Get a product by name\n if (result) {\n return result;\n }\n\n // Get products by type\n if (prop in types) {\n return types[prop];\n }\n\n // Get product types\n if (prop === 'types') {\n return Object.keys(types);\n }\n\n return undefined;\n }\n});\n\nconsole.log(products[0]); // { name: 'Firefox', type: 'browser' }\nconsole.log(products['Firefox']); // { name: 'Firefox', type: 'browser' }\nconsole.log(products['Chrome']); // undefined\nconsole.log(products.browser); // [{ name: 'Firefox', type: 'browser' }, { name: 'SeaMonkey', type: 'browser' }]\nconsole.log(products.types); // ['browser', 'mailer']\nconsole.log(products.number); // 3\n traps list exampleNow in order to create a complete sample traps list, for didactic purposes, we will try to proxify a non native object that is particularly suited to this type of operation: the docCookies global object created by the \"little framework\" published on the document.cookie page.
/*\n var docCookies = ... get the \"docCookies\" object here: \n https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support\n*/\n\nvar docCookies = new Proxy(docCookies, {\n get: function (oTarget, sKey) {\n return oTarget[sKey] || oTarget.getItem(sKey) || undefined;\n },\n set: function (oTarget, sKey, vValue) {\n if (sKey in oTarget) { return false; }\n return oTarget.setItem(sKey, vValue);\n },\n deleteProperty: function (oTarget, sKey) {\n if (sKey in oTarget) { return false; }\n return oTarget.removeItem(sKey);\n },\n enumerate: function (oTarget, sKey) {\n return oTarget.keys();\n },\n ownKeys: function (oTarget, sKey) {\n return oTarget.keys();\n },\n has: function (oTarget, sKey) {\n return sKey in oTarget || oTarget.hasItem(sKey);\n },\n defineProperty: function (oTarget, sKey, oDesc) {\n if (oDesc && 'value' in oDesc) { oTarget.setItem(sKey, oDesc.value); }\n return oTarget;\n },\n getOwnPropertyDescriptor: function (oTarget, sKey) {\n var vValue = oTarget.getItem(sKey);\n return vValue ? {\n value: vValue,\n writable: true,\n enumerable: true,\n configurable: false\n } : undefined;\n },\n});\n\n/* Cookies test */\n\nconsole.log(docCookies.my_cookie1 = 'First value');\nconsole.log(docCookies.getItem('my_cookie1'));\n\ndocCookies.setItem('my_cookie1', 'Changed value');\nconsole.log(docCookies.my_cookie1); | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Proxy' in that specification. | Standard | Initial definition. |
| ECMAScript 2016 (ECMA-262) The definition of 'Proxy' in that specification. | Standard | |
| ECMAScript 2017 (ECMA-262) The definition of 'Proxy' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Proxy' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
revocable | \nYes | \nYes | \n34 | \nNo | \nYes | \n10 | \n
handler.apply | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
handler.construct | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
handler.defineProperty | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
handler.deleteProperty | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
\nhandler.enumerate \n | \nNo | \nNo | \n37 — 47 | \nNo | \nNo | \nNo | \n
handler.get | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
handler.getOwnPropertyDescriptor | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
handler.getPrototypeOf | \nNo | \nNo | \n49 | \nNo | \nNo | \nNo | \n
handler.has | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
handler.isExtensible | \n? | \n? | \n31 | \nNo | \n? | \n? | \n
handler.ownKeys | \n49 | \n12 | \n 18\n
| \nNo | \n36 | \n10 | \n
handler.preventExtensions | \n49 | \n12 | \n22 | \nNo | \n36 | \n10 | \n
handler.set | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
handler.setPrototypeOf | \n? | \n? | \n49 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
revocable | \nYes | \nYes | \nYes | \n34 | \nYes | \n10 | \nYes | \n
handler.apply | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
handler.construct | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
handler.defineProperty | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
handler.deleteProperty | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
\nhandler.enumerate \n | \nNo | \nNo | \nNo | \n37 — 47 | \nNo | \nNo | \nNo | \n
handler.get | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
handler.getOwnPropertyDescriptor | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
handler.getPrototypeOf | \nNo | \nNo | \nNo | \n49 | \nNo | \nNo | \nNo | \n
handler.has | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
handler.isExtensible | \n? | \n? | \n? | \n31 | \n? | \n? | \n? | \n
handler.ownKeys | \n49 | \n49 | \nYes | \n 18\n
| \n36 | \n10 | \n5.0 | \n
handler.preventExtensions | \n49 | \n49 | \nYes | \n22 | \n36 | \n10 | \n5.0 | \n
handler.set | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
handler.setPrototypeOf | \n? | \n? | \n? | \n49 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
revocable | \n6.0.0 | \n
handler.apply | \n6.0.0 | \n
handler.construct | \n6.0.0 | \n
handler.defineProperty | \n6.0.0 | \n
handler.deleteProperty | \n6.0.0 | \n
\nhandler.enumerate \n | \nNo | \n
handler.get | \n6.0.0 | \n
handler.getOwnPropertyDescriptor | \n6.0.0 | \n
handler.getPrototypeOf | \n6.0.0 | \n
handler.has | \n6.0.0 | \n
handler.isExtensible | \n6.0.0 | \n
handler.ownKeys | \n6.0.0 | \n
handler.preventExtensions | \n6.0.0 | \n
handler.set | \n6.0.0 | \n
handler.setPrototypeOf | \n6.0.0 | \n
Object.watch() is a non-standard feature but has been supported in Gecko for a long time.Some content (text, examples) in this page has been copied or adapted from the ECMAScript wiki which content is licensed CC 2.0 BY-NC-SA.
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy\n
The Uint16Array typed array represents an array of 16-bit unsigned integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).
new Uint16Array(); // new in ES2017\nnew Uint16Array(length);\nnew Uint16Array(typedArray);\nnew Uint16Array(object);\nnew Uint16Array(buffer [, byteOffset [, length]]);
For more information about the constructor syntax and the parameters, see TypedArray.
Uint16Array.BYTES_PER_ELEMENT2 in the case of an Uint16Array.Uint16Array.prototype.length.Uint16Array.nameUint16Array type: \"Uint16Array\".Uint16Array.prototypeUint16Array.from()Uint16Array from an array-like or iterable object. See also Array.from().Uint16Array.of()Uint16Array with a variable number of arguments. See also Array.of().Uint16Array prototypeAll Uint16Array objects inherit from %TypedArray%.prototype.
Uint16Array.prototype.constructorUint16Array constructor by default.Uint16Array.prototype.buffer Read only \nArrayBuffer referenced by the Uint16Array Fixed at construction time and thus read only.Uint16Array.prototype.byteLength Read only \nUint16Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nUint16Array.prototype.byteOffset Read only \nUint16Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nUint16Array.prototype.length Read only \nUint16Array. Fixed at construction time and thus read only.\nUint16Array.prototype.copyWithin()Array.prototype.copyWithin().Uint16Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().Uint16Array.prototype.every()Array.prototype.every().Uint16Array.prototype.fill()Array.prototype.fill().Uint16Array.prototype.filter()Array.prototype.filter().Uint16Array.prototype.find()undefined if not found. See also Array.prototype.find().Uint16Array.prototype.findIndex()Array.prototype.findIndex().Uint16Array.prototype.forEach()Array.prototype.forEach().Uint16Array.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().Uint16Array.prototype.indexOf()Array.prototype.indexOf().Uint16Array.prototype.join()Array.prototype.join().Uint16Array.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().Uint16Array.prototype.lastIndexOf()Array.prototype.lastIndexOf().Uint16Array.prototype.map()Array.prototype.map().Uint16Array.prototype.move() Unimplemented\nUint16Array.prototype.copyWithin().Uint16Array.prototype.reduce()Array.prototype.reduce().Uint16Array.prototype.reduceRight()Array.prototype.reduceRight().Uint16Array.prototype.reverse()Array.prototype.reverse().Uint16Array.prototype.set()Uint16Array.prototype.slice()Array.prototype.slice().Uint16Array.prototype.some()Array.prototype.some().Uint16Array.prototype.sort()Array.prototype.sort().Uint16Array.prototype.subarray()Uint16Array from the given start and end element index.Uint16Array.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().Uint16Array.prototype.toLocaleString()Array.prototype.toLocaleString().Uint16Array.prototype.toString()Array.prototype.toString().Uint16Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Different ways to create a Uint16Array:
// From a length\nvar uint16 = new Uint16Array(2);\nuint16[0] = 42;\nconsole.log(uint16[0]); // 42\nconsole.log(uint16.length); // 2\nconsole.log(uint16.BYTES_PER_ELEMENT); // 2\n\n// From an array\nvar arr = new Uint16Array([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Uint16Array([21, 31]);\nvar y = new Uint16Array(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(8);\nvar z = new Uint16Array(buffer, 0, 4);\n\n// From an iterable\nvar iterable = function*(){ yield* [1,2,3]; }(); \nvar uint16 = new Uint16Array(iterable); \n// Uint16Array[1, 2, 3]\n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray constructors' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray constructors' in that specification. | Draft | ECMAScript 2017 changed the Uint16Array constructor to use the ToIndex operation and allows constructors with no arguments. |
| Feature | \nChrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
|---|---|---|---|---|---|---|
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nUint16Array() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| Feature | \nAndroid webview | \nChrome for Android | \nEdge mobile | \nFirefox for Android | \nOpera Android | \niOS Safari | \nSamsung Internet | \n
|---|---|---|---|---|---|---|---|
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nUint16Array() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
Starting with ECMAScript 2015, Uint16Array constructors require to be constructed with a new operator. Calling a Uint16Array constructor as a function without new, will throw a TypeError from now on.
var dv = Uint16Array([1, 2, 3]);\n// TypeError: calling a builtin Uint16Array constructor\n// without new is forbidden
var dv = new Uint16Array([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array\n
The Set object lets you store unique values of any type, whether primitive values or object references.
new Set([iterable]);
iterableSet. If you don't specify this parameter, or its value is null, the new Set is empty.A new Set object.
Set objects are collections of values. You can iterate through the elements of a set in insertion order. A value in the Set may only occur once; it is unique in the Set's collection.
Because each value in the Set has to be unique, the value equality will be checked. In an earlier version of ECMAScript specification, this was not based on the same algorithm as the one used in the === operator. Specifically, for Sets, +0 (which is strictly equal to -0) and -0 were different values. However, this was changed in the ECMAScript 2015 specification. See \"Value equality for -0 and 0\" in the browser compatibility table for details.
Also, NaN and undefined can also be stored in a Set. NaN is considered the same as NaN (even though NaN !== NaN).
Set.lengthlength property is 0.Set, use Set.prototype.size.get Set[@@species]Set.prototypeSet constructor. Allows the addition of properties to all Set objects.Set instancesAll Set instances inherit from Set.prototype.
Set.prototype.constructorSet function by default.Set.prototype.sizeSet object.Set.prototype.add(value)Set object. Returns the Set object.Set.prototype.clear()Set object.Set.prototype.delete(value)value and returns the value that Set.prototype.has(value) would have previously returned. Set.prototype.has(value) will return false afterwards.Set.prototype.entries()Iterator object that contains[value, value] for each element in the Set object, in insertion order. This is kept similar to the Map object, so that each entry has the same value for its key and value here.Set.prototype.forEach(callbackFn[, thisArg])callbackFn once for each value present in the Set object, in insertion order. If a thisArg parameter is provided to forEach, it will be used as the this value for each callback.Set.prototype.has(value)Set object or not.Set.prototype.keys()values() function and returns a new Iterator object that contains the values for each element in the Set object in insertion order.Set.prototype.values()Iterator object that contains the values for each element in the Set object in insertion order.Set.prototype[@@iterator]()Iterator object that contains the values for each element in the Set object in insertion order.Set objectvar mySet = new Set();\n\nmySet.add(1); // Set [ 1 ]\nmySet.add(5); // Set [ 1, 5 ]\nmySet.add(5); // Set [ 1, 5 ]\nmySet.add('some text'); // Set [ 1, 5, 'some text' ]\nvar o = {a: 1, b: 2};\nmySet.add(o);\n\nmySet.add({a: 1, b: 2}); // o is referencing a different object so this is okay\n\nmySet.has(1); // true\nmySet.has(3); // false, 3 has not been added to the set\nmySet.has(5); // true\nmySet.has(Math.sqrt(25)); // true\nmySet.has('Some Text'.toLowerCase()); // true\nmySet.has(o); // true\n\nmySet.size; // 5\n\nmySet.delete(5); // removes 5 from the set\nmySet.has(5); // false, 5 has been removed\n\nmySet.size; // 4, we just removed one value\nconsole.log(mySet);// Set [ 1, \"some text\", Object {a: 1, b: 2}, Object {a: 1, b: 2} ] // iterate over items in set\n// logs the items in the order: 1, \"some text\", {\"a\": 1, \"b\": 2}, {\"a\": 1, \"b\": 2} \nfor (let item of mySet) console.log(item);\n\n// logs the items in the order: 1, \"some text\", {\"a\": 1, \"b\": 2}, {\"a\": 1, \"b\": 2} \nfor (let item of mySet.keys()) console.log(item);\n \n// logs the items in the order: 1, \"some text\", {\"a\": 1, \"b\": 2}, {\"a\": 1, \"b\": 2} \nfor (let item of mySet.values()) console.log(item);\n\n// logs the items in the order: 1, \"some text\", {\"a\": 1, \"b\": 2}, {\"a\": 1, \"b\": 2} \n//(key and value are the same here)\nfor (let [key, value] of mySet.entries()) console.log(key);\n\n// convert Set object to an Array object, with Array.from\nvar myArr = Array.from(mySet); // [1, \"some text\", {\"a\": 1, \"b\": 2}, {\"a\": 1, \"b\": 2}]\n\n// the following will also work if run in an HTML document\nmySet.add(document.body);\nmySet.has(document.querySelector('body')); // true\n\n// converting between Set and Array\nmySet2 = new Set([1, 2, 3, 4]);\nmySet2.size; // 4\n[...mySet2]; // [1, 2, 3, 4]\n\n// intersect can be simulated via \nvar intersection = new Set([...set1].filter(x => set2.has(x)));\n\n// difference can be simulated via\nvar difference = new Set([...set1].filter(x => !set2.has(x)));\n\n// Iterate set entries with forEach\nmySet.forEach(function(value) {\n console.log(value);\n});\n\n// 1\n// 2\n// 3\n// 4 function isSuperset(set, subset) {\n for (var elem of subset) {\n if (!set.has(elem)) {\n return false;\n }\n }\n return true;\n}\n\nfunction union(setA, setB) {\n var _union = new Set(setA);\n for (var elem of setB) {\n _union.add(elem);\n }\n return _union;\n}\n\nfunction intersection(setA, setB) {\n var _intersection = new Set();\n for (var elem of setB) {\n if (setA.has(elem)) {\n _intersection.add(elem);\n }\n }\n return _intersection;\n}\n\nfunction difference(setA, setB) {\n var _difference = new Set(setA);\n for (var elem of setB) {\n _difference.delete(elem);\n }\n return _difference;\n}\n\n//Examples\nvar setA = new Set([1, 2, 3, 4]),\n setB = new Set([2, 3]),\n setC = new Set([3, 4, 5, 6]);\n\nisSuperset(setA, setB); // => true\nunion(setA, setC); // => Set [1, 2, 3, 4, 5, 6]\nintersection(setA, setC); // => Set [3, 4]\ndifference(setA, setC); // => Set [1, 2]\n\n Array objectsvar myArray = ['value1', 'value2', 'value3'];\n\n// Use the regular Set constructor to transform an Array into a Set\nvar mySet = new Set(myArray);\n\nmySet.has('value1'); // returns true\n\n// Use the spread operator to transform a set into an Array.\nconsole.log([...mySet]); // Will show you exactly the same Array as myArray Strings\nvar text = 'India';\n\nvar mySet = new Set(text); // Set ['I', 'n', 'd', 'i', 'a']\nmySet.size; // 5\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
new Set(iterable) | \n38 | \n12 | \n13 | \nNo | \n25 | \n9 | \n
new Set(null) | \nYes | \n12 | \n37 | \n11 | \nYes | \n9 | \n
\nSet() without new throws | \nYes | \n12 | \n42 | \n11 | \nYes | \n9 | \n
| Key equality for -0 and 0 | \n38 | \n12 | \n29 | \nNo | \n25 | \n9 | \n
add | \n38 | \n12 | \n13 | \n11\n
| \n25 | \n8 | \n
clear | \n38 | \n12 | \n19 | \n11 | \n25 | \n8 | \n
delete | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
entries | \n38 | \n12 | \n24 | \nNo | \n25 | \n8 | \n
forEach | \n38 | \n12 | \n25 | \n11 | \n25 | \n8 | \n
has | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
prototype | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
size | \n38 | \n12 | \n 19\n
| \n11 | \n25 | \n8 | \n
values | \n38 | \n12 | \n24 | \nNo | \n25 | \n8 | \n
@@iterator | \nYes | \nYes | \n 36\n
| \nNo | \nYes | \nYes | \n
@@species | \n51 | \n13 | \n41 | \nNo | \n38 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
new Set(iterable) | \n38 | \n38 | \n12 | \n14 | \n25 | \n9 | \nYes | \n
new Set(null) | \nYes | \nYes | \n12 | \n37 | \nYes | \n9 | \nYes | \n
\nSet() without new throws | \nYes | \nYes | \n12 | \n42 | \nYes | \n9 | \nYes | \n
| Key equality for -0 and 0 | \n38 | \n38 | \n12 | \n29 | \n25 | \n9 | \nYes | \n
add | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
clear | \n38 | \n38 | \n12 | \n19 | \n25 | \n8 | \nYes | \n
delete | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
entries | \n38 | \n38 | \n12 | \n24 | \n25 | \n8 | \nYes | \n
forEach | \n38 | \n38 | \n12 | \n25 | \n25 | \n8 | \nYes | \n
has | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
prototype | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
size | \n38 | \n38 | \n12 | \n 19\n
| \n25 | \n8 | \nYes | \n
values | \n38 | \n38 | \n12 | \n24 | \n25 | \n8 | \nYes | \n
@@iterator | \nYes | \nYes | \nYes | \n 36\n
| \nYes | \nYes | \nYes | \n
@@species | \n51 | \n51 | \n13 | \n41 | \n38 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
new Set(iterable) | \n0.12 | \n
new Set(null) | \n 0.12\n
| \n
\nSet() without new throws | \n0.12 | \n
| Key equality for -0 and 0 | \n4.0.0 | \n
add | \nYes | \n
clear | \n0.12 | \n
delete | \n 0.12\n
| \n
entries | \n0.12 | \n
forEach | \n0.12 | \n
has | \nYes | \n
prototype | \nYes | \n
size | \n0.12 | \n
values | \n0.12 | \n
@@iterator | \n0.12 | \n
@@species | \n 6.5.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set\n
The SharedArrayBuffer object is used to represent a generic, fixed-length raw binary data buffer, similar to the ArrayBuffer object, but in a way that they can be used to create views on shared memory. Unlike an ArrayBuffer, a SharedArrayBuffer cannot become detached.
Note that SharedArrayBuffer was disabled by default in all major browsers on 5 January, 2018 in response to Spectre. Chrome re-enabled it in v67 on platforms where its site-isolation feature is enabled to protect against Spectre-style vulnerabilities.
new SharedArrayBuffer(length)\n
lengthA new SharedArrayBuffer object of the specified size. Its contents are initialized to 0.
To share memory using SharedArrayBuffer objects from one agent in the cluster to another (an agent is either the web page’s main program or one of its web workers), postMessage and structured cloning is used.
The structured clone algorithm accepts SharedArrayBuffers and TypedArrays mapped onto SharedArrayBuffers. In both cases, the SharedArrayBuffer object is transmitted to the receiver resulting in a new, private SharedArrayBuffer object in the receiving agent (just as for ArrayBuffer). However, the shared data block referenced by the two SharedArrayBuffer objects is the same data block, and a side effect to the block in one agent will eventually become visible in the other agent.
var sab = new SharedArrayBuffer(1024);\nworker.postMessage(sab);\n
Shared memory can be created and updated simultaneously in workers or the main thread. Depending on the system (the CPU, the OS, the Browser) it can take a while until the change is propagated to all contexts. To synchronize, atomic operations are needed.
SharedArrayBuffer objectsWebGLRenderingContext.bufferData()WebGLRenderingContext.bufferSubData()WebGL2RenderingContext.getBufferSubData()new operatorSharedArrayBuffer constructors are required to be constructed with a new operator. Calling a SharedArrayBuffer constructor as a function without new will throw a TypeError.
var sab = SharedArrayBuffer(1024);\n// TypeError: calling a builtin SharedArrayBuffer constructor \n// without new is forbidden
var sab = new SharedArrayBuffer(1024);
SharedArrayBuffer.lengthSharedArrayBuffer constructor's length property whose value is 1.SharedArrayBuffer.prototypeSharedArrayBuffer objects.SharedArrayBuffer prototype objectAll SharedArrayBuffer instances inherit from SharedArrayBuffer.prototype.
SharedArrayBuffer constructor.SharedArrayBuffer.prototype.byteLength Read only \nSharedArrayBuffer.prototype.slice(begin, end)SharedArrayBuffer whose contents are a copy of this SharedArrayBuffer's bytes from begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'SharedArrayBuffer' in that specification. | Draft | Initial definition in ES2017. |
| ECMAScript 2017 (ECMA-262) The definition of 'SharedArrayBuffer' in that specification. | Standard |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n No\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
\nSharedArrayBuffer in DataView\n | \n 68\n
| \n No\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
prototype | \n 68\n
| \n No\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
byteLength | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
slice | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
\nSharedArrayBuffer in DataView\n | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
prototype | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
byteLength | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
slice | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\nSharedArrayBuffer in DataView\n | \nNo | \n
prototype | \nNo | \n
byteLength | \n8.10.0 | \n
slice | \n8.10.0 | \n
AtomicsArrayBufferA Taste of JavaScript’s New Parallel Primitives – Mozilla Hacks
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer\n
The Uint32Array typed array represents an array of 32-bit unsigned integers in the platform byte order. If control over byte order is needed, use DataView instead. The contents are initialized to 0. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).
new Uint32Array(); // new in ES2017\nnew Uint32Array(length);\nnew Uint32Array(typedArray);\nnew Uint32Array(object);\nnew Uint32Array(buffer [, byteOffset [, length]]);
For more information about the constructor syntax and the parameters, see TypedArray.
Uint32Array.BYTES_PER_ELEMENT4 in the case of an Uint32Array.Uint32Array.prototype.length.Uint32Array.nameUint32Array type: \"Uint32Array\".Uint32Array.prototypeUint32Array.from()Uint32Array from an array-like or iterable object. See also Array.from().Uint32Array.of()Uint32Array with a variable number of arguments. See also Array.of().Uint32Array prototypeAll Uint32Array objects inherit from %TypedArray%.prototype.
Uint32Array.prototype.constructorUint32Array constructor by default.Uint32Array.prototype.buffer Read only \nArrayBuffer referenced by the Uint32Array Fixed at construction time and thus read only.Uint32Array.prototype.byteLength Read only \nUint32Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nUint32Array.prototype.byteOffset Read only \nUint32Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nUint32Array.prototype.length Read only \nUint32Array. Fixed at construction time and thus read only.\nUint32Array.prototype.copyWithin()Array.prototype.copyWithin().Uint32Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().Uint32Array.prototype.every()Array.prototype.every().Uint32Array.prototype.fill()Array.prototype.fill().Uint32Array.prototype.filter()Array.prototype.filter().Uint32Array.prototype.find()undefined if not found. See also Array.prototype.find().Uint32Array.prototype.findIndex()Array.prototype.findIndex().Uint32Array.prototype.forEach()Array.prototype.forEach().Uint32Array.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().Uint32Array.prototype.indexOf()Array.prototype.indexOf().Uint32Array.prototype.join()Array.prototype.join().Uint32Array.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().Uint32Array.prototype.lastIndexOf()Array.prototype.lastIndexOf().Uint32Array.prototype.map()Array.prototype.map().Uint32Array.prototype.move() Unimplemented\nUint32Array.prototype.copyWithin().Uint32Array.prototype.reduce()Array.prototype.reduce().Uint32Array.prototype.reduceRight()Array.prototype.reduceRight().Uint32Array.prototype.reverse()Array.prototype.reverse().Uint32Array.prototype.set()Uint32Array.prototype.slice()Array.prototype.slice().Uint32Array.prototype.some()Array.prototype.some().Uint32Array.prototype.sort()Array.prototype.sort().Uint32Array.prototype.subarray()Uint32Array from the given start and end element index.Uint32Array.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().Uint32Array.prototype.toLocaleString()Array.prototype.toLocaleString().Uint32Array.prototype.toString()Array.prototype.toString().Uint32Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Different ways to create a Uint32Array:
// From a length\nvar uint32 = new Uint32Array(2);\nuint32[0] = 42;\nconsole.log(uint32[0]); // 42\nconsole.log(uint32.length); // 2\nconsole.log(uint32.BYTES_PER_ELEMENT); // 4\n\n// From an array\nvar arr = new Uint32Array([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Uint32Array([21, 31]);\nvar y = new Uint32Array(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(16);\nvar z = new Uint32Array(buffer, 0, 4);\n\n// From an iterable \nvar iterable = function*(){ yield* [1,2,3]; }(); \nvar uint32 = new Uint32Array(iterable);\n// Uint32Array[1, 2, 3]\n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray constructors' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray constructors' in that specification. | Draft | ECMAScript 2017 changed the Uint32Array constructor to use the ToIndex operation and allows constructors with no arguments. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nUint32Array() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nUint32Array() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\nUint32Array() without new throws | \n0.12 | \n
| Iterable in constructor | \n4.0.0 | \n
| Constructor without arguments | \n? | \n
Starting with ECMAScript 2015, Uint32Array constructors require to be constructed with a new operator. Calling a Uint32Array constructor as a function without new, will throw a TypeError from now on.
var dv = Uint32Array([1, 2, 3]);\n// TypeError: calling a builtin Uint32Array constructor \n// without new is forbidden
var dv = new Uint32Array([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array\n
The Uint8Array typed array represents an array of 8-bit unsigned integers. The contents are initialized to 0. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).
new Uint8Array(); // new in ES2017\nnew Uint8Array(length);\nnew Uint8Array(typedArray);\nnew Uint8Array(object);\nnew Uint8Array(buffer [, byteOffset [, length]]);
For more information about the constructor syntax and the parameters, see TypedArray.
Uint8Array.BYTES_PER_ELEMENT1 in the case of an Uint8Array.Uint8Array.prototype.length.Uint8Array.nameUint8Array type: \"Uint8Array\".Uint8Array.prototypeUint8Array.from()Uint8Array from an array-like or iterable object. See also Array.from().Uint8Array.of()Uint8Array with a variable number of arguments. See also Array.of().Uint8Array prototypeAll Uint8Array objects inherit from %TypedArray%.prototype.
Uint8Array.prototype.constructorUint8Array constructor by default.Uint8Array.prototype.buffer Read only \nArrayBuffer referenced by the Uint8Array Fixed at construction time and thus read only.Uint8Array.prototype.byteLength Read only \nUint8Array. Fixed at construction time and thus read only.\nUint8Array.prototype.byteOffset Read only \nUint8Array from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nUint8Array.prototype.length Read only \nUint8Array. Fixed at construction time and thus read only.\nUint8Array.prototype.copyWithin()Array.prototype.copyWithin().Uint8Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().Uint8Array.prototype.every()Array.prototype.every().Uint8Array.prototype.fill()Array.prototype.fill().Uint8Array.prototype.filter()Array.prototype.filter().Uint8Array.prototype.find()undefined if not found. See also Array.prototype.find().Uint8Array.prototype.findIndex()Array.prototype.findIndex().Uint8Array.prototype.forEach()Array.prototype.forEach().Uint8Array.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().Uint8Array.prototype.indexOf()Array.prototype.indexOf().Uint8Array.prototype.join()Array.prototype.join().Uint8Array.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().Uint8Array.prototype.lastIndexOf()Array.prototype.lastIndexOf().Uint8Array.prototype.map()Array.prototype.map().Uint8Array.prototype.move() Unimplemented\nUint8Array.prototype.copyWithin().Uint8Array.prototype.reduce()Array.prototype.reduce().Uint8Array.prototype.reduceRight()Array.prototype.reduceRight().Uint8Array.prototype.reverse()Array.prototype.reverse().Uint8Array.prototype.set()Uint8Array.prototype.slice()Array.prototype.slice().Uint8Array.prototype.some()Array.prototype.some().Uint8Array.prototype.sort()Array.prototype.sort().Uint8Array.prototype.subarray()Uint8Array from the given start and end element index.Uint8Array.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().Uint8Array.prototype.toLocaleString()Array.prototype.toLocaleString().Uint8Array.prototype.toString()Array.prototype.toString().Uint8Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Different ways to create a Uint8Array:
// From a length\nvar uint8 = new Uint8Array(2);\nuint8[0] = 42;\nconsole.log(uint8[0]); // 42\nconsole.log(uint8.length); // 2\nconsole.log(uint8.BYTES_PER_ELEMENT); // 1\n\n// From an array\nvar arr = new Uint8Array([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Uint8Array([21, 31]);\nvar y = new Uint8Array(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(8);\nvar z = new Uint8Array(buffer, 1, 4);\n\n// From an iterable \nvar iterable = function*(){ yield* [1,2,3]; }(); \nvar uint8 = new Uint8Array(iterable); \n// Uint8Array[1, 2, 3]\n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray constructors' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray constructors' in that specification. | Draft | ECMAScript 2017 changed the Uint8Array constructor to use the ToIndex operation and allows constructors with no arguments. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nUint8Array() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nUint8Array() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\nUint8Array() without new throws | \n0.12 | \n
| Iterable in constructor | \n4.0.0 | \n
| Constructor without arguments | \n? | \n
Starting with ECMAScript 2015, Uint8Array constructors require to be constructed with a new operator. Calling a Uint8Array constructor as a function without new, will throw a TypeError from now on.
var dv = Uint8Array([1, 2, 3]);\n// TypeError: calling a builtin Uint8Array constructor\n// without new is forbidden
var dv = new Uint8Array([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array\n
The Promise object represents the eventual completion (or failure) of an asynchronous operation, and its resulting value.
Note: This article describes the Promise constructor and the methods and properties of such objects. To learn about the way promises work and how you can use them, we advise you to read Using promises first. The constructor is primarily used to wrap functions that do not already support promises.
new Promise( /* executor */ function(resolve, reject) { ... } ); resolve and reject. The executor function is executed immediately by the Promise implementation, passing resolve and reject functions (the executor is called before the Promise constructor even returns the created object). The resolve and reject functions, when called, resolve or reject the promise, respectively. The executor normally initiates some asynchronous work, and then, once that completes, either calls the resolve function to resolve the promise or else rejects it if an error occurred. If an error is thrown in the executor function, the promise is rejected. The return value of the executor is ignored.A Promise is a proxy for a value not necessarily known when the promise is created. It allows you to associate handlers with an asynchronous action's eventual success value or failure reason. This lets asynchronous methods return values like synchronous methods: instead of immediately returning the final value, the asynchronous method returns a promise to supply the value at some point in the future.
A Promise is in one of these states:
A pending promise can either be fulfilled with a value, or rejected with a reason (error). When either of these options happens, the associated handlers queued up by a promise's then method are called. (If the promise has already been fulfilled or rejected when a corresponding handler is attached, the handler will be called, so there is no race condition between an asynchronous operation completing and its handlers being attached.)
As the Promise.prototype.then()Promise.prototype.catch()
Not to be confused with: Several other languages have mechanisms for lazy evaluation and deferring a computation, which they also call \"promises\", e.g. Scheme. Promises in JavaScript represent processes which are already happening, which can be chained with callback functions. If you are looking to lazily evaluate an expression, consider the arrow function with no arguments: f = () => expression to create the lazily-evaluated expression, and f() to evaluate.
Note: A promise is said to be settled if it is either fulfilled or rejected, but not pending. You will also hear the term resolved used with promises — this means that the promise is settled or “locked in” to match the state of another promise. States and fates contains more details about promise terminology.
Promise.lengthPromise.prototypePromise constructor.Promise.all(iterable)Promise.race(iterable)Promise.reject(reason)Promise object that is rejected with the given reason.Promise.resolve(value)Promise object that is resolved with the given value. If the value is a thenable (i.e. has a then method), the returned promise will \"follow\" that thenable, adopting its eventual state; otherwise the returned promise will be fulfilled with the value. Generally, if you don't know if a value is a promise or not, Promise.resolve(value) it instead and work with the return value as a promise.Promise.prototype.constructorPromise function by default.Promise.prototype.catch(onRejected)Promise.prototype.then(onFulfilled, onRejected)onFulfilled or onRejected is not a function).Promise.prototype.finally(onFinally)A Promise object is created using the new keyword and its constructor. This constructor takes as its argument a function, called the \"executor function\". This function should take two functions as parameters. The first of these functions (resolve) is called when the asynchronous task completes successfully and returns the results of the task as a value. The second (reject) is called when the task fails, and returns the reason for failure, which is typically an error object.
const myFirstPromise = new Promise((resolve, reject) => {\n // do something asynchronous which eventually calls either:\n //\n // resolve(someValue); // fulfilled\n // or\n // reject(\"failure reason\"); // rejected\n});\n To provide a function with promise functionality, simply have it return a promise:
function myAsyncFunction(url) {\n return new Promise((resolve, reject) => {\n const xhr = new XMLHttpRequest();\n xhr.open(\"GET\", url);\n xhr.onload = () => resolve(xhr.responseText);\n xhr.onerror = () => reject(xhr.statusText);\n xhr.send();\n });\n} let myFirstPromise = new Promise((resolve, reject) => {\n // We call resolve(...) when what we were doing asynchronously was successful, and reject(...) when it failed.\n // In this example, we use setTimeout(...) to simulate async code. \n // In reality, you will probably be using something like XHR or an HTML5 API.\n setTimeout(function(){\n resolve(\"Success!\"); // Yay! Everything went well!\n }, 250);\n});\n\nmyFirstPromise.then((successMessage) => {\n // successMessage is whatever we passed in the resolve(...) function above.\n // It doesn't have to be a string, but if it is only a succeed message, it probably will be.\n console.log(\"Yay! \" + successMessage);\n});\n This small example shows the mechanism of a Promise. The testPromise() method is called each time the <button> is clicked. It creates a promise that will be fulfilled, using window.setTimeout(), to the promise count (number starting from 1) every 1-3 seconds, at random. The Promise() constructor is used to create the promise.
The fulfillment of the promise is simply logged, via a fulfill callback set using p1.then(). A few logs show how the synchronous part of the method is decoupled from the asynchronous completion of the promise.
'use strict';\nvar promiseCount = 0;\n\nfunction testPromise() {\n let thisPromiseCount = ++promiseCount;\n\n let log = document.getElementById('log');\n log.insertAdjacentHTML('beforeend', thisPromiseCount +\n ') Started (<small>Sync code started</small>)<br/>');\n\n // We make a new promise: we promise a numeric count of this promise, starting from 1 (after waiting 3s)\n let p1 = new Promise(\n // The executor function is called with the ability to resolve or\n // reject the promise\n (resolve, reject) => {\n log.insertAdjacentHTML('beforeend', thisPromiseCount +\n ') Promise started (<small>Async code started</small>)<br/>');\n // This is only an example to create asynchronism\n window.setTimeout(\n function() {\n // We fulfill the promise !\n resolve(thisPromiseCount);\n }, Math.random() * 2000 + 1000);\n }\n );\n\n // We define what to do when the promise is resolved with the then() call,\n // and what to do when the promise is rejected with the catch() call\n p1.then(\n // Log the fulfillment value\n function(val) {\n log.insertAdjacentHTML('beforeend', val +\n ') Promise fulfilled (<small>Async code terminated</small>)<br/>');\n }).catch(\n // Log the rejection reason\n (reason) => {\n console.log('Handle rejected promise ('+reason+') here.');\n });\n\n log.insertAdjacentHTML('beforeend', thisPromiseCount +\n ') Promise made (<small>Sync code terminated</small>)<br/>');\n} This example is started by clicking the button. You need a browser that supports Promise. By clicking the button several times in a short amount of time, you'll even see the different promises being fulfilled one after another.
Another simple example using Promise and XMLHttpRequest to load an image is available at the MDN GitHub js-examples repository. You can also see it in action. Each step is commented and allows you to follow the Promise and XHR architecture closely.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Promise' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Promise' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
\nPromise() constructor | \n32 | \nYes | \n 29\n
| \nNo | \n19 | \n 8\n
| \n
all | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
prototype | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
catch | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
finally | \n63 | \n18 | \n58 | \nNo | \n50 | \n11.1 | \n
then | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
race | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
reject | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
resolve | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
\nPromise() constructor | \n4.4.3 | \n32 | \nYes | \n 29\n
| \nYes | \n 8\n
| \nYes | \n
all | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
prototype | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
catch | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
finally | \n63 | \n63 | \nNo | \n58 | \n50 | \n11.1 | \nNo | \n
then | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
race | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
reject | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
resolve | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\nPromise() constructor | \n 0.12\n
| \n
all | \n0.12 | \n
prototype | \n0.12 | \n
catch | \n0.12 | \n
finally | \n10.0.0 | \n
then | \n0.12 | \n
race | \n0.12 | \n
reject | \n0.12 | \n
resolve | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise\n
The Number JavaScript object is a wrapper object allowing you to work with numerical values. A Number object is created using the Number() constructor.
new Number(value);
valueThe primary uses of the Number object are:
NaN.new operator), Number can be used to perform a type conversion.Number.EPSILONNumber.MAX_SAFE_INTEGER253 - 1).Number.MAX_VALUENumber.MIN_SAFE_INTEGER-(253 - 1)).Number.MIN_VALUENumber.NaNNumber.NEGATIVE_INFINITYNumber.POSITIVE_INFINITYNumber.prototypeNumber object.Number.isNaN()Number.isFinite()Number.isInteger()Number.isSafeInteger()-(253 - 1) and 253 - 1).Number.toInteger() Infinity), but has been removed.Number.parseFloat()parseFloat() of the global object.Number.parseInt()parseInt() of the global object.Number instancesAll Number instances inherit from Number.prototype. The prototype object of the Number constructor can be modified to affect all Number instances.
Number.prototype.toExponential()Number.prototype.toFixed()Number.prototype.toLocaleString()Object.prototype.toLocaleString() method.Number.prototype.toPrecision()Number.prototype.toSource() \nNumber object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.Number.prototype.toString()Object.prototype.toString() method.Number.prototype.valueOf()Object.prototype.valueOf() method.Number object to assign values to numeric variablesThe following example uses the Number object's properties to assign values to several numeric variables:
var biggestNum = Number.MAX_VALUE;\nvar smallestNum = Number.MIN_VALUE;\nvar infiniteNum = Number.POSITIVE_INFINITY;\nvar negInfiniteNum = Number.NEGATIVE_INFINITY;\nvar notANum = Number.NaN;\n
Number\nThe following example shows the minimum and maximum integer values that can be represented as Number object (for details, refer to ECMAScript standard, chapter 6.1.6 The Number Type):
var biggestInt = 9007199254740991;\nvar smallestInt = -9007199254740991;\n
When parsing data that has been serialized to JSON, integer values falling out of this range can be expected to become corrupted when JSON parser coerces them to Number type. Using String instead is a possible workaround.
Number to convert a Date objectThe following example converts the Date object to a numerical value using Number as a function:
var d = new Date('December 17, 1995 03:24:00');\nconsole.log(Number(d));\n This logs \"819199440000\".
Number('123') // 123\nNumber('12.3') // 12.3\nNumber('123e-1') // 12.3\nNumber('') // 0\nNumber(null) // 0 \nNumber('0x11') // 17\nNumber('0b11') // 3\nNumber('0o11') // 9\nNumber('foo') // NaN\nNumber('100a') // NaN\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number' in that specification. | Standard | New methods and properties added: EPSILON, isFinite, isInteger, isNaN, parseFloat, parseInt\n |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
EPSILON | \nYes | \nYes | \n25 | \nNo | \nYes | \n9 | \n
MAX_SAFE_INTEGER | \n34 | \nYes | \n31 | \nNo | \nYes | \n9 | \n
MAX_VALUE | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
MIN_SAFE_INTEGER | \n34 | \nYes | \n31 | \nNo | \nYes | \n9 | \n
MIN_VALUE | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
NEGATIVE_INFINITY | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
NaN | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
POSITIVE_INFINITY | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
isFinite | \n19 | \nYes | \n16 | \nNo | \n15 | \n9 | \n
isInteger | \nYes | \nYes | \n16 | \nNo | \nYes | \nYes | \n
isNaN | \n25 | \nYes | \n15 | \nNo | \nYes | \n9 | \n
isSafeInteger | \nYes | \nYes | \n32 | \nNo | \nYes | \n10 | \n
parseFloat | \nYes | \nYes | \n25 | \nNo | \nYes | \n9 | \n
parseInt | \nYes | \nYes | \n25 | \nNo | \nYes | \n9 | \n
prototype | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toExponential | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toFixed | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ntoInteger \n | \nNo | \nNo | \n16 — 32 | \nNo | \nNo | \nNo | \n
toLocaleString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toPrecision | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
valueOf | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
EPSILON | \nYes | \nYes | \nYes | \n25 | \nYes | \n9 | \nYes | \n
MAX_SAFE_INTEGER | \nYes | \nYes | \nYes | \n31 | \nYes | \n9 | \nYes | \n
MAX_VALUE | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
MIN_SAFE_INTEGER | \nYes | \nYes | \nYes | \n31 | \nYes | \n9 | \nYes | \n
MIN_VALUE | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
NEGATIVE_INFINITY | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
NaN | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
POSITIVE_INFINITY | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
isFinite | \nYes | \nYes | \nYes | \n16 | \nYes | \nYes | \nYes | \n
isInteger | \nYes | \nYes | \nYes | \n16 | \nYes | \nYes | \nYes | \n
isNaN | \nYes | \nYes | \nYes | \n15 | \nYes | \n9 | \nYes | \n
isSafeInteger | \nYes | \nYes | \nYes | \n32 | \nYes | \nYes | \nYes | \n
parseFloat | \nYes | \nYes | \nYes | \n25 | \nYes | \n9 | \nYes | \n
parseInt | \nYes | \nYes | \nYes | \n25 | \nYes | \n9 | \nYes | \n
prototype | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toExponential | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toFixed | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ntoInteger \n | \nNo | \nNo | \nNo | \n16 — 32 | \nNo | \nNo | \nNo | \n
toLocaleString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toPrecision | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
valueOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
EPSILON | \n0.12 | \n
MAX_SAFE_INTEGER | \n0.12 | \n
MAX_VALUE | \nYes | \n
MIN_SAFE_INTEGER | \n0.12 | \n
MIN_VALUE | \nYes | \n
NEGATIVE_INFINITY | \nYes | \n
NaN | \nYes | \n
POSITIVE_INFINITY | \nYes | \n
isFinite | \n0.10 | \n
isInteger | \n0.12 | \n
isNaN | \n0.10 | \n
isSafeInteger | \n0.12 | \n
parseFloat | \n0.12 | \n
parseInt | \n0.12 | \n
prototype | \nYes | \n
toExponential | \nYes | \n
toFixed | \nYes | \n
\ntoInteger \n | \nNo | \n
toLocaleString | \nYes | \n
toPrecision | \nYes | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
valueOf | \nYes | \n
NaNMath global object\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number\n
The Uint8ClampedArray typed array represents an array of 8-bit unsigned integers clamped to 0-255; if you specified a value that is out of the range of [0,255], 0 or 255 will be set instead; if you specify a non-integer, the nearest integer will be set. The contents are initialized to 0. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).
new Uint8ClampedArray(); // new in ES2017\nnew Uint8ClampedArray(length);\nnew Uint8ClampedArray(typedArray);\nnew Uint8ClampedArray(object);\nnew Uint8ClampedArray(buffer [, byteOffset [, length]]);
For more information about the constructor syntax and the parameters, see TypedArray.
Uint8ClampedArray.BYTES_PER_ELEMENT1 in the case of an Uint8ClampedArray.Uint8ClampedArray.prototype.length.Uint8ClampedArray.nameUint8ClampedArray type: \"Uint8ClampedArray\".Uint8ClampedArray.prototypeUint8ClampedArray.from()Uint8ClampedArray from an array-like or iterable object. See also Array.from().Uint8ClampedArray.of()Uint8ClampedArray with a variable number of arguments. See also Array.of().Uint8ClampedArray prototypeAll Uint8ClampedArray objects inherit from %TypedArray%.prototype.
Uint8ClampedArray.prototype.constructorUint8ClampedArray constructor by default.Uint8ClampedArray.prototype.buffer Read only \nArrayBuffer referenced by the Uint8ClampedArray Fixed at construction time and thus read only.Uint8ClampedArray.prototype.byteLength Read only \nUint8ClampedArray from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nUint8ClampedArray.prototype.byteOffset Read only \nUint8ClampedArray from the start of its ArrayBuffer. Fixed at construction time and thus read only.\nUint8ClampedArray.prototype.length Read only \nUintClamped8Array. Fixed at construction time and thus read only.\nUint8ClampedArray.prototype.copyWithin()Array.prototype.copyWithin().Uint8ClampedArray.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().Uint8ClampedArray.prototype.every()Array.prototype.every().Uint8ClampedArray.prototype.fill()Array.prototype.fill().Uint8ClampedArray.prototype.filter()Array.prototype.filter().Uint8ClampedArray.prototype.find()undefined if not found. See also Array.prototype.find().Uint8ClampedArray.prototype.findIndex()Array.prototype.findIndex().Uint8ClampedArray.prototype.forEach()Array.prototype.forEach().Uint8ClampedArray.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().Uint8ClampedArray.prototype.indexOf()Array.prototype.indexOf().Uint8ClampedArray.prototype.join()Array.prototype.join().Uint8ClampedArray.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().Uint8ClampedArray.prototype.lastIndexOf()Array.prototype.lastIndexOf().Uint8ClampedArray.prototype.map()Array.prototype.map().Uint8ClampedArray.prototype.move() Unimplemented\nUint8ClampedArray.prototype.copyWithin().Uint8ClampedArray.prototype.reduce()Array.prototype.reduce().Uint8ClampedArray.prototype.reduceRight()Array.prototype.reduceRight().Uint8ClampedArray.prototype.reverse()Array.prototype.reverse().Uint8ClampedArray.prototype.set()Uint8ClampedArray.prototype.slice()Array.prototype.slice().Uint8ClampedArray.prototype.some()Array.prototype.some().Uint8ClampedArray.prototype.sort()Array.prototype.sort().Uint8ClampedArray.prototype.subarray()Uint8ClampedArray from the given start and end element index.Uint8ClampedArray.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().Uint8ClampedArray.prototype.toLocaleString()Array.prototype.toLocaleString().Uint8ClampedArray.prototype.toString()Array.prototype.toString().Uint8ClampedArray.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Different ways to create a Uint8ClampedArray:
// From a length\nvar uintc8 = new Uint8ClampedArray(2);\nuintc8[0] = 42;\nuintc8[1] = 1337;\nconsole.log(uintc8[0]); // 42\nconsole.log(uintc8[1]); // 255 (clamped)\nconsole.log(uintc8.length); // 2\nconsole.log(uintc8.BYTES_PER_ELEMENT); // 1\n\n// From an array\nvar arr = new Uint8ClampedArray([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Uint8ClampedArray([21, 31]);\nvar y = new Uint8ClampedArray(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(8);\nvar z = new Uint8ClampedArray(buffer, 1, 4);\n\n// From an iterable \nvar iterable = function*(){ yield* [1,2,3]; }(); \nvar uintc8 = new Uint8ClampedArray(iterable); \n// Uint8ClampedArray[1, 2, 3]\n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray constructors' in that specification. | Standard | Initial definition in an ECMA standard. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray constructors' in that specification. | Draft | ECMAScript 2017 changed the Uint8ClampedArray constructor to use the ToIndex operation and allows constructors with no arguments. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
\nUint8ClampedArray() without new throws | \nYes | \nYes | \n44 | \nNo | \nYes | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
\nUint8ClampedArray() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\nUint8ClampedArray() without new throws | \n0.12 | \n
| Iterable in constructor | \n4.0.0 | \n
| Constructor without arguments | \n? | \n
Starting with ECMAScript 2015, Uint8ClampedArray constructors require to be constructed with a new operator. Calling a Uint8ClampedArray constructor as a function without new, will throw a TypeError from now on.
var dv = Uint8ClampedArray([1, 2, 3]);\n// TypeError: calling a builtin Uint8ClampedArray constructor\n// without new is forbidden
var dv = new Uint8ClampedArray([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray\n
The DataView view provides a low-level interface for reading and writing multiple number types in a binary ArrayBuffer, without having to care about the platform's endianness.
new DataView(buffer [, byteOffset [, byteLength]])
bufferArrayBuffer or SharedArrayBuffer to use as the storage backing the new DataView object.byteOffset Optional\nbyteLength Optional\nA new DataView object representing the specified data buffer. (That probably wasn't a very helpful description.)
You can think of the returned object as an \"interpreter\" of the array buffer of bytes — it knows how to convert numbers to fit within the buffer correctly, both when reading and writing to it. This means handling integer and float conversion, endianness, and other details of representing numbers in binary form.
RangeErrorThrown if the byteOffset or byteLength parameter values result in the view extending past the end of the buffer.
For example, if the buffer is 16 bytes long, the byteOffset is 8, and the byteLength is 10, this error is thrown because the resulting view tries to extend 2 bytes past the total length of the buffer.
Multi-byte number formats are represented in memory differently depending on machine architecture — see Endianness for an explanation. DataView accessors provide explicit control of how data is accessed, regardless of the executing computer's endianness.
var littleEndian = (function() {\n var buffer = new ArrayBuffer(2);\n new DataView(buffer).setInt16(0, 256, true /* littleEndian */);\n // Int16Array uses the platform's endianness.\n return new Int16Array(buffer)[0] === 256;\n})();\nconsole.log(littleEndian); // true or false\n Because JavaScript does not currently include standard support for 64-bit integer values, DataView does not offer native 64-bit operations. As a workaround, you could implement your own getUint64() method to obtain a value with precision up to Number.MAX_SAFE_INTEGER, which could suffice for certain cases.
DataView.prototype.getUint64 = function(byteOffset, littleEndian) {\n // split 64-bit number into two 32-bit (4-byte) parts\n const left = this.getUint32(byteOffset, littleEndian);\n const right = this.getUint32(byteOffset+4, littleEndian);\n\n // combine the two 32-bit values\n const combined = littleEndian? left + 2**32*right : 2**32*left + right;\n\n if (!Number.isSafeInteger(combined))\n console.warn(combined, 'exceeds MAX_SAFE_INTEGER. Precision may be lost');\n\n return combined;\n}\n All DataView instances inherit from DataView.prototype and allows the addition of properties to all DataView objects.
DataView.prototype.constructorDataView constructor.DataView.prototype.buffer Read only \nArrayBuffer referenced by this view. Fixed at construction time and thus read only.\nDataView.prototype.byteLength Read only \nArrayBuffer. Fixed at construction time and thus read only.\nDataView.prototype.byteOffset Read only \nArrayBuffer. Fixed at construction time and thus read only.\nDataView.prototype.getInt8()DataView.prototype.getUint8()DataView.prototype.getInt16()DataView.prototype.getUint16()DataView.prototype.getInt32()DataView.prototype.getUint32()DataView.prototype.getFloat32()DataView.prototype.getFloat64()DataView.prototype.setInt8()DataView.prototype.setUint8()DataView.prototype.setInt16()DataView.prototype.setUint16()DataView.prototype.setInt32()DataView.prototype.setUint32()DataView.prototype.setFloat32()DataView.prototype.setFloat64()var buffer = new ArrayBuffer(16);\nvar view = new DataView(buffer, 0);\n\nview.setInt16(1, 42);\nview.getInt16(1); // 42\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 6 |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView' in that specification. | Standard | Initial definition in an ECMA standard |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
\nDataView() without new throws | \nYes | \nYes | \n40 | \nNo | \nYes | \n? | \n
\nSharedArrayBuffer accepted as buffer | \n60 | \n? | \n55 | \n? | \n? | \n? | \n
buffer | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
byteLength | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
byteOffset | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
getFloat32 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
getFloat64 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
getInt16 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
getInt32 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
getInt8 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
getUint16 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
getUint32 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
getUint8 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
setFloat32 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
setFloat64 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
setInt16 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
setInt32 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
setInt8 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
setUint16 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
setUint32 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
setUint8 | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
prototype | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
\nDataView() without new throws | \n? | \n? | \n? | \n40 | \n? | \n? | \n? | \n
\nSharedArrayBuffer accepted as buffer | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
buffer | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
byteLength | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
byteOffset | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
getFloat32 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
getFloat64 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
getInt16 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
getInt32 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
getInt8 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
getUint16 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
getUint32 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
getUint8 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
setFloat32 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
setFloat64 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
setInt16 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
setInt32 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
setInt8 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
setUint16 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
setUint32 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
setUint8 | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
prototype | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\nDataView() without new throws | \n0.12 | \n
\nSharedArrayBuffer accepted as buffer | \n? | \n
buffer | \nYes | \n
byteLength | \nYes | \n
byteOffset | \nYes | \n
getFloat32 | \nYes | \n
getFloat64 | \nYes | \n
getInt16 | \nYes | \n
getInt32 | \nYes | \n
getInt8 | \nYes | \n
getUint16 | \nYes | \n
getUint32 | \nYes | \n
getUint8 | \nYes | \n
setFloat32 | \nYes | \n
setFloat64 | \nYes | \n
setInt16 | \nYes | \n
setInt32 | \nYes | \n
setInt8 | \nYes | \n
setUint16 | \nYes | \n
setUint32 | \nYes | \n
setUint8 | \nYes | \n
prototype | \nYes | \n
Starting with Firefox 40, DataView must be constructed with the new operator. Calling DataView() as a function without new will throw a TypeError.
var view = DataView(buffer, 0); \n// TypeError: calling a builtin DataView constructor without new is forbidden
var view = new DataView(buffer, 0);
DataView API to all browsers and Node.js.ArrayBufferSharedArrayBuffer\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView\n
The WeakMap object is a collection of key/value pairs in which the keys are weakly referenced. The keys must be objects and the values can be arbitrary values.
You can learn more about WeakMaps in the section WeakMap object in Keyed collections.
new WeakMap([iterable])\n
iterableKeys of WeakMaps are of the type Object only. Primitive data types as keys are not allowed (e.g. a Symbol can't be a WeakMap key).
A map API could be implemented in JavaScript with two arrays (one for keys, one for values) shared by the four API methods. Setting elements on this map would involve pushing a key and value onto the end of each of those arrays simultaneously. As a result, the indices of the key and value would correspond to both arrays. Getting values from the map would involve iterating through all keys to find a match, then using the index of this match to retrieve the corresponding value from the array of values.
Such an implementation would have two main inconveniences. The first one is an O(n) set and search (n being the number of keys in the map) since both operations must iterate through the list of keys to find a matching value. The second inconvenience is a memory leak because the arrays ensure that references to each key and each value are maintained indefinitely. These references prevent the keys from being garbage collected, even if there are no other references to the object. This would also prevent the corresponding values from being garbage collected.
By contrast, native WeakMaps hold \"weak\" references to key objects, which means that they do not prevent garbage collection in case there would be no other reference to the key object. This also avoids preventing garbage collection of values in the map. Native WeakMaps can be particularly useful constructs when mapping keys to information about the key that is valuable only if the key has not been garbage collected.
Because of references being weak, WeakMap keys are not enumerable (i.e. there is no method giving you a list of the keys). If they were, the list would depend on the state of garbage collection, introducing non-determinism. If you want to have a list of keys, you should use a Map.
WeakMap.lengthlength property is 0.WeakMap.prototypeWeakMap constructor. Allows the addition of properties to all WeakMap objects.WeakMap instancesAll WeakMap instances inherit from WeakMap.prototype.
WeakMap.prototype.constructorWeakMap function by default.WeakMap.prototype.delete(key)key. WeakMap.prototype.has(key) will return false afterwards.WeakMap.prototype.get(key)key, or undefined if there is none.WeakMap.prototype.has(key)key in the WeakMap object or not.WeakMap.prototype.set(key, value)key in the WeakMap object. Returns the WeakMap object.WeakMap.prototype.clear() WeakMap object. Note that it is possible to implement a WeakMap-like object that has a .clear() method by encapsulating a WeakMap object that hasn't it (see example on page WeakMap)WeakMap\nvar wm1 = new WeakMap(),\n wm2 = new WeakMap(),\n wm3 = new WeakMap();\nvar o1 = {},\n o2 = function() {},\n o3 = window;\n\nwm1.set(o1, 37);\nwm1.set(o2, 'azerty');\nwm2.set(o1, o2); // a value can be anything, including an object or a function\nwm2.set(o3, undefined);\nwm2.set(wm1, wm2); // keys and values can be any objects. Even WeakMaps!\n\nwm1.get(o2); // \"azerty\"\nwm2.get(o2); // undefined, because there is no key for o2 on wm2\nwm2.get(o3); // undefined, because that is the set value\n\nwm1.has(o2); // true\nwm2.has(o2); // false\nwm2.has(o3); // true (even if the value itself is 'undefined')\n\nwm3.set(o1, 37);\nwm3.get(o1); // 37\n\nwm1.has(o1); // true\nwm1.delete(o1);\nwm1.has(o1); // false\n WeakMap-like class with a .clear() methodclass ClearableWeakMap {\n constructor(init) {\n this._wm = new WeakMap(init)\n }\n clear() {\n this._wm = new WeakMap()\n }\n delete(k) {\n return this._wm.delete(k)\n }\n get(k) {\n return this._wm.get(k)\n }\n has(k) {\n return this._wm.has(k)\n }\n set(k, v) {\n this._wm.set(k, v)\n return this\n }\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakMap' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakMap' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \n12 | \n6 | \n11 | \n23 | \n8 | \n
new WeakMap(iterable) | \n38 | \n12 | \n36 | \nNo | \n25 | \n9 | \n
new WeakMap(null) | \nYes | \n12 | \n37 | \n11 | \n? | \n8 | \n
\nWeakMap() without new throws | \nYes | \n12 | \n42 | \n11 | \nYes | \n9 | \n
\nclear \n | \n36 — 43 | \nNo | \n20 — 46 | \n11 | \n25 — 30 | \n8 — 9 | \n
delete | \n36 | \nYes | \n 6\n
| \n11 | \n23 | \n8 | \n
get | \n36 | \nYes | \n 6\n
| \n11 | \n23 | \n8 | \n
has | \n36 | \nYes | \n 6\n
| \n11 | \n23 | \n8 | \n
prototype | \n36 | \nYes | \n6 | \n11 | \n23 | \n8 | \n
set | \n36 | \nYes | \n 6\n
| \n11\n
| \n23 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \n12 | \n6 | \n23 | \n8 | \nYes | \n
new WeakMap(iterable) | \n38 | \n38 | \n12 | \n36 | \n25 | \n9 | \nYes | \n
new WeakMap(null) | \nYes | \nYes | \n12 | \n37 | \n? | \n8 | \nYes | \n
\nWeakMap() without new throws | \nYes | \nYes | \n12 | \n42 | \nYes | \n9 | \nYes | \n
\nclear \n | \n37 — 43 | \n36 — 43 | \nNo | \n20 — 46 | \n25 — 30 | \n8 — 9 | \nYes | \n
delete | \n37 | \n36 | \nYes | \n 6\n
| \n23 | \n8 | \nYes | \n
get | \n37 | \n36 | \nYes | \n 6\n
| \n23 | \n8 | \nYes | \n
has | \n37 | \n36 | \nYes | \n 6\n
| \n23 | \n8 | \nYes | \n
prototype | \n37 | \n36 | \nYes | \n6 | \n23 | \n8 | \nYes | \n
set | \n37 | \n36 | \nYes | \n 6\n
| \n23 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
new WeakMap(iterable) | \n0.12 | \n
new WeakMap(null) | \n 0.12\n
| \n
\nWeakMap() without new throws | \n0.12 | \n
\nclear \n | \nYes | \n
delete | \n 0.12\n
| \n
get | \n 0.12\n
| \n
has | \n 0.12\n
| \n
prototype | \n 0.12\n
| \n
set | \n 0.12\n
| \n
WeakMap in the JavaScript guideMapSetWeakSet\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap\n
The decodeURIComponent() function decodes a Uniform Resource Identifier (URI) component previously created by encodeURIComponent or by a similar routine.
decodeURIComponent(encodedURI)
encodedURIA new string representing the decoded version of the given encoded Uniform Resource Identifier (URI) component.
Throws an URIError (\"malformed URI sequence\") exception when used wrongly.
Replaces each escape sequence in the encoded URI component with the character that it represents.
decodeURIComponent('JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B');\n// \"JavaScript_шеллы\"\n try { \n var a = decodeURIComponent('%E0%A4%A'); \n} catch(e) { \n console.error(e); \n}\n\n// URIError: malformed URI sequence | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'decodeURIComponent' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'decodeURIComponent' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'decodeURIComponent' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent\n
The WeakSet object lets you store weakly held objects in a collection.
new WeakSet([iterable]);
WeakSet. null is treated as undefined.var ws = new WeakSet();\nvar foo = {};\nvar bar = {};\n\nws.add(foo);\nws.add(bar);\n\nws.has(foo); // true\nws.has(bar); // true\n\nws.delete(foo); // removes foo from the set\nws.has(foo); // false, foo has been removed\n Note that foo !== bar. While they are similar objects, they are not the same object. And so they are both added to the set.
WeakSet objects are collections of objects. An object in the WeakSet may occur only once; it is unique in the WeakSet's collection.
The main differences to the Set object are:
Sets, WeakSets are collections of objects only and not of arbitrary values of any type.WeakSet is weak: References to objects in the collection are held weakly. If there is no other reference to an object stored in the WeakSet, they can be garbage collected. That also means that there is no list of current objects stored in the collection. WeakSets are not enumerable.TODO describe usecases.
WeakSet.lengthlength property is 0.WeakSet.prototypeWeakSet constructor. Allows the addition of properties to all WeakSet objects.WeakSet instancesAll WeakSet instances inherit from WeakSet.prototype.
WeakSet.prototype.constructorWeakSet function by default.WeakSet.prototype.add(value)WeakSet object.WeakSet.prototype.delete(value)value. WeakSet.prototype.has(value) will return false afterwards.WeakSet.prototype.has(value)WeakSet object or not.WeakSet.prototype.clear() WeakSet object.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakSet' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakSet' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \n12 | \n34 | \nNo | \n23 | \n9 | \n
new WeakSet(iterable) | \n38 | \n12 | \n34 | \nNo | \n25 | \n9 | \n
new WeakSet(null) | \nYes | \n12 | \n37 | \nNo | \n? | \n9 | \n
add | \n36 | \nYes | \n34 | \nNo | \n23 | \n9 | \n
\nclear \n | \n36 — 43 | \nNo | \n34 — 46 | \nNo | \n25 — 30 | \nNo | \n
delete | \n36 | \nYes | \n34 | \nNo | \n23 | \n9 | \n
has | \n36 | \nYes | \n34 | \nNo | \n23 | \n9 | \n
prototype | \n36 | \nYes | \n34 | \nNo | \n23 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \n12 | \n34 | \n23 | \n9 | \nYes | \n
new WeakSet(iterable) | \n38 | \n38 | \n12 | \n34 | \n25 | \n9 | \nYes | \n
new WeakSet(null) | \nYes | \nYes | \n12 | \n37 | \n? | \n9 | \nYes | \n
add | \n37 | \n36 | \nYes | \n34 | \n23 | \n9 | \nYes | \n
\nclear \n | \n37 — 43 | \n36 — 43 | \nNo | \n34 — 46 | \n25 — 30 | \nNo | \nYes | \n
delete | \n37 | \n36 | \nYes | \n34 | \n23 | \n9 | \nYes | \n
has | \n37 | \n36 | \nYes | \n34 | \n23 | \n9 | \nYes | \n
prototype | \n37 | \n36 | \nYes | \n34 | \n23 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
new WeakSet(iterable) | \n0.12 | \n
new WeakSet(null) | \n0.12 | \n
add | \n0.12 | \n
\nclear \n | \nNo | \n
delete | \n0.12 | \n
has | \n0.12 | \n
prototype | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet\n
The value null represents the intentional absence of any object value. It is one of JavaScript's primitive values.
null
The value null is written with a literal: null. null is not an identifier for a property of the global object, like undefined can be. Instead, null expresses a lack of identification, indicating that a variable points to no object. In APIs, null is often retrieved in a place where an object can be expected but no object is relevant.
// foo does not exist. It is not defined and has never been initialized:\nfoo;\n\"ReferenceError: foo is not defined\"\n\n// foo is known to exist now but it has no type or value:\nvar foo = null; \nfoo;\n\"null\"\n
null and undefined\nWhen checking for null or undefined, beware of the differences between equality (==) and identity (===) operators, as the former performs type-conversion.
typeof null // \"object\" (not \"null\" for legacy reasons)\ntypeof undefined // \"undefined\"\nnull === undefined // false\nnull == undefined // true\nnull === null // true\nnull == null // true\n!null // true\nisNaN(1 + null) // false\nisNaN(1 + undefined) // true
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'null value' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'null value' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'null value' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null\n
The Symbol() function returns a value of type symbol, has static properties that expose several members of built-in objects, has static methods that expose the global symbol registry, and resembles a built-in object class but is incomplete as a constructor because it does not support the syntax \"new Symbol()\".
Every symbol value returned from Symbol() is unique. A symbol value may be used as an identifier for object properties; this is the data type's only purpose. Some further explanation about purpose and usage can be found in the glossary entry for Symbol.
The data type symbol is a primitive data type.
Symbol([description])
description Optional\nTo create a new primitive symbol, you write Symbol() with an optional string as its description:
var sym1 = Symbol();\nvar sym2 = Symbol('foo');\nvar sym3 = Symbol('foo');\n The above code creates three new symbols. Note that Symbol(\"foo\") does not coerce the string \"foo\" into a symbol. It creates a new symbol each time:
Symbol('foo') === Symbol('foo'); // false The following syntax with the new operator will throw a TypeError:
var sym = new Symbol(); // TypeError
This prevents authors from creating an explicit Symbol wrapper object instead of a new symbol value and might be surprising as creating explicit wrapper objects around primitive data types is generally possible (for example, new Boolean, new String and new Number).
If you really want to create a Symbol wrapper object, you can use the Object() function:
var sym = Symbol('foo');\ntypeof sym; // \"symbol\" \nvar symObj = Object(sym);\ntypeof symObj; // \"object\"\n The above syntax using the Symbol() function will not create a global symbol that is available in your whole codebase. To create symbols available across files and even across realms (each of which has its own global scope), use the methods Symbol.for() and Symbol.keyFor() to set and retrieve symbols from the global symbol registry.
The method Object.getOwnPropertySymbols() returns an array of symbols and lets you find symbol properties on a given object. Note that every object is initialized with no own symbol properties, so that this array will be empty unless you've set symbol properties on the object.
Symbol.lengthSymbol.prototypeSymbol constructor.In addition to your own symbols, JavaScript has some built-in symbols which represent internal language behaviors which were not exposed to developers in ECMAScript 5 and before. These symbols can be accessed using the following properties:
Symbol.iteratorfor...of.Symbol.asyncIterator \nfor await of.Symbol.matchString.prototype.match().Symbol.replaceString.prototype.replace().Symbol.searchString.prototype.search().Symbol.splitString.prototype.split().Symbol.hasInstanceinstanceof.Symbol.isConcatSpreadableArray.prototype.concat().Symbol.unscopableswith environment bindings of the associated object.Symbol.speciesSymbol.toPrimitiveSymbol.toStringTagObject.prototype.toString().Symbol.for(key)Symbol.keyFor(sym)Symbol prototypeAll Symbols inherit from Symbol.prototype.
Symbol.prototype.constructorSymbol function by default.Symbol.prototype.descriptionSymbol.prototype.toSource() \nSymbol object. Overrides the Object.prototype.toSource() method.Symbol.prototype.toString()Object.prototype.toString() method.Symbol.prototype.valueOf()Symbol object. Overrides the Object.prototype.valueOf() method.Symbol.prototype[@@toPrimitive]Symbol object.typeof operator with symbolsThe typeof operator can help you to identify symbols.
typeof Symbol() === 'symbol'\ntypeof Symbol('foo') === 'symbol'\ntypeof Symbol.iterator === 'symbol'\n Some things to note when working with type conversion of symbols.
TypeError will be thrown+sym or sym | 0).Object(sym) == sym returns true.\nSymbol(\"foo\") + \"bar\" throws a TypeError (can't convert symbol to string). This prevents you from silently creating a new string property name from a symbol, for example.String(sym) conversion works like a call to Symbol.prototype.toString() with symbols, but note that new String(sym) will throw.for...in iterationSymbols are not enumerable in for...in iterations. In addition, Object.getOwnPropertyNames() will not return symbol object properties, however, you can use Object.getOwnPropertySymbols() to get these.
var obj = {};\n\nobj[Symbol('a')] = 'a';\nobj[Symbol.for('b')] = 'b';\nobj['c'] = 'c';\nobj.d = 'd';\n\nfor (var i in obj) {\n console.log(i); // logs \"c\" and \"d\"\n} JSON.stringify()\nSymbol-keyed properties will be completely ignored when using JSON.stringify():
JSON.stringify({[Symbol('foo')]: 'foo'}); \n// '{}' For more details, see JSON.stringify().
When a Symbol wrapper object is used as a property key, this object will be coerced to its wrapped symbol:
var sym = Symbol('foo');\nvar obj = {[sym]: 1};\nobj[sym]; // 1\nobj[Object(sym)]; // still 1\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol' in that specification. | Standard | Initial definition |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n 12\n
| \n36 | \nNo | \n25 | \n9 | \n
\nasyncIterator \n | \nNo | \nNo | \n No\n
| \nNo | \nNo | \nNo | \n
description | \n70 | \nNo | \n63 | \nNo | \n57 | \nNo | \n
for | \n40 | \nYes | \n36 | \nNo | \nYes | \n9 | \n
hasInstance | \n51 | \n15 | \n50 | \nNo | \nYes | \nYes | \n
isConcatSpreadable | \n48 | \n15 | \n48 | \nNo | \nYes | \nYes | \n
iterator | \n43 | \nYes | \n36 | \nNo | \n30 | \n10 | \n
keyFor | \n40 | \nYes | \n36 | \nNo | \nYes | \n9 | \n
match | \n50 | \nYes | \n40 | \nNo | \nYes | \nYes | \n
prototype | \n38 | \n12 | \n36 | \nNo | \n25 | \n9 | \n
replace | \n50 | \nYes | \n49 | \nNo | \nYes | \nYes | \n
search | \n50 | \nYes | \n49 | \nNo | \nYes | \nYes | \n
species | \n51 | \n14 | \n41 | \nNo | \n38 | \n10 | \n
split | \n50 | \nYes | \n49 | \nNo | \nYes | \nYes | \n
toPrimitive | \n48 | \n15 | \n44 | \nNo | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \n36 | \nNo | \nNo | \nNo | \n
toString | \n38 | \n12 | \n36 | \nNo | \n25 | \n9 | \n
toStringTag | \n49 | \n15 | \n51 | \nNo | \nYes | \nYes | \n
unscopables | \n38 | \nYes | \n48 | \nNo | \nYes | \n9 | \n
valueOf | \n38 | \n12 | \n36 | \nNo | \n25 | \n9 | \n
@@toPrimitive | \n? | \n? | \n44 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n38 | \nYes | \n36 | \n25 | \n9 | \nYes | \n
\nasyncIterator \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
description | \n70 | \n70 | \nNo | \n63 | \n57 | \nNo | \nNo | \n
for | \nYes | \nYes | \nYes | \n36 | \nYes | \n9 | \nYes | \n
hasInstance | \nYes | \nYes | \nYes | \n50 | \nYes | \nYes | \nYes | \n
isConcatSpreadable | \nYes | \nYes | \nYes | \n48 | \nYes | \nYes | \nYes | \n
iterator | \nYes | \nYes | \nYes | \n36 | \nYes | \n10 | \nYes | \n
keyFor | \nYes | \nYes | \nYes | \n36 | \nYes | \n9 | \nYes | \n
match | \nYes | \nYes | \nYes | \n40 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \n38 | \nYes | \n36 | \n25 | \n9 | \nYes | \n
replace | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
search | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
species | \nYes | \nYes | \n14 | \n41 | \n38 | \n10 | \nYes | \n
split | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
toPrimitive | \nYes | \nYes | \nYes | \n44 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n36 | \nNo | \nNo | \nNo | \n
toString | \nYes | \n38 | \nYes | \n36 | \n25 | \n9 | \nYes | \n
toStringTag | \nYes | \nYes | \nYes | \n51 | \nYes | \nYes | \nYes | \n
unscopables | \nYes | \nYes | \nYes | \n48 | \nYes | \n9 | \nYes | \n
valueOf | \nYes | \n38 | \nYes | \n36 | \n25 | \n9 | \nYes | \n
@@toPrimitive | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\nasyncIterator \n | \nNo | \n
description | \nNo | \n
for | \nYes | \n
hasInstance | \n 6.5.0\n
| \n
isConcatSpreadable | \n6.0.0 | \n
iterator | \n0.12 | \n
keyFor | \nYes | \n
match | \n6.0.0 | \n
prototype | \nYes | \n
replace | \n6.0.0 | \n
search | \n6.0.0 | \n
species | \n 6.5.0\n
| \n
split | \n6.0.0 | \n
toPrimitive | \n6.0.0 | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
toStringTag | \n 6.0.0\n
| \n
unscopables | \n0.12 | \n
valueOf | \nYes | \n
@@toPrimitive | \n? | \n
typeof\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol\n
The decodeURI() function decodes a Uniform Resource Identifier (URI) previously created by encodeURI() or by a similar routine.
decodeURI(encodedURI)
encodedURIA new string representing the unencoded version of the given encoded Uniform Resource Identifier (URI).
Throws an URIError (\"malformed URI sequence\") exception when encodedURI contains invalid character sequences.
Replaces each escape sequence in the encoded URI with the character that it represents, but does not decode escape sequences that could not have been introduced by encodeURI. The character “#” is not decoded from escape sequences.
decodeURI('https://developer.mozilla.org/ru/docs/JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B');\n// \"https://developer.mozilla.org/ru/docs/JavaScript_шеллы\"\n try { \n var a = decodeURI('%E0%A4%A'); \n} catch(e) { \n console.error(e); \n}\n\n// URIError: malformed URI sequence | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'decodeURI' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'decodeURI' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'decodeURI' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURI\n
The Atomics object provides atomic operations as static methods. They are used with SharedArrayBuffer objects.
The Atomic operations are installed on an Atomics module. Unlike the other global objects, Atomics is not a constructor. You cannot use it with a new operator or invoke the Atomics object as a function. All properties and methods of Atomics are static (as is the case with the Math object, for example).
Atomics[Symbol.toStringTag]When memory is shared, multiple threads can read and write the same data in memory. Atomic operations make sure that predictable values are written and read, that operations are finished before the next operation starts and that operations are not interrupted.
Atomics.add()Atomics.and()Atomics.compareExchange()Atomics.exchange()Atomics.load()Atomics.or()Atomics.store()Atomics.sub()Atomics.xor()The wait() and notify() methods are modeled on Linux futexes (\"fast user-space mutex\") and provide ways for waiting until a certain condition becomes true and are typically used as blocking constructs.
Atomics.wait()Verifies that the specified index of the array still contains a value and sleeps awaiting or times out. Returns either \"ok\", \"not-equal\", or \"timed-out\". If waiting is not allowed in the calling agent then it throws an Error exception (most browsers will not allow wait() on the browser's main thread).
Atomics.notify()Atomics.isLockFree(size)An optimization primitive that can be used to determine whether to use locks or atomic operations. Returns true, if an atomic operation on arrays of the given element size will be implemented using a hardware atomic operation (as opposed to a lock). Experts only.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics' in that specification. | Draft | Initial definition in ES2017. |
| ECMAScript 2017 (ECMA-262) The definition of 'Atomics' in that specification. | Standard |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n No\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
add | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
and | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
compareExchange | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
exchange | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
isLockFree | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
load | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
notify | \n 68\n
| \n 16\n
| \n 63\n
| \nNo | \nNo | \n10.1 — ?\n
| \n
or | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
store | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
sub | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
wait | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
xor | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
add | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
and | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
compareExchange | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
exchange | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
isLockFree | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
load | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
notify | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 63\n
| \nNo | \nNo | \nNo | \n
or | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
store | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
sub | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
wait | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
xor | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
add | \n8.10.0 | \n
and | \n8.10.0 | \n
compareExchange | \n8.10.0 | \n
exchange | \n8.10.0 | \n
isLockFree | \n8.10.0 | \n
load | \n8.10.0 | \n
notify | \n 8.10.0\n
| \n
or | \n8.10.0 | \n
store | \n8.10.0 | \n
sub | \n8.10.0 | \n
wait | \n8.10.0 | \n
xor | \n8.10.0 | \n
Prior to Firefox 48, the latest API names and semantics weren't implemented yet. The changes between Firefox version 46 and version 48 are:
Atomics.futexWakeOrRequeue() and Atomics.fence() are now removed entirely (bug 1259544 and bug 1225028).Atomics.wait() and Atomics.wake() were named Atomics.futexWait() and Atomics.futexWake() (bug 1260910). Note: The old names have been removed in version 49 and later (bug 1262062). Atomics.wake() has then been renamed to Atomics.notify() in version 63.Atomics.OK, Atomics.TIMEDOUT, Atomics.NOTEQUAL have been removed. The Atomics.wait() method now returns the strings \"ok\", \"timed-out\" and \"not-equal\" (bug 1260835).The count parameter of the Atomics.wake() method has been changed: it now defaults to +Infinity, not 0 (bug 1253350).
ArrayBuffer\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics\n
The RegExp constructor creates a regular expression object for matching text with a pattern.
For an introduction to regular expressions, read the Regular Expressions chapter in the JavaScript Guide.
Literal, constructor, and factory notations are possible:
/pattern/flags\nnew RegExp(pattern[, flags])\nRegExp(pattern[, flags])\n
patternflagsIf specified, flags indicates the flags to add, or if an object is supplied for the pattern, the flags value will replace any of that object's flags (and lastIndex will be reset to 0) (as of ES2015). If flags is not specified and a regular expressions object is supplied, that object's flags (and lastIndex value) will be copied over. The value is a string containing any combination of the following values:
giu flag is also enabled, use Unicode case foldingmuylastIndex property of this regular expression in the target string (and does not attempt to match from any later indexes).There are 2 ways to create a RegExp object: a literal notation and a constructor. To indicate strings, the parameters to the literal notation do not use quotation marks while the parameters to the constructor function do use quotation marks. So the following expressions create the same regular expression:
/ab+c/i;\nnew RegExp('ab+c', 'i');\nnew RegExp(/ab+c/, 'i');\n The literal notation provides a compilation of the regular expression when the expression is evaluated. Use literal notation when the regular expression will remain constant. For example, if you use literal notation to construct a regular expression used in a loop, the regular expression won't be recompiled on each iteration.
The constructor of the regular expression object, for example, new RegExp('ab+c'), provides runtime compilation of the regular expression. Use the constructor function when you know the regular expression pattern will be changing, or you don't know the pattern and are getting it from another source, such as user input.
Starting with ECMAScript 6, new RegExp(/ab+c/, 'i') no longer throws a TypeError (\"can't supply flags when constructing one RegExp from another\") when the first argument is a RegExp and the second flags argument is present. A new RegExp from the arguments is created instead.
When using the constructor function, the normal string escape rules (preceding special characters with \\ when included in a string) are necessary. For example, the following are equivalent:
var re = /\\w+/;\nvar re = new RegExp('\\\\w+');\n | Character Classes | |
|---|---|
| Character | Meaning |
. | (The dot, the decimal point) matches any single character except line terminators: Inside a character set, the dot loses its special meaning and matches a literal dot. Note that the For example, |
\\d | Matches any digit (Arabic numeral). Equivalent to For example, |
\\D | Matches any character that is not a digit (Arabic numeral). Equivalent to For example, |
\\w | Matches any alphanumeric character from the basic Latin alphabet, including the underscore. Equivalent to For example, |
\\W | Matches any character that is not a word character from the basic Latin alphabet. Equivalent to For example, |
\\s | Matches a single white space character, including space, tab, form feed, line feed and other Unicode spaces. Equivalent to For example, |
\\S | Matches a single character other than white space. Equivalent to For example, |
\\t | Matches a horizontal tab. |
\\r | Matches a carriage return. |
\\n | Matches a linefeed. |
\\v | Matches a vertical tab. |
\\f | Matches a form-feed. |
[\\b] | Matches a backspace. (Not to be confused with \\b) |
\\0 | Matches a NUL character. Do not follow this with another digit. |
\\cX | Where For example, |
\\xhh | Matches the character with the code hh (two hexadecimal digits). |
\\uhhhh | Matches a UTF-16 code-unit with the value hhhh (four hexadecimal digits). |
\\u{hhhh} or \\u{hhhhh} | (only when u flag is set) Matches the character with the Unicode value U+hhhh or U+hhhhh (hexadecimal digits). |
\\ | For characters that are usually treated literally, indicates that the next character is special and not to be interpreted literally. For example, or For characters that are usually treated specially, indicates that the next character is not special and should be interpreted literally. For example, \"*\" is a special character that means 0 or more occurrences of the preceding character should be matched; for example, |
| Character Sets | |
| Character | Meaning |
[xyz] | A character set. Matches any one of the enclosed characters. You can specify a range of characters by using a hyphen, but if the hyphen appears as the first or last character enclosed in the square brackets it is taken as a literal hyphen to be included in the character set as a normal character. It is also possible to include a character class in a character set. For example, For example, [abcd-] and [-abcd] match the \"b\" in \"brisket\", the \"c\" in \"chop\" and the \"-\" (hyphen) in \"non-profit\". For example, [\\w-] is the same as [A-Za-z0-9_-]. They match the \"b\" in \"brisket\", the \"c\" in \"chop\" and the \"n\" in \"non-profit\". |
|
| A negated or complemented character set. That is, it matches anything that is not enclosed in the brackets. You can specify a range of characters by using a hyphen, but if the hyphen appears as the first or last character enclosed in the square brackets it is taken as a literal hyphen to be included in the character set as a normal character. For example, |
| Alternation | |
| Character | Meaning |
x|y | Matches either For example, |
| Boundaries | |
| Character | Meaning |
^ | Matches beginning of input. If the multiline flag is set to true, also matches immediately after a line break character. For example, |
$ | Matches end of input. If the multiline flag is set to true, also matches immediately before a line break character. For example, |
\\b | Matches a word boundary. This is the position where a word character is not followed or preceded by another word-character, such as between a letter and a space. Note that a matched word boundary is not included in the match. In other words, the length of a matched word boundary is zero. Examples: |
\\B | Matches a non-word boundary. This is a position where the previous and next character are of the same type: Either both must be words, or both must be non-words. Such as between two letters or between two spaces. The beginning and end of a string are considered non-words. Same as the matched word boundary, the matched non-word boundary is also not included in the match. For example, |
| Grouping and back references | |
| Character | Meaning |
(x) | Matches For example, The capturing groups are numbered according to the order of left parentheses of capturing groups, starting from 1. The matched substring can be recalled from the resulting array's elements Capturing groups have a performance penalty. If you don't need the matched substring to be recalled, prefer non-capturing parentheses (see below). |
\\n | Where For example, |
(?:x) | Matches x but does not remember the match. These are called non-capturing groups. The matched substring cannot be recalled from the resulting array's elements [1], ..., [n] or from the predefined RegExp object's properties $1, ..., $9. |
| Quantifiers | |
| Character | Meaning |
x* | Matches the preceding item x 0 or more times. For example, |
x+ | Matches the preceding item x 1 or more times. Equivalent to For example, |
x? | Matches the preceding item x 0 or 1 time. For example, If used immediately after any of the quantifiers |
x{n} | Where For example, |
x{n,} | Where For example, |
x{n,m} | Where For example, |
|
| Matches the preceding item x like For example, Quantifiers without |
| Assertions | |
| Character | Meaning |
x(?=y) | Matches For example, / |
x(?!y) | Matches For example, |
RegExp.prototypeRegExp.lengthRegExp.length is 2.get RegExp[@@species]RegExp.lastIndexThe global RegExp object has no methods of its own, however, it does inherit some methods through the prototype chain.
RegExp prototype objects and instancesSee also deprecated RegExp properties.
Note that several of the RegExp properties have both long and short (Perl-like) names. Both names always refer to the same value. Perl is the programming language from which JavaScript modeled its regular expressions.
RegExp.prototype.constructorRegExp.prototype.flagsRegExp object.RegExp.prototype.globalRegExp.prototype.ignoreCaseRegExp.prototype.multilineRegExp.prototype.sourceRegExp.prototype.stickyRegExp.prototype.unicodeRegExp.prototype.compile() \nRegExp.prototype.exec()RegExp.prototype.test()RegExp.prototype[@@match]()RegExp.prototype[@@replace]()RegExp.prototype[@@search]()RegExp.prototype[@@split]()RegExp.prototype.toSource() \nObject.prototype.toSource() method.RegExp.prototype.toString()Object.prototype.toString() method.The following script uses the replace() method of the String instance to match a name in the format first last and output it in the format last, first. In the replacement text, the script uses $1 and $2 to indicate the results of the corresponding matching parentheses in the regular expression pattern.
var re = /(\\w+)\\s(\\w+)/;\nvar str = 'John Smith';\nvar newstr = str.replace(re, '$2, $1');\nconsole.log(newstr);\n
This displays \"Smith, John\".
The default line ending varies depending on the platform (Unix, Windows, etc.). The line splitting provided in this example works on all platforms.
var text = 'Some text\\nAnd some more\\r\\nAnd yet\\rThis is the end';\nvar lines = text.split(/\\r\\n|\\r|\\n/);\nconsole.log(lines); // logs [ 'Some text', 'And some more', 'And yet', 'This is the end' ]\n
Note that the order of the patterns in the regular expression matters.
var s = 'Please yes\\nmake my day!';\ns.match(/yes.*day/);\n// Returns null\ns.match(/yes[^]*day/);\n// Returns [\"yes\\nmake my day\"]\n
The sticky flag indicates that the regular expression performs sticky matching in the target string by attempting to match starting at RegExp.prototype.lastIndex.
var str = '#foo#';\nvar regex = /foo/y;\n\nregex.lastIndex = 1;\nregex.test(str); // true\nregex.lastIndex = 5;\nregex.test(str); // false (lastIndex is taken into account with sticky flag)\nregex.lastIndex; // 0 (reset after match failure)
As mentioned above, \\w or \\W only matches ASCII based characters; for example, \"a\" to \"z\", \"A\" to \"Z\", \"0\" to \"9\" and \"_\". To match characters from other languages such as Cyrillic or Hebrew, use \\uhhhh, where \"hhhh\" is the character's Unicode value in hexadecimal. This example demonstrates how one can separate out Unicode characters from a word.
var text = 'Образец text на русском языке';\nvar regex = /[\\u0400-\\u04FF]+/g;\n\nvar match = regex.exec(text);\nconsole.log(match[0]); // logs 'Образец'\nconsole.log(regex.lastIndex); // logs '7'\n\nvar match2 = regex.exec(text);\nconsole.log(match2[0]); // logs 'на' [did not log 'text']\nconsole.log(regex.lastIndex); // logs '15'\n\n// and so on\n
Here's an external resource for getting the complete Unicode block range for different scripts: Regexp-Unicode-block.
var url = 'http://xxx.domain.com';\nconsole.log(/[^.]+/.exec(url)[0].substr(7)); // logs 'xxx'\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp' in that specification. | Standard | The RegExp constructor no longer throws when the first argument is a RegExp and the second argument is present. Introduces Unicode and sticky flags. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ncompile \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
exec | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
flags | \nYes | \nYes | \n37 | \nNo | \nYes | \nYes | \n
global | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
ignoreCase | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nRegExp.input ($_) \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
lastIndex | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nRegExp.lastMatch ($&) \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nRegExp.lastParen ($+) \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nRegExp.leftContext ($`) \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
lookbehind assertions ((?<= ) and (?<! )) | \n62 | \n? | \n? | \n? | \n49 | \n? | \n
multiline | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nRegExp.$1-$9 \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nRegExp.rightContext ($') \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
source | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
sticky | \n49 | \n13 | \n3 | \nNo | \n36 | \n10 | \n
test | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
unicode | \n50 | \n 12\n
| \n46 | \nNo | \n37 | \n10 | \n
@@match | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
@@replace | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
@@search | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
@@species | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
@@split | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ncompile \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
exec | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
flags | \nYes | \nYes | \nYes | \n37 | \nYes | \nYes | \nYes | \n
global | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
ignoreCase | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nRegExp.input ($_) \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
lastIndex | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nRegExp.lastMatch ($&) \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nRegExp.lastParen ($+) \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nRegExp.leftContext ($`) \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
lookbehind assertions ((?<= ) and (?<! )) | \n62 | \n62 | \n? | \n? | \n49 | \n? | \n? | \n
multiline | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nRegExp.$1-$9 \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nRegExp.rightContext ($') \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
source | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
sticky | \n49 | \n49 | \nYes | \n4 | \n36 | \n10 | \n5.0 | \n
test | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
unicode | \nYes | \n50 | \nYes | \n46 | \n37 | \n10 | \n5.0 | \n
@@match | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
@@replace | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
@@search | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
@@species | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
@@split | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\ncompile \n | \nYes | \n
exec | \nYes | \n
flags | \n6.0.0 | \n
global | \nYes | \n
ignoreCase | \nYes | \n
\nRegExp.input ($_) \n | \nYes | \n
lastIndex | \nYes | \n
\nRegExp.lastMatch ($&) \n | \nYes | \n
\nRegExp.lastParen ($+) \n | \nYes | \n
\nRegExp.leftContext ($`) \n | \nYes | \n
lookbehind assertions ((?<= ) and (?<! )) | \n? | \n
multiline | \nYes | \n
\nRegExp.$1-$9 \n | \nYes | \n
prototype | \nYes | \n
\nRegExp.rightContext ($') \n | \nYes | \n
source | \nYes | \n
sticky | \nYes | \n
test | \nYes | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
unicode | \nYes | \n
@@match | \n6.0.0 | \n
@@replace | \n6.0.0 | \n
@@search | \n6.0.0 | \n
@@species | \n 6.5.0\n
| \n
@@split | \n6.0.0 | \n
Starting with Firefox 34, in the case of a capturing group with quantifiers preventing its exercise, the matched text for a capturing group is now undefined instead of an empty string:
// Firefox 33 or older\n'x'.replace(/x(.)?/g, function(m, group) {\n console.log(\"'group:\" + group + \"'\");\n}); // 'group:'\n\n// Firefox 34 or newer\n'x'.replace(/x(.)?/g, function(m, group) {\n console.log(\"'group:\" + group + \"'\");\n}); // 'group:undefined'\n Note that due to web compatibility, RegExp.$N will still return an empty string instead of undefined (bug 1053944).
String.prototype.match()String.prototype.replace()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp\n
The encodeURI() function encodes a Uniform Resource Identifier (URI) by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two \"surrogate\" characters).
encodeURI(URI)
URIA new string representing the provided string encoded as a Uniform Resource Identifier (URI).
Does not encode characters that have special meaning (reserved characters) for a URI. The following example shows all the parts that a URI \"scheme\" can possibly contain. Note how certain characters are used to signify special meaning:
http://username:password@www.example.com:80/path/to/file.php?foo=316&bar=this+has+spaces#anchor
Hence encodeURI does not encode characters that are necessary to formulate a complete URI. Also, encodeURI does not encode a few additional characters, known as \"unreserved marks\", which do not have a reserved purpose but are allowed in a URI \"as is\". (See RFC2396)
encodeURI escapes all characters except:
Not Escaped:\n\n A-Z a-z 0-9 ; , / ? : @ & = + $ - _ . ! ~ * ' ( ) #\n\n
encodeURI differs from encodeURIComponent as follows:
var set1 = \";,/?:@&=+$#\"; // Reserved Characters\nvar set2 = \"-_.!~*'()\"; // Unreserved Marks\nvar set3 = \"ABC abc 123\"; // Alphanumeric Characters + Space\n\nconsole.log(encodeURI(set1)); // ;,/?:@&=+$#\nconsole.log(encodeURI(set2)); // -_.!~*'()\nconsole.log(encodeURI(set3)); // ABC%20abc%20123 (the space gets encoded as %20)\n\nconsole.log(encodeURIComponent(set1)); // %3B%2C%2F%3F%3A%40%26%3D%2B%24%23\nconsole.log(encodeURIComponent(set2)); // -_.!~*'()\nconsole.log(encodeURIComponent(set3)); // ABC%20abc%20123 (the space gets encoded as %20)\n\n
Note that a URIError will be thrown if one attempts to encode a surrogate which is not part of a high-low pair, e.g.,
// high-low pair ok\nconsole.log(encodeURIComponent('\\uD800\\uDFFF'));\n\n// lone high surrogate throws \"URIError: malformed URI sequence\"\nconsole.log(encodeURIComponent('\\uD800'));\n\n// lone low surrogate throws \"URIError: malformed URI sequence\"\nconsole.log(encodeURIComponent('\\uDFFF')); \n Note that encodeURI by itself cannot form proper HTTP GET and POST requests, such as for XMLHTTPRequests, because \"&\", \"+\", and \"=\" are not encoded, which are treated as special characters in GET and POST requests. encodeURIComponent, however, does encode these characters.
Note that an URIError will be thrown if one attempts to encode a surrogate which is not part of a high-low pair, e.g.,
// high-low pair ok\nconsole.log(encodeURI('\\uD800\\uDFFF'));\n\n// lone high surrogate throws \"URIError: malformed URI sequence\"\nconsole.log(encodeURI('\\uD800'));\n\n// lone low surrogate throws \"URIError: malformed URI sequence\"\nconsole.log(encodeURI('\\uDFFF')); Also note that if one wishes to follow the more recent RFC3986 for URLs, which makes square brackets reserved (for IPv6) and thus not encoded when forming something which could be part of a URL (such as a host), the following code snippet may help:
function fixedEncodeURI(str) {\n return encodeURI(str).replace(/%5B/g, '[').replace(/%5D/g, ']');\n} Alternative URI encoding scheme is Base62x, which has been ported into NPM.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'encodeURI' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'encodeURI' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'encodeURI' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURI\n
The encodeURIComponent() function encodes a Uniform Resource Identifier (URI) component by replacing each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character (will only be four escape sequences for characters composed of two \"surrogate\" characters).
encodeURIComponent(str);
strA new string representing the provided string encoded as a Uniform Resource Identifier (URI) component.
encodeURIComponent escapes all characters except:
Not Escaped:\n\n A-Z a-z 0-9 - _ . ! ~ * ' ( )\n\n
encodeURIComponent differs from encodeURI as follows:
var set1 = \";,/?:@&=+$\"; // Reserved Characters\nvar set2 = \"-_.!~*'()\"; // Unescaped Characters\nvar set3 = \"#\"; // Number Sign\nvar set4 = \"ABC abc 123\"; // Alphanumeric Characters + Space\n\nconsole.log(encodeURI(set1)); // ;,/?:@&=+$\nconsole.log(encodeURI(set2)); // -_.!~*'()\nconsole.log(encodeURI(set3)); // #\nconsole.log(encodeURI(set4)); // ABC%20abc%20123 (the space gets encoded as %20)\n\nconsole.log(encodeURIComponent(set1)); // %3B%2C%2F%3F%3A%40%26%3D%2B%24\nconsole.log(encodeURIComponent(set2)); // -_.!~*'()\nconsole.log(encodeURIComponent(set3)); // %23\nconsole.log(encodeURIComponent(set4)); // ABC%20abc%20123 (the space gets encoded as %20)\n\n
Note that a URIError will be thrown if one attempts to encode a surrogate which is not part of a high-low pair, e.g.,
// high-low pair ok\nconsole.log(encodeURIComponent('\\uD800\\uDFFF'));\n\n// lone high surrogate throws \"URIError: malformed URI sequence\"\nconsole.log(encodeURIComponent('\\uD800'));\n\n// lone low surrogate throws \"URIError: malformed URI sequence\"\nconsole.log(encodeURIComponent('\\uDFFF')); \n Use encodeURIComponent on user-entered fields from forms POST'd to the server. This will encode \"&\" symbols that may inadvertently be generated during data entry for special HTML entities or other characters that require encoding/decoding.
For example, if a user writes \"Jack & Jill\", the text may get encoded as \"Jack & Jill\". Without encodeURIComponent the ampersand could be interpretted on the server as the start of a new field and jeopardize the integrity of the data.
For application/x-www-form-urlencoded, spaces are to be replaced by '+', so one may wish to follow a encodeURIComponent replacement with an additional replacement of \"%20\" with \"+\".
To be more stringent in adhering to RFC 3986 (which reserves !, ', (, ), and *), even though these characters have no formalized URI delimiting uses, the following can be safely used:
function fixedEncodeURIComponent(str) {\n return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {\n return '%' + c.charCodeAt(0).toString(16);\n });\n}\n The following example provides the special encoding required within UTF-8 Content-Disposition and Link server response header parameters (e.g., UTF-8 filenames):
var fileName = 'my file(2).txt';\nvar header = \"Content-Disposition: attachment; filename*=UTF-8''\" \n + encodeRFC5987ValueChars(fileName);\n\nconsole.log(header); \n// logs \"Content-Disposition: attachment; filename*=UTF-8''my%20file%282%29.txt\"\n\n\nfunction encodeRFC5987ValueChars(str) {\n return encodeURIComponent(str).\n // Note that although RFC3986 reserves \"!\", RFC5987 does not,\n // so we do not need to escape it\n replace(/['()]/g, escape). // i.e., %27 %28 %29\n replace(/\\*/g, '%2A').\n // The following are not required for percent-encoding per RFC5987, \n // so we can allow for a little better readability over the wire: |`^\n replace(/%(?:7C|60|5E)/g, unescape);\n}\n\n// here is an alternative to the above function\nfunction encodeRFC5987ValueChars2(str) {\n return encodeURIComponent(str).\n // Note that although RFC3986 reserves \"!\", RFC5987 does not,\n // so we do not need to escape it\n replace(/['()*]/g, c => \"%\" + c.charCodeAt(0).toString(16)). // i.e., %27 %28 %29 %2A\n // The following are not required for percent-encoding per RFC5987,\n // so we can allow for a little better readability over the wire: |`^\n replace(/%(7C|60|5E)/g, (str, hex) => String.fromCharCode(parseInt(hex, 16)));\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'encodeURIComponent' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'encodeURIComponent' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'encodeURIComponent' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent\n
The eval() function evaluates JavaScript code represented as a string.
eval(string)
stringThe completion value of evaluating the given code. If the completion value is empty, undefined is returned.
eval() is a function property of the global object.
The argument of the eval() function is a string. If the string represents an expression, eval() evaluates the expression. If the argument represents one or more JavaScript statements, eval() evaluates the statements. Do not call eval() to evaluate an arithmetic expression; JavaScript evaluates arithmetic expressions automatically.
If you construct an arithmetic expression as a string, you can use eval() to evaluate it at a later time. For example, suppose you have a variable x. You can postpone evaluation of an expression involving x by assigning the string value of the expression, say \"3 * x + 2\", to a variable, and then calling eval() at a later point in your script.
If the argument of eval() is not a string, eval() returns the argument unchanged. In the following example, the String constructor is specified and eval() returns a String object rather than evaluating the string.
eval(new String('2 + 2')); // returns a String object containing \"2 + 2\"\neval('2 + 2'); // returns 4\n You can work around this limitation in a generic fashion by using toString().
var expression = new String('2 + 2');\neval(expression.toString());\n If you use the eval function indirectly, by invoking it via a reference other than eval, as of ECMAScript 5 it works in the global scope rather than the local scope. This means, for instance, that function declarations create global functions, and that the code being evaluated doesn't have access to local variables within the scope where it's being called.
function test() {\n var x = 2, y = 4;\n console.log(eval('x + y')); // Direct call, uses local scope, result is 6\n var geval = eval; // equivalent to calling eval in the global scope\n console.log(geval('x + y')); // Indirect call, uses global scope, throws ReferenceError because `x` is undefined\n (0, eval)('x + y'); // another example of Indirect call\n}\n eval!eval() is a dangerous function, which executes the code it's passed with the privileges of the caller. If you run eval() with a string that could be affected by a malicious party, you may end up running malicious code on the user's machine with the permissions of your webpage / extension. More importantly, a third-party code can see the scope in which eval() was invoked, which can lead to possible attacks in ways to which the similar Function is not susceptible.
eval() is also slower than the alternatives, since it has to invoke the JS interpreter, while many other constructs are optimized by modern JS engines.
Additionally, modern javascript interpreters convert javascript to machine code. This means that any concept of variable naming gets obliterated. Thus, any use of eval will force the browser to do long expensive variable name lookups to figure out where the variable exists in the machine code and set it's value. Additonally, new things can be introduced to that variable through eval() such as changing the type of that variable, forcing the browser to reevaluate all of the generated machine code to compensate. However, there (thankfully) exists a very good alternative to eval: simply using window.Function. As an example of how you convert code using evil eval() to using Function(), see below.
Bad code with eval:
function looseJsonParse(obj){\n return eval(obj);\n}\nconsole.log(looseJsonParse(\n \"{a:(4-1), b:function(){}, c:new Date()}\"\n))\n Better code without eval:
function looseJsonParse(obj){\n return Function('\"use strict\";return (' + obj + ')')();\n}\nconsole.log(looseJsonParse(\n \"{a:(4-1), b:function(){}, c:new Date()}\"\n))\n Comparing the two code snippets above, the two code snippets might seem to work the same way, but think again: the eval one is a huge amount slower. Notice c: new Date() in the evaluated object. In the function without the eval, the object is being evaluated in the global scope, so it is safe for the browser to assume that Date refers to window.Date instead of a local variable called Date. But, in the code using eval(), the browser cannot assume this since what if your code looked like the following:
function Date(n){\n return [\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\",\"Sunday\"][n%7 || 0];\n}\nfunction looseJsonParse(obj){\n return eval(obj);\n}\nconsole.log(looseJsonParse(\n \"{a:(4-1), b:function(){}, c:new Date()}\"\n))\n Thus, in the eval() version of the code, the browser is forced to make the expensive lookup call to check to see if there are any local variables called Date(). This is incredibly innefficient compared to Function().
In a related circumstance, what if you actually wanted your Date function to be able to be called from the code inside Function(). Should you just wimp out and fall back to eval()? Absolutely not, never ever. Instead try the approach below.
function Date(n){\n return [\"Monday\",\"Tuesday\",\"Wednesday\",\"Thursday\",\"Friday\",\"Saturday\",\"Sunday\"][n%7 || 0];\n}\nfunction runCodeWithDateFunction(obj){\n return Function('\"use strict\";return (' + obj + ')')()(\n Date\n );\n}\nconsole.log(runCodeWithDateFunction(\n \"function(Date){ return Date(5) }\"\n))\n The code above may seem inefficiently slow because of the triple nested function, but let's analyse the benefits of the above efficient method:
1. It allows the code in the string passed to runCodeWithDateFunction to be minified.
2. Function call overhead is minimal, making the far smaller code size well worth the benefit
3. Function() more easily allows your code to utilize the performance buttering \"use strict\";
4. The code does not use eval(), making it orders of magnitude faster than otherwise.
Lastly, let's examine minification. With using Function() as shown above, you can minify the code string passed to runCodeWithDateFunction far more efficiently because the function arguments names can be minified too as seen in the minified code below.
console.log(Function('\"use strict\";return(function(a){return a(5)})')()(function(a){\nreturn\"Monday Tuesday Wednesday Thursday Friday Saturday Sunday\".split(\" \")[a%7||0]})); There are also additional safer (and faster!) alternatives to eval() or Function() for common use-cases.
You should not use eval() to convert property names into properties. Consider the following example where the property of the object to be accessed is not known until the code is executed. This can be done with eval:
var obj = { a: 20, b: 30 };\nvar propName = getPropName(); // returns \"a\" or \"b\"\n\neval( 'var result = obj.' + propName );\n However, eval() is not necessary here. In fact, its use here is discouraged. Instead, use the property accessors, which are much faster and safer:
var obj = { a: 20, b: 30 };\nvar propName = getPropName(); // returns \"a\" or \"b\"\nvar result = obj[ propName ]; // obj[ \"a\" ] is the same as obj.a You can even use this method to access descendant properties. Using eval() this would look like:
var obj = {a: {b: {c: 0}}};\nvar propPath = getPropPath(); // returns e.g. \"a.b.c\"\n\neval( 'var result = obj.' + propPath );\n Avoiding eval() here could be done by splitting the property path and looping through the different properties:
function getDescendantProp(obj, desc) {\n var arr = desc.split('.');\n while (arr.length) {\n obj = obj[arr.shift()];\n }\n return obj;\n}\n\nvar obj = {a: {b: {c: 0}}};\nvar propPath = getPropPath(); // returns e.g. \"a.b.c\"\nvar result = getDescendantProp(obj, propPath); Setting a property that way works similarly:
function setDescendantProp(obj, desc, value) {\n var arr = desc.split('.');\n while (arr.length > 1) {\n obj = obj[arr.shift()];\n }\n return obj[arr[0]] = value;\n}\n\nvar obj = {a: {b: {c: 0}}};\nvar propPath = getPropPath(); // returns e.g. \"a.b.c\"\nvar result = setDescendantProp(obj, propPath, 1); // test.a.b.c will now be 1 JavaScript has first-class functions, which means you can pass functions as arguments to other APIs, store them in variables and objects' properties, and so on. Many DOM APIs are designed with this in mind, so you can (and should) write:
// instead of setTimeout(\" ... \", 1000) use:\nsetTimeout(function() { ... }, 1000); \n\n// instead of elt.setAttribute(\"onclick\", \"...\") use:\nelt.addEventListener('click', function() { ... } , false); Closures are also helpful as a way to create parameterized functions without concatenating strings.
If the string you're calling eval() on contains data (for example, an array: \"[1, 2, 3]\"), as opposed to code, you should consider switching to JSON, which allows the string to use a subset of JavaScript syntax to represent data. See also Downloading JSON and JavaScript in extensions.
Note that since JSON syntax is limited compared to JavaScript syntax, many valid JavaScript literals will not parse as JSON. For example, trailing commas are not allowed in JSON, and property names (keys) in object literals must be enclosed in quotes. Be sure to use a JSON serializer to generate strings that will be later parsed as JSON.
For example, an extension designed to scrape contents of web-pages could have the scraping rules defined in XPath instead of JavaScript code.
If you must run the code, consider running it with reduced privileges. This advice applies mainly to extensions and XUL applications, which can use Components.utils.evalInSandbox for this.
eval\nIn the following code, both of the statements containing eval() return 42. The first evaluates the string \"x + y + 1\"; the second evaluates the string \"42\".
var x = 2;\nvar y = 39;\nvar z = '42';\neval('x + y + 1'); // returns 42\neval(z); // returns 42 \n eval to evaluate a string of JavaScript statementsThe following example uses eval() to evaluate the string str. This string consists of JavaScript statements that open an alert dialog box and assign z a value of 42 if x is five, and assigns 0 to z otherwise. When the second statement is executed, eval() will cause these statements to be performed, and it will also evaluate the set of statements and return the value that is assigned to z.
var x = 5;\nvar str = \"if (x == 5) {console.log('z is 42'); z = 42;} else z = 0;\";\n\nconsole.log('z is ', eval(str)); If you define multiple values then the last value is returned.
var x = 5;\nvar str = \"if (x == 5) {console.log('z is 42'); z = 42; x = 420; } else z = 0;\"; \n\nconsole.log('x is ', eval(str)); // z is 42 x is 420 \n eval() returns the value of the last expression evaluated.
var str = 'if ( a ) { 1 + 1; } else { 1 + 2; }';\nvar a = true;\nvar b = eval(str); // returns 2\n \nconsole.log('b is : ' + b);\n\na = false;\nb = eval(str); // returns 3\n\nconsole.log('b is : ' + b); eval as a string defining function requires \"(\" and \")\" as prefix and suffixvar fctStr1 = 'function a() {}'\nvar fctStr2 = '(function a() {})'\nvar fct1 = eval(fctStr1) // return undefined\nvar fct2 = eval(fctStr2) // return a function\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'eval' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'eval' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'eval' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
eval() had an optional second argument, specifying an object in whose context the evaluation was to be performed. This argument was non-standard, and was definitely removed from Firefox 4. See bug 531675.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval\n
The WebAssembly JavaScript object acts as the namespace for all WebAssembly-related functionality.
Unlike most other global objects, WebAssembly is not a constructor (it is not a function object). You can compare it to Math, which is also a namespace object for mathematical constants and functions, or to Intl which is the namespace object for internationalization constructors and other language sensitive functions.
The primary uses for the WebAssembly object are:
WebAssembly.instantiate() function.WebAssembly.Memory()/WebAssembly.Table() constructors.WebAssembly.CompileError()/WebAssembly.LinkError()/WebAssembly.RuntimeError() constructors.WebAssembly.instantiate()Module and its first Instance.WebAssembly.instantiateStreaming()Module and its first Instance.WebAssembly.compile()WebAssembly.Module from WebAssembly binary code, leaving instantiation as a separate step.WebAssembly.compileStreaming()WebAssembly.Module directly from a streamed underlying source, leaving instantiation as a separate step.WebAssembly.validate()true) or not (false).WebAssembly.Global()Global object.WebAssembly.Module()Module object.WebAssembly.Instance()Instance object.WebAssembly.Memory()Memory object.WebAssembly.Table()Table object.WebAssembly.CompileError()CompileError object.WebAssembly.LinkError()LinkError object.WebAssembly.RuntimeError()RuntimeError object.The following example (see our instantiate-streaming.html demo on GitHub, and view it live also) directly streams a .wasm module from an underlying source then compiles and instantiates it, the promise fulfilling with a ResultObject. Because the instantiateStreaming() function accepts a promise for a Response object, you can directly pass it a WindowOrWorkerGlobalScope.fetch() call, and it will pass the response into the function when it fulfills.
var importObject = { imports: { imported_func: arg => console.log(arg) } };\n\nWebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)\n.then(obj => obj.instance.exports.exported_func()); The ResultObject's instance member is then accessed, and the contained exported function invoked.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
CompileError | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
Global | \n69 | \nNo | \n62 | \nNo | \nNo | \nNo | \n
Instance | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
LinkError | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
Memory | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
Module | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
RuntimeError | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
Table | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
compile | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
compileStreaming | \n61 | \n16 | \n58 | \nNo | \n47 | \nNo | \n
instantiate | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
instantiateStreaming | \n61 | \n16 | \n58 | \nNo | \n47 | \nNo | \n
validate | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
CompileError | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
Global | \n69 | \n69 | \nNo | \n62 | \nNo | \nNo | \nNo | \n
Instance | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
LinkError | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
Memory | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
Module | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
RuntimeError | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
Table | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
compile | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n44 | \n11 | \n7.0 | \n
compileStreaming | \n61 | \n61 | \nNo | \n58 | \n? | \nNo | \nNo | \n
instantiate | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
instantiateStreaming | \n61 | \n61 | \nNo | \n58 | \n? | \nNo | \nNo | \n
validate | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
CompileError | \n8.0.0 | \n
Global | \nNo | \n
Instance | \n8.0.0 | \n
LinkError | \n8.0.0 | \n
Memory | \n8.0.0 | \n
Module | \n8.0.0 | \n
RuntimeError | \n8.0.0 | \n
Table | \n8.0.0 | \n
compile | \n8.0.0 | \n
compileStreaming | \nNo | \n
instantiate | \n8.0.0 | \n
instantiateStreaming | \nNo | \n
validate | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly\n
The parseFloat() function parses an argument and returns a floating point number.
parseFloat(value)
valueA floating point number parsed from the given value. If the value cannot be converted to a number, NaN is returned.
parseFloat is a top-level function and is not associated with any object.
parseFloat parses its argument, and returns a floating point number. If it encounters a character other than a sign (+ or -), numeral (0-9), a decimal point, or an exponent, it returns the value up to that point and ignores that character and all succeeding characters. Leading and trailing spaces are allowed.
If the value is a string and first character cannot be converted to a number, parseFloat returns NaN.
For arithmetic purposes, the NaN value is not a number in any radix. You can call the isNaN function to determine if the result of parseFloat is NaN. If NaN is passed on to arithmetic operations, the operation results will also be NaN.
parseFloat can also parse and return the value Infinity. You can use the isFinite function to determine if the result is a finite number (not Infinity, -Infinity, or NaN).
parseFloat is also able to parse an object if it has a toString or valueOf method defined. The returned value is the same as if parseFloat had been called on the result of calling that method.
parseFloat returning a numberThe following examples all return 3.14
parseFloat(3.14);\nparseFloat('3.14');\nparseFloat('314e-2');\nparseFloat('0.0314E+2');\nparseFloat('3.14more non-digit characters');\n\nvar foo = Object.create(null);\nfoo.toString = function () { return \"3.14\"; };\nparseFloat(foo);\n\nvar foo = Object.create(null);\nfoo.valueOf = function () { return \"3.14\"; }; \nparseFloat(foo); parseFloat returning NaNThe following example returns NaN
parseFloat('FF2');\n It is sometime useful to have a stricter way to parse float values, regular expressions can help :
var filterFloat = function(value) {\n if (/^(\\-|\\+)?([0-9]+(\\.[0-9]+)?|Infinity)$/\n .test(value))\n return Number(value);\n return NaN;\n}\n\nconsole.log(filterFloat('421')); // 421\nconsole.log(filterFloat('-421')); // -421\nconsole.log(filterFloat('+421')); // 421\nconsole.log(filterFloat('Infinity')); // Infinity\nconsole.log(filterFloat('1.61803398875')); // 1.61803398875\nconsole.log(filterFloat('421e+0')); // NaN\nconsole.log(filterFloat('421hop')); // NaN\nconsole.log(filterFloat('hop1.61803398875')); // NaN\n\n Note that this code is an example only; it does not accept valid numbers such as 1. or .5.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'parseFloat' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'parseFloat' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'parseFloat' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseFloat\n
The isNaN() function determines whether a value is NaN or not. Note: coercion inside the isNaN function has interesting rules; you may alternatively want to use Number.isNaN(), as defined in ECMAScript 2015.
isNaN(value)
valuetrue if the given value is NaN; otherwise, false.
isNaN functionUnlike all other possible values in JavaScript, it is not possible to rely on the equality operators (== and ===) to determine whether a value is NaN or not, because both NaN == NaN and NaN === NaN evaluate to false. Hence, the necessity of an isNaN function.
NaN valuesNaN values are generated when arithmetic operations result in undefined or unrepresentable values. Such values do not necessarily represent overflow conditions. A NaN also results from attempted coercion to numeric values of non-numeric values for which no primitive numeric value is available.
For example, dividing zero by zero results in a NaN — but dividing other numbers by zero does not.
Since the very earliest versions of the isNaN function specification, its behavior for non-numeric arguments has been confusing. When the argument to the isNaN function is not of type Number, the value is first coerced to a Number. The resulting value is then tested to determine whether it is NaN. Thus for non-numbers that when coerced to numeric type result in a valid non-NaN numeric value (notably the empty string and boolean primitives, which when coerced give numeric values zero or one), the \"false\" returned value may be unexpected; the empty string, for example, is surely \"not a number.\" The confusion stems from the fact that the term, \"not a number\", has a specific meaning for numbers represented as IEEE-754 floating-point values. The function should be interpreted as answering the question, \"is this value, when coerced to a numeric value, an IEEE-754 'Not A Number' value?\"
The latest version of ECMAScript (ES2015) contains the Number.isNaN() function. Number.isNaN(x) will be a reliable way to test whether x is NaN or not. Even with Number.isNaN, however, the meaning of NaN remains the precise numeric meaning, and not simply, \"not a number\". Alternatively, in absense of Number.isNaN, the expression (x != x) is a more reliable way to test whether variable x is NaN or not, as the result is not subject to the false positives that make isNaN unreliable.
A polyfill for isNaN would be (the polyfill leverages the unique never-equal-to-itself characteristic of NaN):
var isNaN = function(value) {\n var n = Number(value);\n return n !== n;\n}; isNaN(NaN); // true\nisNaN(undefined); // true\nisNaN({}); // true\n\nisNaN(true); // false\nisNaN(null); // false\nisNaN(37); // false\n\n// strings\nisNaN('37'); // false: \"37\" is converted to the number 37 which is not NaN\nisNaN('37.37'); // false: \"37.37\" is converted to the number 37.37 which is not NaN\nisNaN(\"37,5\"); // true\nisNaN('123ABC'); // true: parseInt(\"123ABC\") is 123 but Number(\"123ABC\") is NaN\nisNaN(''); // false: the empty string is converted to 0 which is not NaN\nisNaN(' '); // false: a string with spaces is converted to 0 which is not NaN\n\n// dates\nisNaN(new Date()); // false\nisNaN(new Date().toString()); // true\n\n// This is a false positive and the reason why isNaN is not entirely reliable\nisNaN('blabla'); // true: \"blabla\" is converted to a number. \n // Parsing this as a number fails and returns NaN\n There is a more usage oriented way to think of isNaN(): If isNaN(x) returns false, you can use x in an arithmetic expression not making the expression return NaN. If it returns true, x will make every arithmetic expression return NaN. This means that in JavaScript, isNaN(x) == true is equivalent to x - 0 returning NaN (though in JavaScript x - 0 == NaN always returns false, so you can't test for it). Actually, isNaN(x), isNaN(x - 0), isNaN(Number(x)), Number.isNaN(x - 0), and Number.isNaN(Number(x)) always return the same and in JavaScript isNaN(x) is just the shortest possible form to express each of these terms.
You can use this, for example, to test whether an argument to a function is arithmetically processable (usable \"like\" a number), or if it's not and you have to provide a default value or something else. This way you can have a function that makes use of the full versatility JavaScript provides by implicitly converting values depending on context.
function increment(x) {\n if (isNaN(x)) x = 0;\n return x + 1;\n}\n\n// The same effect with Number.isNaN():\nfunction increment(x) {\n if (Number.isNaN(Number(x))) x = 0;\n return x + 1;\n}\n\n// In the following cases for the function's argument x,\n// isNaN(x) is always false, although x is indeed not a\n// number, but can be used as such in arithmetical\n// expressions\nincrement(''); // 1: \"\" is converted to 0\nincrement(new String()); // 1: String object representing an empty string is converted to 0\nincrement([]); // 1: [] is converted to 0\nincrement(new Array()); // 1: Array object representing an empty array is converted to 0\nincrement('0'); // 1: \"0\" is converted to 0\nincrement('1'); // 2: \"1\" is converted to 1\nincrement('0.1'); // 1.1: \"0.1\" is converted to 0.1\nincrement('Infinity'); // Infinity: \"Infinity\" is converted to Infinity\nincrement(null); // 1: null is converted to 0\nincrement(false); // 1: false is converted to 0\nincrement(true); // 2: true is converted to 1\nincrement(new Date()); // returns current date/time in milliseconds plus 1\n\n// In the following cases for the function's argument x,\n// isNaN(x) is always false and x is indeed a number\nincrement(-1); // 0\nincrement(-0.1); // 0.9\nincrement(0); // 1\nincrement(1); // 2\nincrement(2); // 3\n// ... and so on ...\nincrement(Infinity); // Infinity\n\n// In the following cases for the function's argument x,\n// isNaN(x) is always true and x is really not a number,\n// thus the function replaces it by 0 and returns 1\nincrement(String); // 1\nincrement(Array); // 1\nincrement('blabla'); // 1\nincrement('-blabla'); // 1\nincrement(0 / 0); // 1\nincrement('0 / 0'); // 1\nincrement(Infinity / Infinity); // 1\nincrement(NaN); // 1\nincrement(undefined); // 1\nincrement(); // 1\n\n// isNaN(x) is always the same as isNaN(Number(x)),\n// but the presence of x is mandatory here!\nisNaN(x) == isNaN(Number(x)); // true for every value of x, including x == undefined,\n // because isNaN(undefined) == true and Number(undefined) returns NaN,\n // but ...\nisNaN() == isNaN(Number()); // false, because isNaN() == true and Number() == 0\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'isNaN' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'isNaN' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'isNaN' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN\n
Non-standard
This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.
The uneval() function creates a string representation of the source code of an Object.
uneval(object)
objectA string representing the source code of the given Object.
uneval() is a top-level function and is not associated with any object.
var a = 1;\nuneval(a); // returns a String containing 1\n\nvar b = '1';\nuneval(b); // returns a String containing \"1\"\n\nuneval(function foo() {}); // returns \"(function foo(){})\"\n\n\nvar a = uneval(function foo() { return 'hi'; });\nvar foo = eval(a);\nfoo(); // returns \"hi\"\n Not part of any specifications.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/uneval\n
The JavaScript Array object is a global object that is used in the construction of arrays; which are high-level, list-like objects.
Create an Array
var fruits = ['Apple', 'Banana'];\n\nconsole.log(fruits.length);\n// 2\n
Access (index into) an Array item
var first = fruits[0];\n// Apple\n\nvar last = fruits[fruits.length - 1];\n// Banana\n
Loop over an Array
fruits.forEach(function(item, index, array) {\n console.log(item, index);\n});\n// Apple 0\n// Banana 1\n Add to the end of an Array
var newLength = fruits.push('Orange');\n// [\"Apple\", \"Banana\", \"Orange\"]\n Remove from the end of an Array
var last = fruits.pop(); // remove Orange (from the end)\n// [\"Apple\", \"Banana\"];\n
Remove from the front of an Array
var first = fruits.shift(); // remove Apple from the front\n// [\"Banana\"];\n
Add to the front of an Array
var newLength = fruits.unshift('Strawberry') // add to the front\n// [\"Strawberry\", \"Banana\"];\n Find the index of an item in the Array
fruits.push('Mango');\n// [\"Strawberry\", \"Banana\", \"Mango\"]\n\nvar pos = fruits.indexOf('Banana');\n// 1\n Remove an item by index position
var removedItem = fruits.splice(pos, 1); // this is how to remove an item\n \n// [\"Strawberry\", \"Mango\"]
Remove items from an index position
var vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot'];\nconsole.log(vegetables); \n// [\"Cabbage\", \"Turnip\", \"Radish\", \"Carrot\"]\n\nvar pos = 1, n = 2;\n\nvar removedItems = vegetables.splice(pos, n); \n// this is how to remove items, n defines the number of items to be removed,\n// from that position(pos) onward to the end of array.\n\nconsole.log(vegetables); \n// [\"Cabbage\", \"Carrot\"] (the original array is changed)\n\nconsole.log(removedItems); \n// [\"Turnip\", \"Radish\"]
Copy an Array
var shallowCopy = fruits.slice(); // this is how to make a copy\n// [\"Strawberry\", \"Mango\"]\n
[element0, element1, ..., elementN]\nnew Array(element0, element1[, ...[, elementN]])\nnew Array(arrayLength)
elementNArray constructor and that argument is a number (see the arrayLength parameter below). Note that this special case only applies to JavaScript arrays created with the Array constructor, not array literals created with the bracket syntax.arrayLengthArray constructor is an integer between 0 and 232-1 (inclusive), this returns a new JavaScript array with its length property set to that number (Note: this implies an array of arrayLength empty slots, not slots with actual undefined values). If the argument is any other number, a RangeError exception is thrown.Arrays are list-like objects whose prototype has methods to perform traversal and mutation operations. Neither the length of a JavaScript array nor the types of its elements are fixed. Since an array's length can change at any time, and data can be stored at non-contiguous locations in the array, JavaScript arrays are not guaranteed to be dense; this depends on how the programmer chooses to use them. In general, these are convenient characteristics; but if these features are not desirable for your particular use, you might consider using typed arrays.
Arrays cannot use strings as element indexes (as in an associative array) but must use integers. Setting or accessing via non-integers using bracket notation (or dot notation) will not set or retrieve an element from the array list itself, but will set or access a variable associated with that array's object property collection. The array's object properties and list of array elements are separate, and the array's traversal and mutation operations cannot be applied to these named properties.
JavaScript arrays are zero-indexed: the first element of an array is at index 0, and the last element is at the index equal to the value of the array's length property minus 1. Using an invalid index number returns undefined.
var arr = ['this is the first element', 'this is the second element', 'this is the last element'];\nconsole.log(arr[0]); // logs 'this is the first element'\nconsole.log(arr[1]); // logs 'this is the second element'\nconsole.log(arr[arr.length - 1]); // logs 'this is the last element'\n
Array elements are object properties in the same way that toString is a property, but trying to access an element of an array as follows throws a syntax error because the property name is not valid:
console.log(arr.0); // a syntax error\n
There is nothing special about JavaScript arrays and the properties that cause this. JavaScript properties that begin with a digit cannot be referenced with dot notation; and must be accessed using bracket notation. For example, if you had an object with a property named '3d', it can only be referenced using bracket notation. E.g.:
var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];\nconsole.log(years.0); // a syntax error\nconsole.log(years[0]); // works properly\n
renderer.3d.setTexture(model, 'character.png'); // a syntax error\nrenderer['3d'].setTexture(model, 'character.png'); // works properly\n
Note that in the 3d example, '3d' had to be quoted. It's possible to quote the JavaScript array indexes as well (e.g., years['2'] instead of years[2]), although it's not necessary. The 2 in years[2] is coerced into a string by the JavaScript engine through an implicit toString conversion. It is, for this reason, that '2' and '02' would refer to two different slots on the years object and the following example could be true:
console.log(years['2'] != years['02']);\n
Similarly, object properties which happen to be reserved words(!) can only be accessed as string literals in bracket notation (but it can be accessed by dot notation in firefox 40.0a2 at least):
var promise = {\n 'var' : 'text',\n 'array': [1, 2, 3, 4]\n};\n\nconsole.log(promise['var']);\n length and numerical propertiesA JavaScript array's length property and numerical properties are connected. Several of the built-in array methods (e.g., join(), slice(), indexOf(), etc.) take into account the value of an array's length property when they're called. Other methods (e.g., push(), splice(), etc.) also result in updates to an array's length property.
var fruits = [];\nfruits.push('banana', 'apple', 'peach');\n\nconsole.log(fruits.length); // 3\n When setting a property on a JavaScript array when the property is a valid array index and that index is outside the current bounds of the array, the engine will update the array's length property accordingly:
fruits[5] = 'mango';\nconsole.log(fruits[5]); // 'mango'\nconsole.log(Object.keys(fruits)); // ['0', '1', '2', '5']\nconsole.log(fruits.length); // 6\n
Increasing the length.
fruits.length = 10;\nconsole.log(Object.keys(fruits)); // ['0', '1', '2', '5']\nconsole.log(fruits.length); // 10\n
Decreasing the length property does, however, delete elements.
fruits.length = 2;\nconsole.log(Object.keys(fruits)); // ['0', '1']\nconsole.log(fruits.length); // 2\n
This is explained further on the Array.length page.
The result of a match between a regular expression and a string can create a JavaScript array. This array has properties and elements which provide information about the match. Such an array is returned by RegExp.exec, String.match, and String.replace. To help explain these properties and elements, look at the following example and then refer to the table below:
// Match one d followed by one or more b's followed by one d\n// Remember matched b's and the following d\n// Ignore case\n\nvar myRe = /d(b+)(d)/i;\nvar myArray = myRe.exec('cdbBdbsbz');\n The properties and elements returned from this match are as follows:
| Property/Element | Description | Example |
|---|---|---|
input | A read-only property that reflects the original string against which the regular expression was matched. | cdbBdbsbz |
index | A read-only property that is the zero-based index of the match in the string. | 1 |
[0] | A read-only element that specifies the last matched characters. | dbBd |
[1], ...[n] | Read-only elements that specify the parenthesized substring matches, if included in the regular expression. The number of possible parenthesized substrings is unlimited. | [1]: bB [2]: d |
Array.lengthArray constructor's length property whose value is 1.get Array[@@species]Array.prototypeArray.from()Array instance from an array-like or iterable object.Array.isArray()Array.of()Array instance with a variable number of arguments, regardless of number or type of the arguments.Array instancesAll Array instances inherit from Array.prototype. The prototype object of the Array constructor can be modified to affect all Array instances.
Array.prototype.constructorArray.prototype.lengthArray.prototype[@@unscopables]with binding scope.These methods modify the array:
Array.prototype.copyWithin()Array.prototype.fill()Array.prototype.pop()Array.prototype.push()Array.prototype.reverse()Array.prototype.shift()Array.prototype.sort()Array.prototype.splice()Array.prototype.unshift()These methods do not modify the array and return some representation of the array.
Array.prototype.concat()Array.prototype.includes()true or false as appropriate.Array.prototype.indexOf()Array.prototype.join()Array.prototype.lastIndexOf()Array.prototype.slice()Array.prototype.toSource() \nObject.prototype.toSource() method.Array.prototype.toString()Object.prototype.toString() method.Array.prototype.toLocaleString()Object.prototype.toLocaleString() method.Several methods take as arguments functions to be called back while processing the array. When these methods are called, the length of the array is sampled, and any element added beyond this length from within the callback is not visited. Other changes to the array (setting the value of or deleting an element) may affect the results of the operation if the method visits the changed element afterwards. While the specific behavior of these methods in such cases is well-defined, you should not rely upon it so as not to confuse others who might read your code. If you must mutate the array, copy into a new array instead.
Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array.Array.prototype.every()Array.prototype.filter()Array.prototype.find()undefined if not found.Array.prototype.findIndex()Array.prototype.forEach()Array.prototype.keys()Array Iterator that contains the keys for each index in the array.Array.prototype.map()Array.prototype.reduce()Array.prototype.reduceRight()Array.prototype.some()Array.prototype.values()Array Iterator object that contains the values for each index in the array.Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Array generic methodsArray generics are non-standard, deprecated and will get removed in the near future.
Sometimes you would like to apply array methods to strings or other array-like objects (such as function arguments). By doing this, you treat a string as an array of characters (or otherwise treat a non-array as an array). For example, in order to check that every character in the variable str is a letter, you would write:
function isLetter(character) {\n return character >= 'a' && character <= 'z';\n}\n\nif (Array.prototype.every.call(str, isLetter)) {\n console.log(\"The string '\" + str + \"' contains only letters!\");\n}\n This notation is rather wasteful and JavaScript 1.6 introduced a generic shorthand:
if (Array.every(str, isLetter)) {\n console.log(\"The string '\" + str + \"' contains only letters!\");\n}\n Generics are also available on String.
These are not part of ECMAScript standards and they are not supported by non-Gecko browsers. As a standard alternative, you can convert your object to a proper array using Array.from(); although that method may not be supported in old browsers:
if (Array.from(str).every(isLetter)) { \n console.log(\"The string '\" + str + \"' contains only letters!\"); \n}\n The following example creates an array, msgArray, with a length of 0, then assigns values to msgArray[0] and msgArray[99], changing the length of the array to 100.
var msgArray = [];\nmsgArray[0] = 'Hello';\nmsgArray[99] = 'world';\n\nif (msgArray.length === 100) {\n console.log('The length is 100.');\n}\n The following creates a chess board as a two-dimensional array of strings. The first move is made by copying the 'p' in (6,4) to (4,4). The old position (6,4) is made blank.
var board = [ \n ['R','N','B','Q','K','B','N','R'],\n ['P','P','P','P','P','P','P','P'],\n [' ',' ',' ',' ',' ',' ',' ',' '],\n [' ',' ',' ',' ',' ',' ',' ',' '],\n [' ',' ',' ',' ',' ',' ',' ',' '],\n [' ',' ',' ',' ',' ',' ',' ',' '],\n ['p','p','p','p','p','p','p','p'],\n ['r','n','b','q','k','b','n','r'] ];\n\nconsole.log(board.join('\\n') + '\\n\\n');\n\n// Move King's Pawn forward 2\nboard[4][4] = board[6][4];\nboard[6][4] = ' ';\nconsole.log(board.join('\\n'));\n Here is the output:
R,N,B,Q,K,B,N,R\nP,P,P,P,P,P,P,P\n , , , , , , , \n , , , , , , , \n , , , , , , , \n , , , , , , , \np,p,p,p,p,p,p,p\nr,n,b,q,k,b,n,r\n\nR,N,B,Q,K,B,N,R\nP,P,P,P,P,P,P,P\n , , , , , , , \n , , , , , , , \n , , , ,p, , , \n , , , , , , , \np,p,p,p, ,p,p,p\nr,n,b,q,k,b,n,r\n
values = [];\nfor (var x = 0; x < 10; x++){\n values.push([\n 2 ** x,\n 2 * x ** 2\n ])\n};\nconsole.table(values) Results in
0\t1\t0\n1\t2\t2\n2\t4\t8\n3\t8\t18\n4\t16\t32\n5\t32\t50\n6\t64\t72\n7\t128\t98\n8\t256\t128\n9\t512\t162
(First column is the (index))
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array' in that specification. | Standard | New methods added: Array.isArray, indexOf, lastIndexOf, every, some, forEach, map, filter, reduce, reduceRight\n |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array' in that specification. | Standard | New methods added: Array.from, Array.of, find, findIndex, fill, copyWithin\n |
| ECMAScript 2016 (ECMA-262) The definition of 'Array' in that specification. | Standard | New method added: Array.prototype.includes()\n |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
concat | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
copyWithin | \n45 | \n12 | \n32 | \nNo | \n32 | \n9 | \n
entries | \n38 | \nYes | \n28 | \nNo | \n25 | \n8 | \n
every | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
fill | \n45 | \nYes | \n31 | \nNo | \nYes | \n8 | \n
filter | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
find | \n45 | \nYes | \n25 | \nNo | \n32 | \n8 | \n
findIndex | \n45 | \nYes | \n25 | \nNo | \n32 | \n8 | \n
\nflat \n | \n69 | \nNo | \n62 | \nNo | \n56 | \n12 | \n
\nflatMap \n | \n69 | \nNo | \n62 | \nNo | \n56 | \n12 | \n
forEach | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
from | \n45 | \nYes | \n32 | \nNo | \nYes | \n9 | \n
includes | \n47 | \n14 | \n43 | \nNo | \n34 | \n9 | \n
indexOf | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
isArray | \n5 | \nYes | \n4 | \n9 | \n10.5 | \n5 | \n
join | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
keys | \n38 | \nYes | \n28 | \nNo | \n25 | \n8 | \n
lastIndexOf | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
length | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
map | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
\nobserve \n | \n36 — 52 | \nNo | \nNo | \nNo | \nNo | \nNo | \n
of | \n45 | \nYes | \n25 | \nNo | \nYes | \n9 | \n
pop | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
prototype | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
push | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
reduce | \nYes | \nYes | \n3 | \n9 | \n10.5 | \n4 | \n
reduceRight | \nYes | \nYes | \n3 | \n9 | \n10.5 | \n4 | \n
reverse | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
shift | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
slice | \n1 | \nYes | \n1 | \nYes | \nYes | \nYes | \n
some | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
sort | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
splice | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
toLocaleString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nunobserve \n | \n36 — 52 | \nNo | \nNo | \nNo | \nNo | \nNo | \n
unshift | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
values | \n66 | \nYes | \n60 | \nNo | \n53 | \n9 | \n
@@iterator | \n38 | \n? | \n 36\n
| \nNo | \n25 | \nYes | \n
@@species | \n? | \n? | \n48 | \n? | \n? | \n? | \n
@@unscopables | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
concat | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
copyWithin | \nYes | \nYes | \nYes | \n32 | \nYes | \nYes | \nYes | \n
entries | \nYes | \nYes | \nYes | \n28 | \nYes | \n8 | \nYes | \n
every | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
fill | \nYes | \nYes | \nYes | \n31 | \nYes | \n8 | \nYes | \n
filter | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
find | \nYes | \nYes | \nYes | \n4 | \nYes | \n8 | \nYes | \n
findIndex | \nYes | \nYes | \nYes | \n4 | \nYes | \n8 | \nYes | \n
\nflat \n | \n69 | \n69 | \nNo | \n62 | \n56 | \n12 | \nNo | \n
\nflatMap \n | \n69 | \n69 | \nNo | \n62 | \n56 | \n12 | \nNo | \n
forEach | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
from | \n? | \nYes | \nYes | \n32 | \nYes | \nYes | \nYes | \n
includes | \nYes | \nYes | \n14 | \n43 | \n34 | \n9 | \nYes | \n
indexOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
isArray | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
join | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
keys | \nYes | \nYes | \nYes | \n28 | \nYes | \n8 | \nYes | \n
lastIndexOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
length | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
map | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nobserve \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
of | \nYes | \n39 | \nYes | \n25 | \nYes | \nYes | \n4.0 | \n
pop | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
push | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
reduce | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
reduceRight | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
reverse | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
shift | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
slice | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
some | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
sort | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
splice | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toLocaleString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nunobserve \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
unshift | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
values | \n66 | \n66 | \nYes | \n60 | \n53 | \n9 | \nNo | \n
@@iterator | \nYes | \nYes | \n? | \n 36\n
| \nYes | \nYes | \nYes | \n
@@species | \n? | \n? | \n? | \n48 | \n? | \n? | \n? | \n
@@unscopables | \n? | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
concat | \nYes | \n
copyWithin | \n4.0.0 | \n
entries | \n0.12 | \n
every | \nYes | \n
fill | \n 4.0.0\n
| \n
filter | \nYes | \n
find | \n 4.0.0\n
| \n
findIndex | \n 4.0.0\n
| \n
\nflat \n | \nNo | \n
\nflatMap \n | \nNo | \n
forEach | \nYes | \n
from | \n4.0.0 | \n
includes | \n 6.0.0\n
| \n
indexOf | \nYes | \n
isArray | \nYes | \n
join | \nYes | \n
keys | \n0.12 | \n
lastIndexOf | \nYes | \n
length | \nYes | \n
map | \nYes | \n
\nobserve \n | \nNo | \n
of | \n4.0.0 | \n
pop | \nYes | \n
prototype | \nYes | \n
push | \nYes | \n
reduce | \nYes | \n
reduceRight | \nYes | \n
reverse | \nYes | \n
shift | \nYes | \n
slice | \nYes | \n
some | \nYes | \n
sort | \nYes | \n
splice | \nYes | \n
toLocaleString | \nYes | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
\nunobserve \n | \nNo | \n
unshift | \nYes | \n
values | \n 10.9.0\n
| \n
@@iterator | \n0.12 | \n
@@species | \n 6.5.0\n
| \n
@@unscopables | \n0.12 | \n
Array Object”\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array\n
The comma operator evaluates each of its operands (from left to right) and returns the value of the last operand.
expr1, expr2, expr3...
expr1, expr2, expr3...\nYou can use the comma operator when you want to include multiple expressions in a location that requires a single expression. The most common usage of this operator is to supply multiple parameters in a for loop.
If a is a 2-dimensional array with 10 elements on each side, the following code uses the comma operator to increment two variables at once.
The following code prints the values of the diagonal elements in the array:
for (var i = 0, j = 9; i <= 9; i++, j--)\n console.log('a[' + i + '][' + j + '] = ' + a[i][j]); Note that the comma in assignments such as the var statement may appear not to have the normal effect of comma operators because they don't exist within an expression. In the following example, a is set to the value of b = 3 (which is 3), but the c = 4 expression still evaluates and its result returned to console (i.e., 4). This is due to operator precedence and associativity.
// Note that the following creates globals and is disallowed in strict mode.\n\na = b = 3, c = 4; // Returns 4 in console\nconsole.log(a); // 3 (left-most)\n\nx = (y = 5, z = 6); // Returns 6 in console\nconsole.log(x); // 6 (right-most)\n
The comma operator is fully different from the comma within arrays, objects, and function arguments and parameters.
Another example that one could make with comma operator is processing before returning. As stated, only the last element will be returned but all others are going to be evaluated as well. So, one could do:
function myFunc() {\n var x = 0;\n\n return (x += 1, x); // the same as return ++x;\n} | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n3 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator\n
Math is a built-in object that has properties and methods for mathematical constants and functions. Not a function object.
Unlike the other global objects, Math is not a constructor. All properties and methods of Math are static. You refer to the constant pi as Math.PI and you call the sine function as Math.sin(x), where x is the method's argument. Constants are defined with the full precision of real numbers in JavaScript.
Math.EMath.LN2Math.LN10Math.LOG2EMath.LOG10EMath.PIMath.SQRT1_2Math.SQRT2Note that the trigonometric functions (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) expect or return angles in radians. To convert radians to degrees, divide by (Math.PI / 180), and multiply by this to convert the other way.
Note that many math functions have a precision that's implementation-dependent. This means that different browsers can give a different result, and even the same JS engine on a different OS or architecture can give different results.
Math.abs(x)Math.acos(x)Math.acosh(x)Math.asin(x)Math.asinh(x)Math.atan(x)Math.atanh(x)Math.atan2(y, x)Math.cbrt(x)Math.ceil(x)Math.clz32(x)Math.cos(x)Math.cosh(x)Math.exp(x)Math.expm1(x)exp(x).Math.floor(x)Math.fround(x)Math.hypot([x[, y[, …]]])Math.imul(x, y)Math.log(x)Math.log1p(x)1 + x for a number x.Math.log10(x)Math.log2(x)Math.max([x[, y[, …]]])Math.min([x[, y[, …]]])Math.pow(x, y)baseexponent.Math.random()Math.round(x)Math.sign(x)Math.sin(x)Math.sinh(x)Math.sqrt(x)Math.tan(x)Math.tanh(x)Math.toSource() \n\"Math\".Math.trunc(x)Math objectAs with most of the built-in objects in JavaScript, the Math object can be extended with custom properties and methods. To extend the Math object, you do not use prototype. Instead, you directly extend Math:
Math.propName = propValue;\nMath.methodName = methodRef;
For instance, the following example adds a method to the Math object for calculating the greatest common divisor of a list of arguments.
/* Variadic function -- Returns the greatest common divisor of a list of arguments */\nMath.gcd = function() {\n if (arguments.length == 2) {\n if (arguments[1] == 0)\n return arguments[0];\n else\n return Math.gcd(arguments[1], arguments[0] % arguments[1]);\n } else if (arguments.length > 2) {\n var result = Math.gcd(arguments[0], arguments[1]);\n for (var i = 2; i < arguments.length; i++)\n result = Math.gcd(result, arguments[i]);\n return result;\n }\n}; Try it:
console.log(Math.gcd(20, 30, 15, 70, 40)); // `5`
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math' in that specification. | Standard | New methods log10(), log2(), log1p(), expm1(), cosh(), sinh(), tanh(), acosh(), asinh(), atanh(), hypot(), trunc(), sign(), imul(), fround(), cbrt() and clz32() added. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
E | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
LN2 | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
LN10 | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
LOG2E | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
LOG10E | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
PI | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
SQRT1_2 | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
SQRT2 | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
abs | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
acos | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
acosh | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
asin | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
asinh | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
atan | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
atan2 | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
atanh | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
cbrt | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
ceil | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
clz32 | \n38 | \nYes | \n31 | \nNo | \n25 | \nYes | \n
cos | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
cosh | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
exp | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
expm1 | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
floor | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
fround | \n38 | \nYes | \n26 | \nNo | \n25 | \n8 | \n
hypot | \n38 | \nYes | \n27 | \nNo | \n25 | \n8 | \n
imul | \n28 | \nYes | \n20 | \nNo | \n16 | \n7 | \n
log | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
log1p | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
log2 | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
log10 | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
max | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
min | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
pow | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
random | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
round | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
sign | \n38 | \nYes | \n25 | \nNo | \n25 | \n9 | \n
sin | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
sinh | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
sqrt | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
tan | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
tanh | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
trunc | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
E | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
LN2 | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
LN10 | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
LOG2E | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
LOG10E | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
PI | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
SQRT1_2 | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
SQRT2 | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
abs | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
acos | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
acosh | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
asin | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
asinh | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
atan | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
atan2 | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
atanh | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
cbrt | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
ceil | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
clz32 | \nYes | \nYes | \nYes | \n31 | \nYes | \nYes | \nYes | \n
cos | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
cosh | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
exp | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
expm1 | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
floor | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
fround | \nYes | \nYes | \nYes | \n26 | \nYes | \n8 | \nYes | \n
hypot | \nYes | \nYes | \nYes | \n27 | \nYes | \n8 | \nYes | \n
imul | \nYes | \nYes | \nYes | \n20 | \nYes | \n7 | \nYes | \n
log | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
log1p | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
log2 | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
log10 | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
max | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
min | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
pow | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
random | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
round | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
sign | \nYes | \nYes | \nYes | \n25 | \nYes | \nYes | \nYes | \n
sin | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
sinh | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
sqrt | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
tan | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
tanh | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
trunc | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
E | \nYes | \n
LN2 | \nYes | \n
LN10 | \nYes | \n
LOG2E | \nYes | \n
LOG10E | \nYes | \n
PI | \nYes | \n
SQRT1_2 | \nYes | \n
SQRT2 | \nYes | \n
abs | \nYes | \n
acos | \nYes | \n
acosh | \n0.12 | \n
asin | \nYes | \n
asinh | \n0.12 | \n
atan | \nYes | \n
atan2 | \nYes | \n
atanh | \n0.12 | \n
cbrt | \n0.12 | \n
ceil | \nYes | \n
clz32 | \n0.12 | \n
cos | \nYes | \n
cosh | \n0.12 | \n
exp | \nYes | \n
expm1 | \n0.12 | \n
floor | \nYes | \n
fround | \n0.12 | \n
hypot | \n0.12 | \n
imul | \n0.12 | \n
log | \nYes | \n
log1p | \n0.12 | \n
log2 | \n0.12 | \n
log10 | \n0.12 | \n
max | \nYes | \n
min | \nYes | \n
pow | \nYes | \n
random | \nYes | \n
round | \nYes | \n
sign | \n0.12 | \n
sin | \nYes | \n
sinh | \n0.12 | \n
sqrt | \nYes | \n
tan | \nYes | \n
tanh | \n0.12 | \n
trunc | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math\n
The global isFinite() function determines whether the passed value is a finite number. If needed, the parameter is first converted to a number.
isFinite(testValue)
testValuefalse if the argument is positive or negative Infinity or NaN; otherwise, true.
isFinite is a top-level function and is not associated with any object.
You can use this function to determine whether a number is a finite number. The isFinite function examines the number in its argument. If the argument is NaN, positive infinity, or negative infinity, this method returns false; otherwise, it returns true.
isFinite(Infinity); // false\nisFinite(NaN); // false\nisFinite(-Infinity); // false\n\nisFinite(0); // true\nisFinite(2e64); // true\nisFinite(910); // true\n\nisFinite(null); // true, would've been false with the \n // more robust Number.isFinite(null)\n\nisFinite('0'); // true, would've been false with the \n // more robust Number.isFinite(\"0\")\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'isFinite' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'isFinite' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'isFinite' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/isFinite\n
The global undefined property represents the primitive value undefined. It is one of JavaScript's primitive types.
Property attributes of undefined\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
undefined
undefined is a property of the global object; i.e., it is a variable in global scope. The initial value of undefined is the primitive value undefined.
In modern browsers (JavaScript 1.8.5 / Firefox 4+), undefined is a non-configurable, non-writable property per the ECMAScript 5 specification. Even when this is not the case, avoid overriding it.
A variable that has not been assigned a value is of type undefined. A method or statement also returns undefined if the variable that is being evaluated does not have an assigned value. A function returns undefined if a value was not returned.
While it is possible to use it as an identifier (variable name) in any scope other than the global scope (because undefined is not a reserved word), doing so is a very bad idea that will make your code difficult to maintain and debug.
//DON'T DO THIS\n\n// logs \"foo string\"\n(function() { var undefined = 'foo'; console.log(undefined, typeof undefined); })();\n\n// logs \"foo string\"\n(function(undefined) { console.log(undefined, typeof undefined); })('foo');\n undefined\nYou can use undefined and the strict equality and inequality operators to determine whether a variable has a value. In the following code, the variable x is not defined, and the if statement evaluates to true.
var x;\nif (x === undefined) {\n // these statements execute\n}\nelse {\n // these statements do not execute\n}\n Note: The strict equality operator rather than the standard equality operator must be used here, because x == undefined also checks whether x is null, while strict equality doesn't. null is not equivalent to undefined. See comparison operators for details.
Typeof operator and undefined\nAlternatively, typeof can be used:
var x;\nif (typeof x === 'undefined') {\n // these statements execute\n}\n One reason to use typeof is that it does not throw an error if the variable has not been declared.
// x has not been declared before\nif (typeof x === 'undefined') { // evaluates to true without errors\n // these statements execute\n}\n\nif (x === undefined) { // throws a ReferenceError\n\n}\n However, this kind of technique should be avoided. JavaScript is a statically scoped language, so knowing if a variable is declared can be read by seeing whether it is declared in an enclosing context. The only exception is the global scope, but the global scope is bound to the global object, so checking the existence of a variable in the global context can be done by checking the existence of a property on the global object (using the in operator, for instance).
Void operator and undefined\nThe void operator is a third alternative.
var x;\nif (x === void 0) {\n // these statements execute\n}\n\n// y has not been declared before\nif (y === void 0) {\n // throws a - Uncaught ReferenceError: y is not defined\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) The definition of 'undefined' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'undefined' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'undefined' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'undefined' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined\n
The parseInt() function parses a string argument and returns an integer of the specified radix (the base in mathematical numeral systems).
parseInt(string, radix);
stringstring argument is not a string, then it is converted to a string (using the ToString abstract operation). Leading whitespace in the string argument is ignored.radixAn integer number parsed from the given string. If the first character cannot be converted to a number, NaN is returned.
The parseInt function converts its first argument to a string, parses it, and returns an integer or NaN. If not NaN, the returned value will be the integer that is the first argument taken as a number in the specified radix (base). For example, a radix of 10 indicates to convert from a decimal number, 8 octal, 16 hexadecimal, and so on. For radices above 10, the letters of the alphabet indicate numerals greater than 9. For example, for hexadecimal numbers (base 16), A through F are used.
If parseInt encounters a character that is not a numeral in the specified radix, it ignores it and all succeeding characters and returns the integer value parsed up to that point. parseInt truncates numbers to integer values. Leading and trailing spaces are allowed.
Because some numbers include the e character in their string representation (e.g. 6.022e23), using parseInt to truncate numeric values will produce unexpected results when used on very large or very small numbers. parseInt should not be used as a substitute for Math.floor().
If radix is undefined or 0 (or absent), JavaScript assumes the following:
string begins with \"0x\" or \"0X\", radix is 16 (hexadecimal) and the remainder of the string is parsed.string begins with \"0\", radix is eight (octal) or 10 (decimal). Exactly which radix is chosen is implementation-dependent. ECMAScript 5 specifies that 10 (decimal) is used, but not all browsers support this yet. For this reason parseInt.string begins with any other value, the radix is 10 (decimal).If the first character cannot be converted to a number, parseInt returns NaN.
For arithmetic purposes, the NaN value is not a number in any radix. You can call the isNaN function to determine if the result of parseInt is NaN. If NaN is passed on to arithmetic operations, the operation results will also be NaN.
To convert number to its string literal in a particular radix use intValue.toString(radix).
The following examples all return 15:
parseInt('0xF', 16);\nparseInt('F', 16);\nparseInt('17', 8);\nparseInt(021, 8);\nparseInt('015', 10); // parseInt(015, 10); will return 15\nparseInt(15.99, 10);\nparseInt('15,123', 10);\nparseInt('FXX123', 16);\nparseInt('1111', 2);\nparseInt('15 * 3', 10);\nparseInt('15e2', 10);\nparseInt('15px', 10);\nparseInt('12', 13);\n The following examples all return NaN:
parseInt('Hello', 8); // Not a number at all\nparseInt('546', 2); // Digits are not valid for binary representations\n The following examples all return -15:
parseInt('-F', 16);\nparseInt('-0F', 16);\nparseInt('-0XF', 16);\nparseInt(-15.1, 10);\nparseInt('-17', 8);\nparseInt('-15', 10);\nparseInt('-1111', 2);\nparseInt('-15e1', 10);\nparseInt('-12', 13);\n The following examples all return 4:
parseInt(4.7, 10);\nparseInt(4.7 * 1e22, 10); // Very large number becomes 4\nparseInt(0.00000000000434, 10); // Very small number becomes 4\n
The following example returns 224:
parseInt('0e0', 16);\n Although discouraged by ECMAScript 3 and forbidden by ECMAScript 5, many implementations interpret a numeric string beginning with a leading 0 as octal. The following may have an octal result, or it may have a decimal result. Always specify a radix to avoid this unreliable behavior.
parseInt('0e0'); // 0\nparseInt('08'); // 0, '8' is not an octal digit.\n The ECMAScript 5 specification of the function parseInt no longer allows implementations to treat Strings beginning with a 0 character as octal values. ECMAScript 5 states:
The parseInt function produces an integer value dictated by interpretation of the contents of the string argument according to the specified radix. Leading white space in string is ignored. If radix is undefined or 0, it is assumed to be 10 except when the number begins with the character pairs 0x or 0X, in which case a radix of 16 is assumed.
This differs from ECMAScript 3, which discouraged but allowed octal interpretation.
Many implementations have not adopted this behavior as of 2013, and because older browsers must be supported, always specify a radix.
It is sometimes useful to have a stricter way to parse int values. Regular expressions can help:
var filterInt = function(value) {\n if (/^(\\-|\\+)?([0-9]+|Infinity)$/.test(value))\n return Number(value);\n return NaN;\n}\n\nconsole.log(filterInt('421')); // 421\nconsole.log(filterInt('-421')); // -421\nconsole.log(filterInt('+421')); // 421\nconsole.log(filterInt('Infinity')); // Infinity\nconsole.log(filterInt('421e+0')); // NaN\nconsole.log(filterInt('421hop')); // NaN\nconsole.log(filterInt('hop1.61803398875')); // NaN\nconsole.log(filterInt('1.61803398875')); // NaN\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'parseInt' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'parseInt' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'parseInt' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Parses leading-zero strings are decimal, not octal | \n23 | \nYes | \n21 | \n9 | \nYes | \n6 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Parses leading-zero strings are decimal, not octal | \n4.4 | \nYes | \nYes | \n21 | \nYes | \n6 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Parses leading-zero strings are decimal, not octal | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt\n
The conditional (ternary) operator is the only JavaScript operator that takes three operands. This operator is frequently used as a shortcut for the if statement.
condition ? exprT : exprF
conditionexprT, exprF\nIf condition can be converted to true (it is truthy), the operator returns the value of exprT; otherwise (when condition is falsy) it returns the value of exprF.
(In either case, the other alternative expression is left unevaluated.)
Besides false, possible falsy expressions are: null, NaN0\"\"undefinedcondition is any of these, the result of the conditional expression will be exprF.
A simple example:
var age = 26;\nvar beverage = (age >= 21) ? \"Beer\" : \"Juice\";\nconsole.log(beverage); // \"Beer\"\n
One common usage is to handle a value that may be null:
function greeting(person) {\n var name = person ? person.name : \"stranger\";\n return \"Howdy, \" + name;\n}\n\nconsole.log(greeting({name: 'Alice'})); // \"Howdy, Alice\"\nconsole.log(greeting(null)); // \"Howdy, stranger\"\n The ternary operator is right-associative, which means it can be \"chained\" in the following way, similar to an if … else if … else if … else chain:
function example(…) {\n return condition1 ? value1\n : condition2 ? value2\n : condition3 ? value3\n : value4;\n}\n\n// Equivalent to:\n\nfunction example(…) {\n if (condition1) { return value1; }\n else if (condition2) { return value2; }\n else if (condition3) { return value3; }\n else { return value4; }\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Conditional Operator' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Conditional Operator' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'The conditional operator' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'The conditional operator' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator\n
The grouping operator ( ) controls the precedence of evaluation in expressions.
( )
The grouping operator consists of a pair of parentheses around an expression or sub-expression to override the normal operator precedence so that expressions with lower precedence can be evaluated before an expression with higher priority. As it sounds it groups what's inside of the parentheses.
Overriding multiplication and division first, then addition and subtraction to evaluate addition first.
var a = 1;\nvar b = 2;\nvar c = 3;\n\n// default precedence\na + b * c // 7\n// evaluated by default like this\na + (b * c) // 7\n\n// now overriding precedence \n// addition before multiplication \n(a + b) * c // 9\n\n// which is equivalent to\na * c + b * c // 9\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'The Grouping Operator' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'The Grouping Operator' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'The Grouping Operator' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'The Grouping Operator' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Grouping\n
Array.prototype.map, Array.prototype.filter, arrow functions, and spread syntax. Obsolete since Gecko 58 (Firefox 58 / Thunderbird 58 / SeaMonkey 2.55)
This feature is obsolete. Although it may still work in some browsers, its use is discouraged since it could be removed at any time. Try to avoid using it.
The array comprehension syntax was a JavaScript expression which allowed you to quickly assemble a new array based on an existing one. However, it has been removed from the standard and the Firefox implementation. Do not use it!
[for (x of iterable) x]\n[for (x of iterable) if (condition) x]\n[for (x of iterable) for (y of iterable) x + y]\n
Inside array comprehensions, these two kinds of components are allowed:
The for-of iteration is always the first component. Multiple for-of iterations or if statements are allowed.
Array comprehension was previously proposed to be standardized in ECMAScript 2016, it provide a useful shortcut for constructing a new array based on the contents of another. Comprehensions can often be used in place of calls to map() and filter(), or as a way of combining the two.
The following comprehension takes an array of numbers and creates a new array of the double of each of those numbers.
var numbers = [1, 2, 3, 4];\nvar doubled = [for (i of numbers) i * 2];\nconsole.log(doubled); // logs 2,4,6,8\n
This is equivalent to the following map() operation:
var doubled = numbers.map(i => i * 2);\n
Comprehensions can also be used to select items that match a particular expression. Here is a comprehension which selects only even numbers:
var numbers = [1, 2, 3, 21, 22, 30];\nvar evens = [for (i of numbers) if (i % 2 === 0) i];\nconsole.log(evens); // logs 2,22,30\n
filter() can be used for the same purpose:
var evens = numbers.filter(i => i % 2 === 0);\n
map() and filter() style operations can be combined into a single array comprehension. Here is one that filters just the even numbers, then creates an array containing their doubles:
var numbers = [1, 2, 3, 21, 22, 30];\nvar doubledEvens = [for (i of numbers) if (i % 2 === 0) i * 2];\nconsole.log(doubledEvens); // logs 4,44,60\n
The square brackets of an array comprehension introduce an implicit block for scoping purposes. New variables (such as i in the example) are treated as if they had been declared using let. This means that they will not be available outside of the comprehension.
The input to an array comprehension does not itself need to be an array; iterators and generators can also be used.
Even strings may be used as input; to achieve the filter and map actions (under Array-like objects) above:
var str = 'abcdef';\nvar consonantsOnlyStr = [for (c of str) if (!(/[aeiouAEIOU]/).test(c)) c].join(''); // 'bcdf'\nvar interpolatedZeros = [for (c of str) c + '0' ].join(''); // 'a0b0c0d0e0f0'\n Again, the input form is not preserved, so we have to use join() to revert back to a string.
[for (i of [1, 2, 3]) i * i ]; \n// [1, 4, 9]\n\nvar abc = ['A', 'B', 'C'];\n[for (letters of abc) letters.toLowerCase()];\n// [\"a\", \"b\", \"c\"]
var years = [1954, 1974, 1990, 2006, 2010, 2014];\n[for (year of years) if (year > 2000) year];\n// [2006, 2010, 2014]\n[for (year of years) if (year > 2000) if (year < 2010) year];\n// [2006], the same as below:\n[for (year of years) if (year > 2000 && year < 2010) year];\n// [2006] \n
map and filter\nAn easy way to understand array comprehension syntax, is to compare it with the Array map and filter methods:
var numbers = [1, 2, 3];\n\nnumbers.map(function (i) { return i * i });\nnumbers.map(i => i * i);\n[for (i of numbers) i * i];\n// all are [1, 4, 9]\n\nnumbers.filter(function (i) { return i < 3 });\nnumbers.filter(i => i < 3);\n[for (i of numbers) if (i < 3) i];\n// all are [1, 2]\n Using two for-of iterations to work with two arrays:
var numbers = [1, 2, 3];\nvar letters = ['a', 'b', 'c'];\n\nvar cross = [for (i of numbers) for (j of letters) i + j];\n// [\"1a\", \"1b\", \"1c\", \"2a\", \"2b\", \"2c\", \"3a\", \"3b\", \"3c\"]\n\nvar grid = [for (i of numbers) [for (j of letters) i + j]];\n// [\n// [\"1a\", \"1b\", \"1c\"],\n// [\"2a\", \"2b\", \"2c\"],\n// [\"3a\", \"3b\", \"3c\"]\n// ]\n\n[for (i of numbers) if (i > 1) for (j of letters) if(j > 'a') i + j]\n// [\"2b\", \"2c\", \"3b\", \"3c\"], the same as below:\n\n[for (i of numbers) for (j of letters) if (i > 1) if(j > 'a') i + j]\n// [\"2b\", \"2c\", \"3b\", \"3c\"]\n\n[for (i of numbers) if (i > 1) [for (j of letters) if(j > 'a') i + j]]\n// [[\"2b\", \"2c\"], [\"3b\", \"3c\"]], not the same as below:\n\n[for (i of numbers) [for (j of letters) if (i > 1) if(j > 'a') i + j]]\n// [[], [\"2b\", \"2c\"], [\"3b\", \"3c\"]]\n
Was initially in the ECMAScript 2015 draft, but got removed in revision 27 (August 2014). Please see older revisions of ES2015 for specification semantics.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nNo | \nNo | \n30 — 58 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nNo | \nNo | \nNo | \n30 — 58 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
Old comprehensions syntax (do not use anymore!):
[X for (Y in Z)]\n[X for each (Y in Z)]\n[X for (Y of Z)]\n
Differences:
[()=>x for (x of [0, 1, 2])][1]() // 2\n[for (x of [0, 1, 2]) ()=>x][1]() // 1, each iteration creates a fresh binding for x. \n[i * 2 for (i of numbers)]\n[for (i of numbers) i * 2]\nif and for components.for...offor...inSee Bug 1220564, comment 42 for suggestions on updating code.
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Array_comprehensions\n
Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value. The standard arithmetic operators are addition (+), subtraction (-), multiplication (*), and division (/).
The addition operator produces the sum of numeric operands or string concatenation.
Operator: x + y\n
// Number + Number -> addition\n1 + 2 // 3\n\n// Boolean + Number -> addition\ntrue + 1 // 2\n\n// Boolean + Boolean -> addition\nfalse + false // 0\n\n// Number + String -> concatenation\n5 + 'foo' // \"5foo\"\n\n// String + Boolean -> concatenation\n'foo' + false // \"foofalse\"\n\n// String + String -> concatenation\n'foo' + 'bar' // \"foobar\"\n
The subtraction operator subtracts the two operands, producing their difference.
Operator: x - y\n
5 - 3 // 2\n3 - 5 // -2\n'foo' - 3 // NaN
The division operator produces the quotient of its operands where the left operand is the dividend and the right operand is the divisor.
Operator: x / y\n
1 / 2 // returns 0.5 in JavaScript\n1 / 2 // returns 0 in Java \n// (neither number is explicitly a floating point number)\n\n1.0 / 2.0 // returns 0.5 in both JavaScript and Java\n\n2.0 / 0 // returns Infinity in JavaScript\n2.0 / 0.0 // returns Infinity too\n2.0 / -0.0 // returns -Infinity in JavaScript
The multiplication operator produces the product of the operands.
Operator: x * y\n
2 * 2 // 4\n-2 * 2 // -4\nInfinity * 0 // NaN\nInfinity * Infinity // Infinity\n'foo' * 2 // NaN\n
The remainder operator returns the remainder left over when one operand is divided by a second operand. It always takes the sign of the dividend.
Operator: var1 % var2\n
12 % 5 // 2\n-1 % 2 // -1\n1 % -2 // 1\nNaN % 2 // NaN\n1 % 2 // 1\n2 % 3 // 2\n-4 % 2 // -0\n5.5 % 2 // 1.5\n
The exponentiation operator returns the result of raising first operand to the power second operand. that is, var1var2, in the preceding statement, where var1 and var2 are variables. Exponentiation operator is right associative. a ** b ** c is equal to a ** (b ** c).
Operator: var1 ** var2\n
In most languages like PHP and Python and others that have an exponentiation operator (**), the exponentiation operator is defined to have a higher precedence than unary operators such as unary + and unary -, but there are a few exceptions. For example, in Bash the ** operator is defined to have a lower precedence than unary operators. In JavaScript, it is impossible to write an ambiguous exponentiation expression, i.e. you cannot put a unary operator (+/-/~/!/delete/void/typeof) immediately before the base number.
-2 ** 2; \n// 4 in Bash, -4 in other languages. \n// This is invalid in JavaScript, as the operation is ambiguous. \n\n\n-(2 ** 2); \n// -4 in JavaScript and the author's intention is unambiguous. \n
2 ** 3 // 8\n3 ** 2 // 9\n3 ** 2.5 // 15.588457268119896\n10 ** -1 // 0.1\nNaN ** 2 // NaN\n\n2 ** 3 ** 2 // 512\n2 ** (3 ** 2) // 512\n(2 ** 3) ** 2 // 64\n
To invert the sign of the result of an exponentiation expression:
-(2 ** 2) // -4\n
To force the base of an exponentiation expression to be a negative number:
(-2) ** 2 // 4\n
Note: JavaScript also has a bitwise operator ^ (logical XOR). ** and ^ are different (for example : 2 ** 3 === 8 when 2 ^ 3 === 1.)
The increment operator increments (adds one to) its operand and returns a value.
Operator: x++ or ++x\n
// Postfix \nvar x = 3;\ny = x++; // y = 3, x = 4\n\n// Prefix\nvar a = 2;\nb = ++a; // a = 3, b = 3\n
The decrement operator decrements (subtracts one from) its operand and returns a value.
Operator: x-- or --x\n
// Postfix \nvar x = 3;\ny = x--; // y = 3, x = 2\n\n// Prefix\nvar a = 2;\nb = --a; // a = 1, b = 1\n
The unary negation operator precedes its operand and negates it.
Operator: -x\n
var x = 3;\ny = -x; // y = -3, x = 3\n\n//unary negation operator can convert non-numbers into a number\nvar x = \"4\";\ny = -x; // y = -4 \n
The unary plus operator precedes its operand and evaluates to its operand but attempts to convert it into a number, if it isn't already. Although unary negation (-) also can convert non-numbers, unary plus is the fastest and preferred way of converting something into a number, because it does not perform any other operations on the number. It can convert string representations of integers and floats, as well as the non-string values true, false, and null. Integers in both decimal and hexadecimal (\"0x\"-prefixed) formats are supported. Negative numbers are supported (though not for hex). If it cannot parse a particular value, it will evaluate to NaN.
Operator: +x\n
+3 // 3\n+'3' // 3\n+true // 1\n+false // 0\n+null // 0\n+function(val){ return val } // NaN\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) | Standard | Defined in several sections of the specification: Additive operators, Multiplicative operators, Postfix expressions, Unary operators. |
| ECMAScript 2015 (6th Edition, ECMA-262) | Standard | Defined in several sections of the specification: Additive operators, Multiplicative operators, Postfix expressions, Unary operators. |
| ECMAScript 2016 (ECMA-262) | Standard | Added Exponentiation operator. |
| ECMAScript 2017 (ECMA-262) | Standard | |
| ECMAScript Latest Draft (ECMA-262) | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
Addition (+) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Decrement (--) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Division (/) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Exponentiation (**) | \n52 | \n14 | \n52 | \nNo | \nYes | \n10.1 | \n
Increment (++) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Multiplication (*) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Remainder (%) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Subtraction (-) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Unary negation (-) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Unary plus (+) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
Addition (+) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Decrement (--) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Division (/) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Exponentiation (**) | \n51 | \n52 | \n14 | \n52 | \nYes | \n10.1 | \n6.0 | \n
Increment (++) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Multiplication (*) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Remainder (%) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Subtraction (-) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Unary negation (-) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Unary plus (+) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
Addition (+) | \nYes | \n
Decrement (--) | \nYes | \n
Division (/) | \nYes | \n
Exponentiation (**) | \n 7.0.0\n
| \n
Increment (++) | \nYes | \n
Multiplication (*) | \nYes | \n
Remainder (%) | \nYes | \n
Subtraction (-) | \nYes | \n
Unary negation (-) | \nYes | \n
Unary plus (+) | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators\n
The Object constructor creates an object wrapper.
// Object initialiser or literal\n{ [ nameValuePair1[, nameValuePair2[, ...nameValuePairN] ] ] }\n\n// Called as a constructor\nnew Object([value]) nameValuePair1, nameValuePair2, ... nameValuePairNvalueThe Object constructor creates an object wrapper for the given value. If the value is null or undefined, it will create and return an empty object, otherwise, it will return an object of a Type that corresponds to the given value. If the value is an object already, it will return the value.
When called in a non-constructor context, Object behaves identically to new Object().
See also the object initializer / literal syntax.
Object constructorObject.lengthObject.prototypeObject constructorObject.assign()Object.create()Object.defineProperty()Object.defineProperties()Object.entries()[key, value] pairs of a given object's own enumerable string properties.Object.freeze()Object.fromEntries()Object.entries).Object.getOwnPropertyDescriptor()Object.getOwnPropertyDescriptors()Object.getOwnPropertyNames()Object.getOwnPropertySymbols()Object.getPrototypeOf()Object.is()Object.isExtensible()Object.isFrozen()Object.isSealed()Object.keys()Object.preventExtensions()Object.seal()Object.setPrototypeOf()[[Prototype]] property).Object.values()Object instances and Object prototype objectAll objects in JavaScript are descended from Object; all objects inherit methods and properties from Object.prototype, although they may be overridden. For example, other constructors' prototypes override the constructor property and provide their own toString() methods. Changes to the Object prototype object are propagated to all objects unless the properties and methods subject to those changes are overridden further along the prototype chain.
Object.prototype.constructorObject.prototype.__proto__ \nObject.prototype.__noSuchMethod__ \nObject.prototype.__count__ Object.prototype.__parent__ Object.prototype.__defineGetter__() \nObject.prototype.__defineSetter__() \nObject.prototype.__lookupGetter__() \n__defineGetter__() method.Object.prototype.__lookupSetter__() \n__defineSetter__() method.Object.prototype.hasOwnProperty()Object.prototype.isPrototypeOf()Object.prototype.propertyIsEnumerable()Object.prototype.toSource() \nObject.prototype.toLocaleString()toString().Object.prototype.toString()Object.prototype.unwatch() \nObject.prototype.valueOf()Object.prototype.watch() \nObject.prototype.eval() There isn't any method in an Object itself to delete its own properties (e.g. like Map.prototype.delete()). To do so one has to use the delete operator.
Object given undefined and null typesThe following examples store an empty Object object in o:
var o = new Object();\n
var o = new Object(undefined);\n
var o = new Object(null);\n
Object to create Boolean objectsThe following examples store Boolean objects in o:
// equivalent to o = new Boolean(true);\nvar o = new Object(true);\n
// equivalent to o = new Boolean(false);\nvar o = new Object(Boolean());\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Object' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object' in that specification. | Standard | Added Object.assign, Object.getOwnPropertySymbols, Object.setPrototypeOf, Object.is |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object' in that specification. | Draft | Added Object.entries, Object.values and Object.getOwnPropertyDescriptors. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\n__count__ \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
\n__noSuchMethod__ \n | \nNo | \nNo | \n1 — 43 | \nNo | \nNo | \nNo | \n
\n__parent__ \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
\n__proto__ \n | \nYes | \nYes | \n1 | \n11 | \nYes | \nYes | \n
constructor | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
assign | \n45 | \nYes | \n34 | \nNo | \n32 | \n9 | \n
create | \n5 | \nYes | \n4 | \n9 | \n11.6 | \n5 | \n
defineProperties | \n5 | \nYes | \n4 | \n9 | \n11.6 | \n5 | \n
defineProperty | \n5 | \nYes | \n4 | \n 9\n
| \n11.6 | \n 5.1\n
| \n
entries | \n54 | \n14 | \n47 | \nNo | \n41 | \n10.1 | \n
freeze | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
fromEntries | \nNo | \nNo | \n63 | \nNo | \nNo | \nNo | \n
\ngetNotifier \n | \n36 — 52 | \nNo | \nNo | \nNo | \nNo | \nNo | \n
getOwnPropertyDescriptor | \n5 | \nYes | \n4 | \n8 | \n12 | \n5 | \n
getOwnPropertyDescriptors | \n54 | \n15 | \n50 | \nNo | \n41 | \n10 | \n
getOwnPropertyNames | \n5 | \nYes | \n4 | \n9 | \n12 | \n5 | \n
getOwnPropertySymbols | \n38 | \nYes | \n36 | \nNo | \n25 | \n9 | \n
getPrototypeOf | \n5 | \nYes | \n3.5 | \n9 | \n12.1 | \n5 | \n
is | \n30 | \nYes | \n22 | \nNo | \nYes | \n9 | \n
isExtensible | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
isFrozen | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
isSealed | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
keys | \n5 | \nYes | \n4 | \n9 | \n12 | \n5 | \n
\nobserve \n | \n36 — 52 | \nNo | \nNo | \nNo | \nNo | \nNo | \n
preventExtensions | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
\n__defineGetter__ \n | \nYes | \nYes | \n 1\n
| \n11 | \nYes | \nYes | \n
\n__defineSetter__ \n | \nYes | \nYes | \n 1\n
| \n11 | \nYes | \nYes | \n
\n__lookupGetter__ \n | \nYes | \nYes | \n1 | \n11 | \nYes | \nYes | \n
\n__lookupSetter__ \n | \nYes | \nYes | \n1 | \n11 | \nYes | \nYes | \n
\neval \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
hasOwnProperty | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
isPrototypeOf | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \n
propertyIsEnumerable | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \n
toLocaleString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nunwatch \n | \nNo | \nNo | \n1 — 58 | \nNo | \nNo | \nNo | \n
valueOf | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nwatch \n | \nNo | \nNo | \n1 — 58 | \nNo | \nNo | \nNo | \n
seal | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
setPrototypeOf | \n34 | \nYes | \n31 | \n11 | \nYes | \n9 | \n
\nunobserve \n | \n36 — 52 | \nNo | \nNo | \nNo | \nNo | \nNo | \n
values | \n54 | \n14 | \n47 | \nNo | \n41 | \n10.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\n__count__ \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
\n__noSuchMethod__ \n | \nNo | \nNo | \nNo | \n4 — 43 | \nNo | \nNo | \nNo | \n
\n__parent__ \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
\n__proto__ \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
constructor | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
assign | \nNo | \n45 | \nYes | \n34 | \nNo | \nYes | \n5.0 | \n
create | \nYes | \nYes | \nYes | \n4 | \n11.5 | \nYes | \nYes | \n
defineProperties | \nYes | \nYes | \nYes | \n4 | \n11.5 | \nYes | \nYes | \n
defineProperty | \nYes | \nYes | \nYes | \n4 | \n11.5 | \nYes | \nYes | \n
entries | \n54 | \n54 | \nYes | \n47 | \n41 | \n10.1 | \n6.0 | \n
freeze | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
fromEntries | \nNo | \nNo | \nNo | \n63 | \nNo | \nNo | \nNo | \n
\ngetNotifier \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
getOwnPropertyDescriptor | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getOwnPropertyDescriptors | \n? | \n54 | \nYes | \n50 | \n? | \n? | \n6.0 | \n
getOwnPropertyNames | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getOwnPropertySymbols | \n38 | \n38 | \nYes | \n36 | \n25 | \n9 | \nYes | \n
getPrototypeOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
is | \nYes | \nYes | \nYes | \n22 | \nYes | \n9 | \nYes | \n
isExtensible | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
isFrozen | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
isSealed | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
keys | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nobserve \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
preventExtensions | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\n__defineGetter__ \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\n__defineSetter__ \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\n__lookupGetter__ \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\n__lookupSetter__ \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\neval \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
hasOwnProperty | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
isPrototypeOf | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \n
propertyIsEnumerable | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \n
toLocaleString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nunwatch \n | \nNo | \nNo | \nNo | \n4 — 58 | \nNo | \nNo | \nNo | \n
valueOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nwatch \n | \nNo | \nNo | \nNo | \n4 — 58 | \nNo | \nNo | \nNo | \n
seal | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setPrototypeOf | \nYes | \nYes | \nYes | \n31 | \nYes | \nYes | \nYes | \n
\nunobserve \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
values | \n54 | \n54 | \nYes | \n47 | \n41 | \n10.3 | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
prototype | \nYes | \n
\n__count__ \n | \nNo | \n
\n__noSuchMethod__ \n | \nNo | \n
\n__parent__ \n | \nNo | \n
\n__proto__ \n | \nYes | \n
constructor | \nYes | \n
assign | \n4.0.0 | \n
create | \nYes | \n
defineProperties | \nYes | \n
defineProperty | \nYes | \n
entries | \n 7.0.0\n
| \n
freeze | \nYes | \n
fromEntries | \nNo | \n
\ngetNotifier \n | \nNo | \n
getOwnPropertyDescriptor | \nYes | \n
getOwnPropertyDescriptors | \n 7.0.0\n
| \n
getOwnPropertyNames | \nYes | \n
getOwnPropertySymbols | \n0.12 | \n
getPrototypeOf | \nYes | \n
is | \n0.10 | \n
isExtensible | \nYes | \n
isFrozen | \nYes | \n
isSealed | \nYes | \n
keys | \nYes | \n
\nobserve \n | \nNo | \n
preventExtensions | \nYes | \n
\n__defineGetter__ \n | \nYes | \n
\n__defineSetter__ \n | \nYes | \n
\n__lookupGetter__ \n | \nYes | \n
\n__lookupSetter__ \n | \nYes | \n
\neval \n | \nNo | \n
hasOwnProperty | \nYes | \n
isPrototypeOf | \nYes | \n
propertyIsEnumerable | \nYes | \n
toLocaleString | \nYes | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
\nunwatch \n | \nNo | \n
valueOf | \nYes | \n
\nwatch \n | \nNo | \n
seal | \nYes | \n
setPrototypeOf | \n0.12 | \n
\nunobserve \n | \nNo | \n
values | \n 7.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object\n
Logical operators are typically used with Boolean (logical) values. When they are, they return a Boolean value. However, the && and || operators actually return the value of one of the specified operands, so if these operators are used with non-Boolean values, they may return a non-Boolean value.
The logical operators are described in the following table:
| Operator | Usage | Description |
|---|---|---|
Logical AND (&&) | expr1 && expr2 | Returns expr1 if it can be converted to false; otherwise, returns expr2. Thus, when used with Boolean values, && returns true if both operands are true; otherwise, returns false. |
Logical OR (||) | expr1 || expr2 | Returns expr1 if it can be converted to true; otherwise, returns expr2. Thus, when used with Boolean values, || returns true if either operand is true. |
Logical NOT (!) | !expr | Returns false if its single operand can be converted to true; otherwise, returns true. |
If a value can be converted to true, the value is so-called truthy. If a value can be converted to false, the value is so-called falsy.
Examples of expressions that can be converted to false are:
null;NaN;0;\"\" or '' or ``); undefined.Even though the && and || operators can be used with operands that are not Boolean values, they can still be considered Boolean operators since their return values can always be converted to Boolean values.
As logical expressions are evaluated left to right, they are tested for possible \"short-circuit\" evaluation using the following rules:
false && (anything) is short-circuit evaluated to false.true || (anything) is short-circuit evaluated to true.The rules of logic guarantee that these evaluations are always correct. Note that the anything part of the above expressions is not evaluated, so any side effects of doing so do not take effect. Also, note that the anything part of the above expression is any single logical expression (as indicated by the parentheses).
For example, the following two functions are equivalent.
function shortCircuitEvaluation() { \n // logical OR (||)\n doSomething() || doSomethingElse();\n \n // logical AND (&&)\n doSomething() && doSomethingElse();\n}\n\nfunction equivalentEvaluation() {\n\n // logical OR (||)\n var orFlag = doSomething();\n if (!orFlag) {\n doSomethingElse();\n }\n \n \n // logical AND (&&)\n var andFlag = doSomething();\n if (andFlag) {\n doSomethingElse();\n }\n}\n However, the following expressions are not equivalent due to operator precedence and stresses the importance of requiring the right-hand operand to be a single expression (grouped if needed by parentheses).
false && true || true // returns true\nfalse && (true || true) // returns false
The following code shows examples of the && (logical AND) operator.
a1 = true && true // t && t returns true\na2 = true && false // t && f returns false\na3 = false && true // f && t returns false\na4 = false && (3 == 4) // f && f returns false\na5 = 'Cat' && 'Dog' // t && t returns \"Dog\"\na6 = false && 'Cat' // f && t returns false\na7 = 'Cat' && false // t && f returns false\na8 = '' && false // f && f returns \"\"\na9 = false && '' // f && f returns false\n
The following code shows examples of the || (logical OR) operator.
o1 = true || true // t || t returns true\no2 = false || true // f || t returns true\no3 = true || false // t || f returns true\no4 = false || (3 == 4) // f || f returns false\no5 = 'Cat' || 'Dog' // t || t returns \"Cat\"\no6 = false || 'Cat' // f || t returns \"Cat\"\no7 = 'Cat' || false // t || f returns \"Cat\"\no8 = '' || false // f || f returns false\no9 = false || '' // f || f returns \"\"\n
The following code shows examples of the ! (logical NOT) operator.
n1 = !true // !t returns false\nn2 = !false // !f returns true\nn3 = !'Cat' // !t returns false\n
the following operation involving Booleans:
bCondition1 && bCondition2
is always equal to:
!(!bCondition1 || !bCondition2)
the following operation involving Booleans:
bCondition1 || bCondition2
is always equal to:
!(!bCondition1 && !bCondition2)
the following operation involving Booleans:
!!bCondition
is always equal to:
bCondition
As logical expressions are evaluated left to right, it is always possible to remove parentheses from a complex expression following some rules.
The following composite operation involving Booleans:
bCondition1 || (bCondition2 && bCondition3)
is always equal to:
bCondition1 || bCondition2 && bCondition3
The following composite operation involving Booleans:
bCondition1 && (bCondition2 || bCondition3)
is always equal to:
!(!bCondition1 || !bCondition2 && !bCondition3)
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) | Standard | Defined in several sections of the specification: Logical NOT Operator, Binary Logical Operators\n |
| ECMAScript 2015 (6th Edition, ECMA-262) | Standard | Defined in several sections of the specification: Logical NOT Operator, Binary Logical Operators\n |
| ECMAScript Latest Draft (ECMA-262) | Draft | Defined in several sections of the specification: Logical NOT Operator, Binary Logical Operators\n |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
Logical AND (&&) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Logical OR (||) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Logical NOT (!) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
Logical AND (&&) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Logical OR (||) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Logical NOT (!) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
Logical AND (&&) | \nYes | \n
Logical OR (||) | \nYes | \n
Logical NOT (!) | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators\n
Property accessors provide access to an object's properties by using the dot notation or the bracket notation.
object.property\nobject['property']\n
One can think of an object as an associative array (a.k.a. map, dictionary, hash, lookup table). The keys in this array are the names of the object's properties. It's typical when speaking of an object's properties to make a distinction between properties and methods. However, the property/method distinction is little more than a convention. A method is simply a property that can be called, for example if it has a reference to a Function instance as its value.
There are two ways to access properties: dot notation and bracket notation.
get = object.property;\nobject.property = set;\n
In this code, property must be a valid JavaScript identifier, i.e. a sequence of alphanumerical characters, also including the underscore (\"_\") and dollar sign (\"$\"), that cannot start with a number. For example, object.$1 is valid, while object.1 is not.
document.createElement('pre');\n Here, the method named \"createElement\" is retrieved from document and is called.
If you use a method for a numeric literal and the numeric literal has no exponent and no decimal point, leave white-space(s) before the dot that precedes the method call to prevent the dot from being interpreted as a decimal point.
77 .toExponential();\n// or\n77\n.toExponential();\n// or\n(77).toExponential();\n// or\n77..toExponential();\n// or\n77.0.toExponential();\n// because 77. === 77.0, no ambiguity
get = object[property_name];\nobject[property_name] = set;\n
property_name is a string. The string does not have to be a valid identifier; it can have any value, e.g. \"1foo\", \"!bar!\", or even \" \" (a space).
document['createElement']('pre');\n This does the exact same thing as the previous example.
A space before bracket notation is allowed.
document ['createElement']('pre'); Property names must be strings. This means that non-string objects cannot be used as keys in the object. Any non-string object, including a number, is typecasted into a string via the toString method.
var object = {};\nobject['1'] = 'value';\nconsole.log(object[1]);\n This outputs \"value\", since 1 is type-casted into '1'.
var foo = {unique_prop: 1}, bar = {unique_prop: 2}, object = {};\nobject[foo] = 'value';\nconsole.log(object[bar]);\n This also outputs \"value\", since both foo and bar are converted to the same string. In the SpiderMonkey JavaScript engine, this string would be \"['object Object']\".
A method is not bound to the object that it is a method of. Specifically, this is not fixed in a method, i.e., this does not necessarily refer to an object containing the method. this is instead \"passed\" by the function call. See method binding.
eval\nJavaScript novices often make the mistake of using eval where the bracket notation can be used instead. For example, the following syntax is often seen in many scripts.
x = eval('document.forms.form_name.elements.' + strFormControl + '.value');\n eval is slow and should be avoided whenever possible. Also, strFormControl would have to hold an identifier, which is not required for names and IDs of form controls. It is better to use bracket notation instead:
x = document.forms['form_name'].elements[strFormControl].value;\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Property Accessors' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Property Accessors' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'Property Accessors' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'Property Accessors' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors\n
Creates a JavaScript Date instance that represents a single moment in time. Date objects are based on a time value that is the number of milliseconds since 1 January 1970 UTC.
new Date();\nnew Date(value);\nnew Date(dateString);\nnew Date(year, monthIndex [, day [, hours [, minutes [, seconds [, milliseconds]]]]]);\n
Note: JavaScript Date objects can only be instantiated by calling JavaScript Date as a constructor: calling it as a regular function (i.e. without the new operator) will return a string rather than a Date object; unlike other JavaScript object types, JavaScript Date objects have no literal syntax.
Note: The argument monthIndex is 0-based. This means that January = 0 and December = 11.
Note: Where Date is called as a constructor with more than one argument, if values are greater than their logical range (e.g. 13 is provided as the month value or 70 for the minute value), the adjacent value will be adjusted. E.g. new Date(2013, 13, 1) is equivalent to new Date(2014, 1, 1), both create a date for 2014-02-01 (note that the month is 0-based). Similarly for other values: new Date(2013, 2, 1, 0, 70) is equivalent to new Date(2013, 2, 1, 1, 10) which both create a date for 2013-03-01T01:10:00.
Note: Where Date is called as a constructor with more than one argument, the specified arguments represent local time. If UTC is desired, use new Date( with the same arguments.Date.UTC(...))
valuedateStringDate.parse() method (IETF-compliant RFC 2822 timestamps and also a version of ISO8601). Note: parsing of date strings with the Date constructor (and Date.parse, they are equivalent) is strongly discouraged due to browser differences and inconsistencies. Support for RFC 2822 format strings is by convention only. Support for ISO 8601 formats differs in that date-only strings (e.g. \"1970-01-01\") are treated as UTC, not local.
yearmonthIndexday Optional\nhours Optional\nminutes Optional\nseconds Optional\nmilliseconds Optional\nDate object for the current date and time according to system settings for timezone offset.Date object range is -100,000,000 days to 100,000,000 days relative to January 1, 1970 UTC.Date object provides uniform behavior across platforms. The time value can be passed between systems to create a date that represents the same moment in time.Date object supports a number of UTC (universal) methods, as well as local time methods. UTC, also known as Greenwich Mean Time (GMT), refers to the time as set by the World Time Standard. The local time is the time known to the computer where JavaScript is executed.Date as a function (i.e., without the new operator) will return a string representing the current date and time.Date.prototypeDate object.Date.lengthDate.length is 7. This is the number of arguments handled by the constructor.Date.now()Date.parse()Note: Parsing of strings with Date.parse is strongly discouraged due to browser differences and inconsistencies.
Date.UTC()Date instancesAll Date instances inherit from Date.prototype. The prototype object of the Date constructor can be modified to affect all Date instances.
Date.prototype.getDate()Date.prototype.getDay()Date.prototype.getFullYear()Date.prototype.getHours()Date.prototype.getMilliseconds()Date.prototype.getMinutes()Date.prototype.getMonth()Date.prototype.getSeconds()Date.prototype.getTime()Date.prototype.getTimezoneOffset()Date.prototype.getUTCDate()Date.prototype.getUTCDay()Date.prototype.getUTCFullYear()Date.prototype.getUTCHours()Date.prototype.getUTCMilliseconds()Date.prototype.getUTCMinutes()Date.prototype.getUTCMonth()Date.prototype.getUTCSeconds()Date.prototype.getYear() \ngetFullYear() instead.Date.prototype.setDate()Date.prototype.setFullYear()Date.prototype.setHours()Date.prototype.setMilliseconds()Date.prototype.setMinutes()Date.prototype.setMonth()Date.prototype.setSeconds()Date.prototype.setTime()Date object to the time represented by a number of milliseconds since January 1, 1970, 00:00:00 UTC, allowing for negative numbers for times prior.Date.prototype.setUTCDate()Date.prototype.setUTCFullYear()Date.prototype.setUTCHours()Date.prototype.setUTCMilliseconds()Date.prototype.setUTCMinutes()Date.prototype.setUTCMonth()Date.prototype.setUTCSeconds()Date.prototype.setYear() \nsetFullYear() instead.Date.prototype.toDateString()Date as a human-readable string like 'Thu Apr 12 2018'Date.prototype.toISOString()Date.prototype.toJSON()Date using toISOString(). Intended for use by JSON.stringify().Date.prototype.toGMTString() \nDate based on the GMT (UT) time zone. Use toUTCString() instead.Date.prototype.toLocaleDateString()Date.prototype.toLocaleFormat() \nDate.prototype.toLocaleString()Object.prototype.toLocaleString() method.Date.prototype.toLocaleTimeString()Date.prototype.toSource() \nDate object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.Date.prototype.toString()Date object. Overrides the Object.prototype.toString() method.Date.prototype.toTimeString()Date as a human-readable string.Date.prototype.toUTCString()Date.prototype.valueOf()Date object. Overrides the Object.prototype.valueOf() method.Date objectThe following examples show several ways to create JavaScript dates:
Note: parsing of date strings with the Date constructor (and Date.parse, they are equivalent) is strongly discouraged due to browser differences and inconsistencies.
var today = new Date();\nvar birthday = new Date('December 17, 1995 03:24:00');\nvar birthday = new Date('1995-12-17T03:24:00');\nvar birthday = new Date(1995, 11, 17);\nvar birthday = new Date(1995, 11, 17, 3, 24, 0);\n In order to create and get dates between the years 0 and 99 the Date.prototype.setFullYear() and Date.prototype.getFullYear() methods should be used.
var date = new Date(98, 1); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)\n\n// Deprecated method, 98 maps to 1998 here as well\ndate.setYear(98); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT)\n\ndate.setFullYear(98); // Sat Feb 01 0098 00:00:00 GMT+0000 (BST)\n
The following examples show how to determine the elapsed time between two JavaScript dates in milliseconds.
Due to the differing lengths of days (due to daylight saving changeover), months and years, expressing elapsed time in units greater than hours, minutes and seconds requires addressing a number of issues and should be thoroughly researched before being attempted.
// using Date objects\nvar start = Date.now();\n\n// the event to time goes here:\ndoSomethingForALongTime();\nvar end = Date.now();\nvar elapsed = end - start; // elapsed time in milliseconds\n
// using built-in methods\nvar start = new Date();\n\n// the event to time goes here:\ndoSomethingForALongTime();\nvar end = new Date();\nvar elapsed = end.getTime() - start.getTime(); // elapsed time in milliseconds\n
// to test a function and get back its return\nfunction printElapsedTime(fTest) {\n var nStartTime = Date.now(),\n vReturn = fTest(),\n nEndTime = Date.now();\n\n console.log('Elapsed time: ' + String(nEndTime - nStartTime) + ' milliseconds');\n return vReturn;\n}\n\nvar yourFunctionReturn = printElapsedTime(yourFunction);\n Note: In browsers that support the Web Performance API's high-resolution time feature, Performance.now() can provide more reliable and precise measurements of elapsed time than Date.now().
var seconds = Math.floor(Date.now() / 1000);\n
In this case it's important to return only an integer (so a simple division won't do), and also to only return actually elapsed seconds (that's why this code uses Math.floor() and not Math.round()).
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n Yes\n
| \nYes | \nYes | \n
@@toPrimitive | \n? | \n? | \n44 | \n? | \n? | \n? | \n
UTC | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getDate | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getDay | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getFullYear | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getHours | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getMilliseconds | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getMinutes | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getMonth | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getSeconds | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getTime | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getTimezoneOffset | \nYes | \nYes | \n1 | \n5 | \nYes | \nYes | \n
getUTCDate | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getUTCDay | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getUTCFullYear | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getUTCHours | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getUTCMilliseconds | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getUTCMinutes | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getUTCMonth | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
getUTCSeconds | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ngetYear \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
now | \n5 | \nYes | \n3 | \n9 | \n10.5 | \n4 | \n
parse | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nparse: ISO 8601 format | \nYes | \n? | \n4 | \n9 | \nYes | \nYes | \n
prototype | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nprototype: Ordinary object (ES2015) | \n? | \n? | \n41 | \n? | \n? | \n? | \n
setDate | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setFullYear | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setHours | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setMilliseconds | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setMinutes | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setMonth | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setSeconds | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setTime | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setUTCDate | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setUTCFullYear | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setUTCHours | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setUTCMilliseconds | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setUTCMinutes | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setUTCMonth | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
setUTCSeconds | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nsetYear \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toDateString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ntoGMTString \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toISOString | \nYes | \nYes | \n1 | \n9 | \nYes | \nYes | \n
toJSON | \nYes | \nYes | \n1 | \n8 | \nYes | \nYes | \n
toLocaleDateString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toLocaleDateString.locales | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
toLocaleDateString.options | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
\ntoLocaleDateString: IANA time zone names in timeZone option | \n24 | \n? | \n52 | \n? | \n? | \n? | \n
\ntoLocaleFormat \n | \nNo | \nNo | \n1.5 — 58 | \nNo | \nNo | \nNo | \n
toLocaleString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toLocaleString.locales | \n24 | \n? | \n29 | \n11 | \n15 | \n10 | \n
toLocaleString.options | \n24 | \n? | \n29 | \n11 | \n15 | \n10 | \n
\ntoLocaleString: IANA time zone names in timeZone option | \n24 | \n? | \n52 | \n? | \n? | \n? | \n
toLocaleTimeString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toLocaleTimeString.locales | \n24 | \n? | \n29 | \n11 | \n15 | \n10 | \n
toLocaleTimeString.options | \n24 | \n? | \n29 | \n11 | \n15 | \n10 | \n
\ntoLocaleTimeString: IANA time zone names in timeZone option | \n24 | \n? | \n52 | \n? | \n? | \n? | \n
\ntoSource \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toTimeString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toUTCString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
valueOf | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
@@toPrimitive | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
UTC | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getDate | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getDay | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getFullYear | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getHours | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getMilliseconds | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getMinutes | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getMonth | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getSeconds | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getTime | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getTimezoneOffset | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getUTCDate | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getUTCDay | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getUTCFullYear | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getUTCHours | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getUTCMilliseconds | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getUTCMinutes | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getUTCMonth | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
getUTCSeconds | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ngetYear \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
now | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
parse | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nparse: ISO 8601 format | \nYes | \nYes | \n? | \n4 | \nYes | \nYes | \nYes | \n
prototype | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nprototype: Ordinary object (ES2015) | \n? | \n? | \n? | \n41 | \n? | \n? | \n? | \n
setDate | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setFullYear | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setHours | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setMilliseconds | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setMinutes | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setMonth | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setSeconds | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setTime | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setUTCDate | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setUTCFullYear | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setUTCHours | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setUTCMilliseconds | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setUTCMinutes | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setUTCMonth | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
setUTCSeconds | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nsetYear \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toDateString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ntoGMTString \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toISOString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toJSON | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toLocaleDateString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toLocaleDateString.locales | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
toLocaleDateString.options | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
\ntoLocaleDateString: IANA time zone names in timeZone option | \n? | \n? | \n? | \nNo | \n? | \n? | \n? | \n
\ntoLocaleFormat \n | \nNo | \nNo | \nNo | \n4 — 58 | \nNo | \nNo | \nNo | \n
toLocaleString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toLocaleString.locales | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
toLocaleString.options | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
\ntoLocaleString: IANA time zone names in timeZone option | \n? | \n? | \n? | \nNo | \n? | \n? | \n? | \n
toLocaleTimeString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toLocaleTimeString.locales | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
toLocaleTimeString.options | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
\ntoLocaleTimeString: IANA time zone names in timeZone option | \n? | \n? | \n? | \nNo | \n? | \n? | \n? | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toTimeString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toUTCString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
valueOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
@@toPrimitive | \n6.0.0 | \n
UTC | \nYes | \n
getDate | \nYes | \n
getDay | \nYes | \n
getFullYear | \nYes | \n
getHours | \nYes | \n
getMilliseconds | \nYes | \n
getMinutes | \nYes | \n
getMonth | \nYes | \n
getSeconds | \nYes | \n
getTime | \nYes | \n
getTimezoneOffset | \nYes | \n
getUTCDate | \nYes | \n
getUTCDay | \nYes | \n
getUTCFullYear | \nYes | \n
getUTCHours | \nYes | \n
getUTCMilliseconds | \nYes | \n
getUTCMinutes | \nYes | \n
getUTCMonth | \nYes | \n
getUTCSeconds | \nYes | \n
\ngetYear \n | \nYes | \n
now | \nYes | \n
parse | \nYes | \n
\nparse: ISO 8601 format | \n? | \n
prototype | \nYes | \n
\nprototype: Ordinary object (ES2015) | \n? | \n
setDate | \nYes | \n
setFullYear | \nYes | \n
setHours | \nYes | \n
setMilliseconds | \nYes | \n
setMinutes | \nYes | \n
setMonth | \nYes | \n
setSeconds | \nYes | \n
setTime | \nYes | \n
setUTCDate | \nYes | \n
setUTCFullYear | \nYes | \n
setUTCHours | \nYes | \n
setUTCMilliseconds | \nYes | \n
setUTCMinutes | \nYes | \n
setUTCMonth | \nYes | \n
setUTCSeconds | \nYes | \n
\nsetYear \n | \nYes | \n
toDateString | \nYes | \n
\ntoGMTString \n | \nYes | \n
toISOString | \nYes | \n
toJSON | \nYes | \n
toLocaleDateString | \n? | \n
toLocaleDateString.locales | \n? | \n
toLocaleDateString.options | \n? | \n
\ntoLocaleDateString: IANA time zone names in timeZone option | \n? | \n
\ntoLocaleFormat \n | \nNo | \n
toLocaleString | \n? | \n
toLocaleString.locales | \n? | \n
toLocaleString.options | \n? | \n
\ntoLocaleString: IANA time zone names in timeZone option | \n? | \n
toLocaleTimeString | \n? | \n
toLocaleTimeString.locales | \n? | \n
toLocaleTimeString.options | \n? | \n
\ntoLocaleTimeString: IANA time zone names in timeZone option | \n? | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
toTimeString | \nYes | \n
toUTCString | \nYes | \n
valueOf | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date\n
Operator precedence determines the way in which operators are parsed with respect to each other. Operators with higher precedence become the operands of operators with lower precedence.
Associativity determines the way in which operators of the same precedence are parsed. For example, consider an expression:
a OP b OP c\n
Left-associativity (left-to-right) means that it is processed as (a OP b) OP c, while right-associativity (right-to-left) means it is interpreted as a OP (b OP c). Assignment operators are right-associative, so you can write:
a = b = 5;\n
with the expected result that a and b get the value 5. This is because the assignment operator returns the value that is assigned. First, b is set to 5. Then the a is also set to 5, the return value of b = 5, aka right operand of the assignment.
The following table is ordered from highest (20) to lowest (1) precedence.
| Precedence | Operator type | Associativity | Individual operators |
|---|---|---|---|
| 20 | Grouping | n/a | ( … ) |
| 19 | Member Access | left-to-right | … . … |
Computed Member Access | left-to-right | … [ … ] | |
\nnew (with argument list) | n/a | new … ( … ) | |
| Function Call | left-to-right | … ( … ) | |
| 18 | \nnew (without argument list) | right-to-left | new … |
| 17 | Postfix Increment | n/a | … ++ |
Postfix Decrement | … -- | ||
| 16 | Logical NOT | right-to-left | ! … |
| Bitwise NOT | ~ … | ||
| Unary Plus | + … | ||
| Unary Negation | - … | ||
| Prefix Increment | ++ … | ||
| Prefix Decrement | -- … | ||
| typeof | typeof … | ||
| void | void … | ||
| delete | delete … | ||
| await | await … | ||
| 15 | Exponentiation | right-to-left | … ** … |
| 14 | Multiplication | left-to-right | … * … |
| Division | … / … | ||
| Remainder | … % … | ||
| 13 | Addition | left-to-right | … + … |
| Subtraction | … - … | ||
| 12 | Bitwise Left Shift | left-to-right | … << … |
| Bitwise Right Shift | … >> … | ||
| Bitwise Unsigned Right Shift | … >>> … | ||
| 11 | Less Than | left-to-right | … < … |
| Less Than Or Equal | … <= … | ||
| Greater Than | … > … | ||
| Greater Than Or Equal | … >= … | ||
| in | … in … | ||
| instanceof | … instanceof … | ||
| 10 | Equality | left-to-right | … == … |
| Inequality | … != … | ||
| Strict Equality | … === … | ||
| Strict Inequality | … !== … | ||
| 9 | Bitwise AND | left-to-right | … & … |
| 8 | Bitwise XOR | left-to-right | … ^ … |
| 7 | Bitwise OR | left-to-right | … | … |
| 6 | Logical AND | left-to-right | … && … |
| 5 | Logical OR | left-to-right | … || … |
| 4 | Conditional | right-to-left | … ? … : … |
| 3 | Assignment | right-to-left | … = … |
… += … | |||
… -= … | |||
… **= … | |||
… *= … | |||
… /= … | |||
… %= … | |||
… <<= … | |||
… >>= … | |||
… >>>= … | |||
… &= … | |||
… ^= … | |||
… |= … | |||
| 2 | yield | right-to-left | yield … |
| yield* | yield* … | ||
| 1 | Comma / Sequence | left-to-right | … , … |
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence\n
The class expression is one way to define a class in ECMAScript 2015. Similar to function expressions, class expressions can be named or unnamed. If named, the name of the class is local to the class body only. JavaScript classes use prototype-based inheritance.
var MyClass = class [className] [extends] {\n // class body\n}; A class expression has a similar syntax to a class statement (declaration). However, with class expressions, you are able to omit the class name (\"binding identifier\"), which you can't with class statements. Additionally, class expressions allow you to redefine/re-declare classes and don't throw any type errors like class declaration. The constructor property is optional. And, typeof the classes generated using this keyword will always be \"function\".
Just like with class statements, the class body of class expressions is executed in strict mode.
'use strict';\nvar Foo = class {}; // constructor property is optional\nvar Foo = class {}; // Re-declaration is allowed\n\ntypeof Foo; //returns \"function\"\ntypeof class {}; //returns \"function\"\n\nFoo instanceof Object; // true\nFoo instanceof Function; // true\nclass Foo {}; // Throws TypeError, doesn't allow re-declaration\n This is just a simple anonymous class expression which you can refer to using the variable \"Foo\".
var Foo = class {\n constructor() {}\n bar() {\n return 'Hello World!';\n }\n};\n\nvar instance = new Foo();\ninstance.bar(); // \"Hello World!\"\nFoo.name; // \"Foo\"\n If you want to refer to the current class inside the class body, you can create a named class expression. This name is only visible in the scope of the class expression itself.
var Foo = class NamedFoo {\n constructor() {}\n whoIsThere() {\n return NamedFoo.name;\n }\n}\nvar bar = new Foo();\nbar.whoIsThere(); // \"NamedFoo\"\nNamedFoo.name; // ReferenceError: NamedFoo is not defined\nFoo.name; // \"NamedFoo\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n42 | \nYes | \n45 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n42 | \n42 | \nYes | \n45 | \nYes | \nYes | \n4.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/class\n
An assignment operator assigns a value to its left operand based on the value of its right operand.
The basic assignment operator is equal (=), which assigns the value of its right operand to its left operand. That is, x = y assigns the value of y to x. The other assignment operators are usually shorthand for standard operations, as shown in the following definitions and examples.
| Name | Shorthand operator | Meaning |
|---|---|---|
| Assignment | x = y | x = y |
| Addition assignment | x += y | x = x + y |
| Subtraction assignment | x -= y | x = x - y |
| Multiplication assignment | x *= y | x = x * y |
| Division assignment | x /= y | x = x / y |
| Remainder assignment | x %= y | x = x % y |
| Exponentiation assignment | x **= y | x = x ** y |
| Left shift assignment | x <<= y | x = x << y |
| Right shift assignment | x >>= y | x = x >> y |
| Unsigned right shift assignment | x >>>= y | x = x >>> y |
| Bitwise AND assignment | x &= y | x = x & y |
| Bitwise XOR assignment | x ^= y | x = x ^ y |
| Bitwise OR assignment | x |= y | x = x | y |
Simple assignment operator is used to assign a value to a variable. The assignment operation evaluates to the assigned value. Chaining the assignment operator is possible in order to assign a single value to multiple variables. See the example.
Operator: x = y\n
// Assuming the following variables\n// x = 5\n// y = 10\n// z = 25\n\nx = y // x is 10\nx = y = z // x, y and z are all 25\n
The addition assignment operator adds the value of the right operand to a variable and assigns the result to the variable. The types of the two operands determine the behavior of the addition assignment operator. Addition or concatenation is possible. See the addition operator for more details.
Operator: x += y \nMeaning: x = x + y\n
// Assuming the following variables\n// foo = 'foo'\n// bar = 5\n// baz = true\n\n\n// Number + Number -> addition\nbar += 2 // 7\n\n// Boolean + Number -> addition\nbaz += 1 // 2\n\n// Boolean + Boolean -> addition\nbaz += false // 1\n\n// Number + String -> concatenation\nbar += 'foo' // \"5foo\"\n\n// String + Boolean -> concatenation\nfoo += false // \"foofalse\"\n\n// String + String -> concatenation\nfoo += 'bar' // \"foobar\"\n
The subtraction assignment operator subtracts the value of the right operand from a variable and assigns the result to the variable. See the subtraction operator for more details.
Operator: x -= y \nMeaning: x = x - y\n
// Assuming the following variable\n// bar = 5\n\nbar -= 2 // 3\nbar -= 'foo' // NaN\n
The multiplication assignment operator multiplies a variable by the value of the right operand and assigns the result to the variable. See the multiplication operator for more details.
Operator: x *= y \nMeaning: x = x * y\n
// Assuming the following variable\n// bar = 5\n\nbar *= 2 // 10\nbar *= 'foo' // NaN\n
The division assignment operator divides a variable by the value of the right operand and assigns the result to the variable. See the division operator for more details.
Operator: x /= y \nMeaning: x = x / y\n
// Assuming the following variable\n// bar = 5\n\nbar /= 2 // 2.5\nbar /= 'foo' // NaN\nbar /= 0 // Infinity\n
The remainder assignment operator divides a variable by the value of the right operand and assigns the remainder to the variable. See the remainder operator for more details.
Operator: x %= y \nMeaning: x = x % y\n
// Assuming the following variable\n// bar = 5\n\nbar %= 2 // 1\nbar %= 'foo' // NaN\nbar %= 0 // NaN\n
The exponentiation assignment operator evaluates to the result of raising first operand to the power second operand. See the exponentiation operator for more details.
Operator: x **= y \nMeaning: x = x ** y\n
// Assuming the following variable\n// bar = 5\n\nbar **= 2 // 25\nbar **= 'foo' // NaN
The left shift assignment operator moves the specified amount of bits to the left and assigns the result to the variable. See the left shift operator for more details.
Operator: x <<= y \nMeaning: x = x << y\n
var bar = 5; // (00000000000000000000000000000101)\nbar <<= 2; // 20 (00000000000000000000000000010100)\n
The right shift assignment operator moves the specified amount of bits to the right and assigns the result to the variable. See the right shift operator for more details.
Operator: x >>= y \nMeaning: x = x >> y\n
var bar = 5; // (00000000000000000000000000000101)\nbar >>= 2; // 1 (00000000000000000000000000000001)\n\nvar bar = -5; // (-00000000000000000000000000000101)\nbar >>= 2; // -2 (-00000000000000000000000000000010)\n
The unsigned right shift assignment operator moves the specified amount of bits to the right and assigns the result to the variable. See the unsigned right shift operator for more details.
Operator: x >>>= y \nMeaning: x = x >>> y\n
var bar = 5; // (00000000000000000000000000000101)\nbar >>>= 2; // 1 (00000000000000000000000000000001)\n\nvar bar = -5; // (-00000000000000000000000000000101)\nbar >>>= 2; // 1073741822 (00111111111111111111111111111110)
The bitwise AND assignment operator uses the binary representation of both operands, does a bitwise AND operation on them and assigns the result to the variable. See the bitwise AND operator for more details.
Operator: x &= y \nMeaning: x = x & y\n
var bar = 5;\n// 5: 00000000000000000000000000000101\n// 2: 00000000000000000000000000000010\nbar &= 2; // 0\n
The bitwise XOR assignment operator uses the binary representation of both operands, does a bitwise XOR operation on them and assigns the result to the variable. See the bitwise XOR operator for more details.
Operator: x ^= y \nMeaning: x = x ^ y\n
var bar = 5;\nbar ^= 2; // 7\n// 5: 00000000000000000000000000000101\n// 2: 00000000000000000000000000000010\n// -----------------------------------\n// 7: 00000000000000000000000000000111\n
The bitwise OR assignment operator uses the binary representation of both operands, does a bitwise OR operation on them and assigns the result to the variable. See the bitwise OR operator for more details.
Operator: x |= y \nMeaning: x = x | y\n
var bar = 5;\nbar |= 2; // 7\n// 5: 00000000000000000000000000000101\n// 2: 00000000000000000000000000000010\n// -----------------------------------\n// 7: 00000000000000000000000000000111\n
In unusual situations, the assignment operator (e.g. x += y) is not identical to the meaning expression (here x = x + y). When the left operand of an assignment operator itself contains an assignment operator, the left operand is evaluated only once. For example:
a[i++] += 5 // i is evaluated only once\na[i++] = a[i++] + 5 // i is evaluated twice\n
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
Addition assignment (x += y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Bitwise AND assignment (x &= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Bitwise OR assignment (x |= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Bitwise XOR assignment (x ^= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Division assignment (x /= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Exponentiation assignment (x **= y) | \n52 | \n? | \n52 | \nNo | \nYes | \n10.1 | \n
Left shift assignment (x <<= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Multiplication assignment (x *= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Remainder assignment (x %= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Right shift assignment (x >>= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Assignment (x = y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Subtraction assignment (x -= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Unsigned right shift assignment (x >>>= y) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
Addition assignment (x += y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Bitwise AND assignment (x &= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Bitwise OR assignment (x |= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Bitwise XOR assignment (x ^= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Division assignment (x /= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Exponentiation assignment (x **= y) | \n51 | \n52 | \n? | \n52 | \nYes | \n10.1 | \n6.0 | \n
Left shift assignment (x <<= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Multiplication assignment (x *= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Remainder assignment (x %= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Right shift assignment (x >>= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Assignment (x = y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Subtraction assignment (x -= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Unsigned right shift assignment (x >>>= y) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
Addition assignment (x += y) | \nYes | \n
Bitwise AND assignment (x &= y) | \nYes | \n
Bitwise OR assignment (x |= y) | \nYes | \n
Bitwise XOR assignment (x ^= y) | \nYes | \n
Division assignment (x /= y) | \nYes | \n
Exponentiation assignment (x **= y) | \n 7.0.0\n
| \n
Left shift assignment (x <<= y) | \nYes | \n
Multiplication assignment (x *= y) | \nYes | \n
Remainder assignment (x %= y) | \nYes | \n
Right shift assignment (x >>= y) | \nYes | \n
Assignment (x = y) | \nYes | \n
Subtraction assignment (x -= y) | \nYes | \n
Unsigned right shift assignment (x >>>= y) | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators\n
JavaScript has both strict and type–converting comparisons. A strict comparison (e.g., ===) is only true if the operands are of the same type and the contents match. The more commonly-used abstract comparison (e.g. ==) converts the operands to the same type before making the comparison. For relational abstract comparisons (e.g., <=), the operands are first converted to primitives, then to the same type, before comparison.
Strings are compared based on standard lexicographical ordering, using Unicode values.
Features of comparisons:
true or both are false.The equality operator converts the operands if they are not of the same type, then applies strict comparison. If both operands are objects, then JavaScript compares internal references which are equal when operands refer to the same object in memory.
x == y\n
1 == 1 // true\n'1' == 1 // true\n1 == '1' // true\n0 == false // true\n0 == null // false\nvar object1 = {'key': 'value'}, object2 = {'key': 'value'}; \nobject1 == object2 //false\n0 == undefined // false\nnull == undefined // true\n The inequality operator returns true if the operands are not equal. If the two operands are not of the same type, JavaScript attempts to convert the operands to an appropriate type for the comparison. If both operands are objects, then JavaScript compares internal references which are not equal when operands refer to different objects in memory.
x != y
1 != 2 // true\n1 != '1' // false\n1 != \"1\" // false\n1 != true // false\n0 != false // false\n
The identity operator returns true if the operands are strictly equal (see above) with no type conversion.
x === y
3 === 3 // true\n3 === '3' // false\nvar object1 = {'key': 'value'}, object2 = {'key': 'value'};\nobject1 === object2 //false The non-identity operator returns true if the operands are not equal and/or not of the same type.
x !== y
3 !== '3' // true\n4 !== 3 // true\n
Each of these operators will call the valueOf() function on each operand before a comparison is made.
The greater than operator returns true if the left operand is greater than the right operand.
x > y
4 > 3 // true\n
The greater than or equal operator returns true if the left operand is greater than or equal to the right operand.
x >= y
4 >= 3 // true\n3 >= 3 // true\n
The less than operator returns true if the left operand is less than the right operand.
x < y
3 < 4 // true\n
The less than or equal operator returns true if the left operand is less than or equal to the right operand.
x <= y
3 <= 4 // true\n
The standard equality operators (== and !=) use the Abstract Equality Comparison Algorithm to compare two operands. If the operands are of different types, it will attempt to convert them to the same type before making the comparison, e.g., in the expression 5 == '5', the string on the right is converted to Number before the comparison is made.
The strict equality operators (=== and !==) use the Strict Equality Comparison Algorithm and are intended for performing equality comparisons on operands of the same type. If the operands are of different types, the result is always false so 5 !== '5'.
Use strict equality operators if the operands must be of a specific type as well as value or if the exact type of the operands is important. Otherwise, use the standard equality operators, which allow you to compare the identity of two operands even if they are not of the same type.
When type conversion is involved in the comparison (i.e., non–strict comparison), JavaScript converts the types String, Number, Boolean, or Object operands as follows:
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, the Boolean operand is converted to 1 if it is true and +0 if it is false.String or Number value, using the valueOf and toString methods of the objects. If this attempt to convert the object fails, a runtime error is generated.// true as both operands are type String (i.e. string primitives):\n'foo' === 'foo'\n\nvar a = new String('foo');\nvar b = new String('foo');\n\n// false as a and b are type Object and reference different objects\na == b \n\n// false as a and b are type Object and reference different objects\na === b \n\n// true as a and 'foo' are of different type and, the Object (a) \n// is converted to String 'foo' before comparison\na == 'foo' | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0 |
| ECMAScript 3rd Edition (ECMA-262) | Standard | Adds === and !== operators. Implemented in JavaScript 1.3 |
| ECMAScript 5.1 (ECMA-262) | Standard | Defined in several sections of the specification: Relational Operators, Equality Operators\n |
| ECMAScript 2015 (6th Edition, ECMA-262) | Standard | Defined in several sections of the specification: Relational Operators, Equality Operators\n |
| ECMAScript Latest Draft (ECMA-262) | Draft | Defined in several sections of the specification: Relational Operators, Equality Operators\n |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
Equality (a == b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Inequality (a != b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Identity (a === b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Non-identity (a !== b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Greater than (a > b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Greater than or equal (a >= b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Less than (a < b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Less than or equal (a <= b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
Equality (a == b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Inequality (a != b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Identity (a === b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Non-identity (a !== b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Greater than (a > b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Greater than or equal (a >= b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Less than (a < b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Less than or equal (a <= b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
Equality (a == b) | \nYes | \n
Inequality (a != b) | \nYes | \n
Identity (a === b) | \nYes | \n
Non-identity (a !== b) | \nYes | \n
Greater than (a > b) | \nYes | \n
Greater than or equal (a >= b) | \nYes | \n
Less than (a < b) | \nYes | \n
Less than or equal (a <= b) | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators\n
This is an experimental technology
Check the Browser compatibility table carefully before using this in production.
The experimental pipeline operator |> (currently at stage 1) allows the creation of chained function calls in a readable manner. Basically, the pipeline operator provides syntactic sugar on a function call with a single argument allowing you to write
'%21' |> decodeURI instead of decodeURI('%21').
expression |> function
The pipeline operator can improve readability when chaining several functions.
const double = (n) => n * 2;\nconst increment = (n) => n + 1;\n\n// without pipeline operator\ndouble(increment(double(double(5)))); // 42\n\n// with pipeline operator\n5 |> double |> double |> increment |> double; // 42\n
| Specification | Status | Comment |
|---|---|---|
| Pipeline operator draft | Stage 1 | Not part of the ECMAScript specification yet. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nNo | \nNo | \n 58\n
| \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nNo | \nNo | \nNo | \n 58\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Pipeline_operator\n
The in returns true if the specified property is in the specified object or its prototype chain.
prop in object
propobjectThe following examples show some uses of the in operator.
// Arrays\nvar trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];\n0 in trees // returns true\n3 in trees // returns true\n6 in trees // returns false\n'bay' in trees // returns false (you must specify the index number, not the value at that index)\n'length' in trees // returns true (length is an Array property)\nSymbol.iterator in trees // returns true (arrays are iterable, works only in ES2015+)\n\n// Predefined objects\n'PI' in Math // returns true\n\n// Custom objects\nvar mycar = {make: 'Honda', model: 'Accord', year: 1998};\n'make' in mycar // returns true\n'model' in mycar // returns true\n You must specify an object on the right side of the in operator. For example, you can specify a string created with the String constructor, but you cannot specify a string literal.
var color1 = new String('green');\n'length' in color1 // returns true\n\nvar color2 = 'coral';\n// generates an error (color2 is not a String object)\n'length' in color2\n in with deleted or undefined propertiesIf you delete a property with the delete operator, the in operator returns false for that property.
var mycar = {make: 'Honda', model: 'Accord', year: 1998};\ndelete mycar.make;\n'make' in mycar; // returns false\n\nvar trees = new Array('redwood', 'bay', 'cedar', 'oak', 'maple');\ndelete trees[3];\n3 in trees; // returns false\n If you set a property to undefined but do not delete it, the in operator returns true for that property.
var mycar = {make: 'Honda', model: 'Accord', year: 1998};\nmycar.make = undefined;\n'make' in mycar; // returns true\n var trees = new Array('redwood', 'bay', 'cedar', 'oak', 'maple');\ntrees[3] = undefined;\n3 in trees; // returns true\n The in operator returns true for properties in the prototype chain.
'toString' in {}; // returns true\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Relational Operators' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Relational Operators' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'The in Operator' in that specification. | Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'The in Operator' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.4. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
for...indeleteObject.prototype.hasOwnProperty()Reflect.has()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/in\n
Bitwise operators treat their operands as a sequence of 32 bits (zeroes and ones), rather than as decimal, hexadecimal, or octal numbers. For example, the decimal number nine has a binary representation of 1001. Bitwise operators perform their operations on such binary representations, but they return standard JavaScript numerical values.
The following table summarizes JavaScript's bitwise operators:
| Operator | Usage | Description |
|---|---|---|
| Bitwise AND | a & b | Returns a 1 in each bit position for which the corresponding bits of both operands are 1s. |
| Bitwise OR | a | b | Returns a 1 in each bit position for which the corresponding bits of either or both operands are 1s. |
| Bitwise XOR | a ^ b | Returns a 1 in each bit position for which the corresponding bits of either but not both operands are 1s. |
| Bitwise NOT | ~ a | Inverts the bits of its operand. |
| Left shift | a << b | Shifts a in binary representation b (< 32) bits to the left, shifting in 0s from the right. |
| Sign-propagating right shift | a >> b | Shifts a in binary representation b (< 32) bits to the right, discarding bits shifted off. |
| Zero-fill right shift | a >>> b | Shifts a in binary representation b (< 32) bits to the right, discarding bits shifted off, and shifting in 0s from the left. |
The operands of all bitwise operators are converted to signed 32-bit integers in two's complement format. Two's complement format means that a number's negative counterpart (e.g. 5 vs. -5) is all the number's bits inverted (bitwise NOT of the number, a.k.a. ones' complement of the number) plus one. For example, the following encodes the integer 314:
00000000000000000000000100111010\n
The following encodes ~314, i.e. the ones' complement of 314:
11111111111111111111111011000101\n
Finally, the following encodes -314, i.e. the two's complement of 314:
11111111111111111111111011000110\n
The two's complement guarantees that the left-most bit is 0 when the number is positive and 1 when the number is negative. Thus, it is called the sign bit.
The number 0 is the integer that is composed completely of 0 bits.
0 (base 10) = 00000000000000000000000000000000 (base 2)\n
The number -1 is the integer that is composed completely of 1 bits.
-1 (base 10) = 11111111111111111111111111111111 (base 2)\n
The number -2147483648 (hexadecimal representation: -0x80000000) is the integer that is composed completely of 0 bits except the first (left-most) one.
-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)\n
The number 2147483647 (hexadecimal representation: 0x7fffffff) is the integer that is composed completely of 1 bits except the first (left-most) one.
2147483647 (base 10) = 01111111111111111111111111111111 (base 2)\n
The numbers -2147483648 and 2147483647 are the minimum and the maximum integers representable through a 32bit signed number.
Conceptually, the bitwise logical operators work as follows:
Before: 11100110111110100000000000000110000000000001\nAfter: 10100000000000000110000000000001
Performs the AND operation on each pair of bits. a AND b yields 1 only if both a and b are 1. The truth table for the AND operation is:
| a | b | a AND b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
. 9 (base 10) = 00000000000000000000000000001001 (base 2)\n 14 (base 10) = 00000000000000000000000000001110 (base 2)\n --------------------------------\n14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)\n
Bitwise ANDing any number x with 0 yields 0. Bitwise ANDing any number x with -1 yields x.
Performs the OR operation on each pair of bits. a OR b yields 1 if either a or b is 1. The truth table for the OR operation is:
| a | b | a OR b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
. 9 (base 10) = 00000000000000000000000000001001 (base 2)\n 14 (base 10) = 00000000000000000000000000001110 (base 2)\n --------------------------------\n14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)\n
Bitwise ORing any number x with 0 yields x. Bitwise ORing any number x with -1 yields -1.
Performs the XOR operation on each pair of bits. a XOR b yields 1 if a and b are different. The truth table for the XOR operation is:
| a | b | a XOR b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
. 9 (base 10) = 00000000000000000000000000001001 (base 2)\n 14 (base 10) = 00000000000000000000000000001110 (base 2)\n --------------------------------\n14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)\n
Bitwise XORing any number x with 0 yields x. Bitwise XORing any number x with -1 yields ~x.
Performs the NOT operator on each bit. NOT a yields the inverted value (a.k.a. one's complement) of a. The truth table for the NOT operation is:
| a | NOT a |
|---|---|
| 0 | 1 |
| 1 | 0 |
9 (base 10) = 00000000000000000000000000001001 (base 2)\n --------------------------------\n~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)\n
Bitwise NOTing any number x yields -(x + 1). For example, ~-5 yields 4.
Note that due to using 32-bit representation for numbers both ~-1 and ~4294967295 (232-1) results in 0.
The bitwise shift operators take two operands: the first is a quantity to be shifted, and the second specifies the number of bit positions by which the first operand is to be shifted. The direction of the shift operation is controlled by the operator used.
Shift operators convert their operands to 32-bit integers in big-endian order and return a result of the same type as the left operand. The right operand should be less than 32, but if not only the low five bits will be used.
This operator shifts the first operand the specified number of bits to the left. Excess bits shifted off to the left are discarded. Zero bits are shifted in from the right.
For example, 9 << 2 yields 36:
. 9 (base 10): 00000000000000000000000000001001 (base 2)\n --------------------------------\n9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)\n
Bitwise shifting any number x to the left by y bits yields x * 2 ** y.
This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Copies of the leftmost bit are shifted in from the left. Since the new leftmost bit has the same value as the previous leftmost bit, the sign bit (the leftmost bit) does not change. Hence the name \"sign-propagating\".
For example, 9 >> 2 yields 2:
. 9 (base 10): 00000000000000000000000000001001 (base 2)\n --------------------------------\n9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)\n
Likewise, -9 >> 2 yields -3, because the sign is preserved:
. -9 (base 10): 11111111111111111111111111110111 (base 2)\n --------------------------------\n-9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)\n
This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Zero bits are shifted in from the left. The sign bit becomes 0, so the result is always non-negative.
For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result. For example, 9 >>> 2 yields 2, the same as 9 >> 2:
. 9 (base 10): 00000000000000000000000000001001 (base 2)\n --------------------------------\n9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)\n
However, this is not the case for negative numbers. For example, -9 >>> 2 yields 1073741821, which is different than -9 >> 2 (which yields -3):
. -9 (base 10): 11111111111111111111111111110111 (base 2)\n --------------------------------\n-9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)\n
The bitwise logical operators are often used to create, manipulate, and read sequences of flags, which are like binary variables. Variables could be used instead of these sequences, but binary flags take much less memory (by a factor of 32).
Suppose there are 4 flags:
These flags are represented by a sequence of bits: DCBA. When a flag is set, it has a value of 1. When a flag is cleared, it has a value of 0. Suppose a variable flags has the binary value 0101:
var flags = 5; // binary 0101\n
This value indicates:
Since bitwise operators are 32-bit, 0101 is actually 00000000000000000000000000000101, but the preceding zeroes can be neglected since they contain no meaningful information.
A bitmask is a sequence of bits that can manipulate and/or read flags. Typically, a \"primitive\" bitmask for each flag is defined:
var FLAG_A = 1; // 0001\nvar FLAG_B = 2; // 0010\nvar FLAG_C = 4; // 0100\nvar FLAG_D = 8; // 1000\n
New bitmasks can be created by using the bitwise logical operators on these primitive bitmasks. For example, the bitmask 1011 can be created by ORing FLAG_A, FLAG_B, and FLAG_D:
var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011\n
Individual flag values can be extracted by ANDing them with a bitmask, where each bit with the value of one will \"extract\" the corresponding flag. The bitmask masks out the non-relevant flags by ANDing with zeroes (hence the term \"bitmask\"). For example, the bitmask 0100 can be used to see if flag C is set:
// if we own a cat\nif (flags & FLAG_C) { // 0101 & 0100 => 0100 => true\n // do stuff\n}\n A bitmask with multiple set flags acts like an \"either/or\". For example, the following two are equivalent:
// if we own a bat or we own a cat\n// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true\nif ((flags & FLAG_B) || (flags & FLAG_C)) {\n // do stuff\n}\n // if we own a bat or cat\nvar mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110\nif (flags & mask) { // 0101 & 0110 => 0100 => true\n // do stuff\n}\n Flags can be set by ORing them with a bitmask, where each bit with the value one will set the corresponding flag, if that flag isn't already set. For example, the bitmask 1100 can be used to set flags C and D:
// yes, we own a cat and a duck\nvar mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100\nflags |= mask; // 0101 | 1100 => 1101\n
Flags can be cleared by ANDing them with a bitmask, where each bit with the value zero will clear the corresponding flag, if it isn't already cleared. This bitmask can be created by NOTing primitive bitmasks. For example, the bitmask 1010 can be used to clear flags A and C:
// no, we don't have an ant problem or own a cat\nvar mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010\nflags &= mask; // 1101 & 1010 => 1000\n
The mask could also have been created with ~FLAG_A & ~FLAG_C (De Morgan's law):
// no, we don't have an ant problem, and we don't own a cat\nvar mask = ~FLAG_A & ~FLAG_C;\nflags &= mask; // 1101 & 1010 => 1000\n
Flags can be toggled by XORing them with a bitmask, where each bit with the value one will toggle the corresponding flag. For example, the bitmask 0110 can be used to toggle flags B and C:
// if we didn't have a bat, we have one now, \n// and if we did have one, bye-bye bat\n// same thing for cats\nvar mask = FLAG_B | FLAG_C;\nflags = flags ^ mask; // 1100 ^ 0110 => 1010\n
Finally, the flags can all be flipped with the NOT operator:
// entering parallel universe...\nflags = ~flags; // ~1010 => 0101\n
Convert a binary String to a decimal Number:
var sBinString = '1011';\nvar nMyNumber = parseInt(sBinString, 2);\nalert(nMyNumber); // prints 11, i.e. 1011\n
Convert a decimal Number to a binary String:
var nMyNumber = 11;\nvar sBinString = nMyNumber.toString(2);\nalert(sBinString); // prints 1011, i.e. 11\n
You can create multiple masks from a set of Boolean values, like this:
function createMask() {\n var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;\n for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);\n return nMask;\n}\nvar mask1 = createMask(true, true, false, true); // 11, i.e.: 1011\nvar mask2 = createMask(false, false, true); // 4, i.e.: 0100\nvar mask3 = createMask(true); // 1, i.e.: 0001\n// etc.\n\nalert(mask1); // prints 11, i.e.: 1011\n If you want to create an Array of Booleans from a mask you can use this code:
function arrayFromMask(nMask) {\n // nMask must be between -2147483648 and 2147483647\n if (nMask > 0x7fffffff || nMask < -0x80000000) { \n throw new TypeError('arrayFromMask - out of range'); \n }\n for (var nShifted = nMask, aFromMask = []; nShifted; \n aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1);\n return aFromMask;\n}\n\nvar array1 = arrayFromMask(11);\nvar array2 = arrayFromMask(4);\nvar array3 = arrayFromMask(1);\n\nalert('[' + array1.join(', ') + ']');\n// prints \"[true, true, false, true]\", i.e.: 11, i.e.: 1011\n You can test both algorithms at the same time…
var nTest = 19; // our custom mask\nvar nResult = createMask.apply(this, arrayFromMask(nTest));\n\nalert(nResult); // 19\n
For didactic purpose only (since there is the Number.toString(2) method), we show how it is possible to modify the arrayFromMask algorithm in order to create a String containing the binary representation of a Number, rather than an Array of Booleans:
function createBinaryString(nMask) {\n // nMask must be between -2147483648 and 2147483647\n for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32;\n nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);\n return sMask;\n}\n\nvar string1 = createBinaryString(11);\nvar string2 = createBinaryString(4);\nvar string3 = createBinaryString(1);\n\nalert(string1);\n// prints 00000000000000000000000000001011, i.e. 11\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) | Standard | Defined in several sections of the specification: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators\n |
| ECMAScript 2015 (6th Edition, ECMA-262) | Standard | Defined in several sections of the specification: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators\n |
| ECMAScript Latest Draft (ECMA-262) | Draft | Defined in several sections of the specification: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators\n |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
Bitwise AND (a & b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Bitwise left shift (a << b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Bitwise NOT (~a) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Bitwise OR (a | b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Bitwise right shift (a >> b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Bitwise unsigned right shift (a >>> b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Bitwise XOR (a ^ b) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
Bitwise AND (a & b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Bitwise left shift (a << b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Bitwise NOT (~a) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Bitwise OR (a | b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Bitwise right shift (a >> b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Bitwise unsigned right shift (a >>> b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Bitwise XOR (a ^ b) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
Bitwise AND (a & b) | \nYes | \n
Bitwise left shift (a << b) | \nYes | \n
Bitwise NOT (~a) | \nYes | \n
Bitwise OR (a | b) | \nYes | \n
Bitwise right shift (a >> b) | \nYes | \n
Bitwise unsigned right shift (a >>> b) | \nYes | \n
Bitwise XOR (a ^ b) | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators\n
The destructuring assignment syntax is a JavaScript expression that makes it possible to unpack values from arrays, or properties from objects, into distinct variables.
var a, b, rest;\n[a, b] = [10, 20];\nconsole.log(a); // 10\nconsole.log(b); // 20\n\n[a, b, ...rest] = [10, 20, 30, 40, 50];\nconsole.log(a); // 10\nconsole.log(b); // 20\nconsole.log(rest); // [30, 40, 50]\n\n({ a, b } = { a: 10, b: 20 });\nconsole.log(a); // 10\nconsole.log(b); // 20\n\n\n// Stage 4(finished) proposal\n({a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40});\nconsole.log(a); // 10\nconsole.log(b); // 20\nconsole.log(rest); // {c: 30, d: 40}\n The object and array literal expressions provide an easy way to create ad hoc packages of data.
var x = [1, 2, 3, 4, 5];
The destructuring assignment uses similar syntax, but on the left-hand side of the assignment to define what values to unpack from the sourced variable.
var x = [1, 2, 3, 4, 5];\nvar [y, z] = x;\nconsole.log(y); // 1\nconsole.log(z); // 2\n
This capability is similar to features present in languages such as Perl and Python.
var foo = ['one', 'two', 'three'];\n\nvar [one, two, three] = foo;\nconsole.log(one); // \"one\"\nconsole.log(two); // \"two\"\nconsole.log(three); // \"three\"\n
A variable can be assigned its value via destructuring separate from the variable's declaration.
var a, b;\n\n[a, b] = [1, 2];\nconsole.log(a); // 1\nconsole.log(b); // 2\n
A variable can be assigned a default, in the case that the value unpacked from the array is undefined.
var a, b;\n\n[a=5, b=7] = [1];\nconsole.log(a); // 1\nconsole.log(b); // 7\n
Two variables values can be swapped in one destructuring expression.
Without destructuring assignment, swapping two values requires a temporary variable (or, in some low-level languages, the XOR-swap trick).
var a = 1;\nvar b = 3;\n\n[a, b] = [b, a];\nconsole.log(a); // 3\nconsole.log(b); // 1\n
It's always been possible to return an array from a function. Destructuring can make working with an array return value more concise.
In this example, f() returns the values [1, 2] as its output, which can be parsed in a single line with destructuring.
function f() {\n return [1, 2];\n}\n\nvar a, b; \n[a, b] = f(); \nconsole.log(a); // 1\nconsole.log(b); // 2\n You can ignore return values that you're not interested in:
function f() {\n return [1, 2, 3];\n}\n\nvar [a, , b] = f();\nconsole.log(a); // 1\nconsole.log(b); // 3\n You can also ignore all returned values:
[,,] = f();\n
When destructuring an array, you can unpack and assign the remaining part of it to a variable using the rest pattern:
var [a, ...b] = [1, 2, 3];\nconsole.log(a); // 1\nconsole.log(b); // [2, 3]
Be aware that a SyntaxError will be thrown if a trailing comma is used on the left-hand side with a rest element:
var [a, ...b,] = [1, 2, 3];\n// SyntaxError: rest element may not have a trailing comma
When the regular expression exec() method finds a match, it returns an array containing first the entire matched portion of the string and then the portions of the string that matched each parenthesized group in the regular expression. Destructuring assignment allows you to unpack the parts out of this array easily, ignoring the full match if it is not needed.
function parseProtocol(url) { \n var parsedURL = /^(\\w+)\\:\\/\\/([^\\/]+)\\/(.*)$/.exec(url);\n if (!parsedURL) {\n return false;\n }\n console.log(parsedURL); // [\"https://developer.mozilla.org/en-US/Web/JavaScript\", \"https\", \"developer.mozilla.org\", \"en-US/Web/JavaScript\"]\n\n var [, protocol, fullhost, fullpath] = parsedURL;\n return protocol;\n}\n\nconsole.log(parseProtocol('https://developer.mozilla.org/en-US/Web/JavaScript')); // \"https\"\n var o = {p: 42, q: true};\nvar {p, q} = o;\n\nconsole.log(p); // 42\nconsole.log(q); // true \n A variable can be assigned its value with destructuring separate from its declaration.
var a, b;\n\n({a, b} = {a: 1, b: 2}); Notes: The parentheses ( ... ) around the assignment statement are required when using object literal destructuring assignment without a declaration.
{a, b} = {a: 1, b: 2} is not valid stand-alone syntax, as the {a, b} on the left-hand side is considered a block and not an object literal.
However, ({a, b} = {a: 1, b: 2}) is valid, as is var {a, b} = {a: 1, b: 2}
Your ( ... ) expression needs to be preceded by a semicolon or it may be used to execute a function on the previous line.
A property can be unpacked from an object and assigned to a variable with a different name than the object property.
var o = {p: 42, q: true};\nvar {p: foo, q: bar} = o;\n \nconsole.log(foo); // 42 \nconsole.log(bar); // true A variable can be assigned a default, in the case that the value unpacked from the object is undefined.
var {a = 10, b = 5} = {a: 3};\n\nconsole.log(a); // 3\nconsole.log(b); // 5 A property can be both 1) unpacked from an object and assigned to a variable with a different name and 2) assigned a default value in case the unpacked value is undefined.
var {a: aa = 10, b: bb = 5} = {a: 3};\n\nconsole.log(aa); // 3\nconsole.log(bb); // 5\n function drawES5Chart(options) {\n options = options === undefined ? {} : options;\n var size = options.size === undefined ? 'big' : options.size;\n var cords = options.cords === undefined ? {x: 0, y: 0} : options.cords;\n var radius = options.radius === undefined ? 25 : options.radius;\n console.log(size, cords, radius);\n // now finally do some chart drawing\n}\n\ndrawES5Chart({\n cords: {x: 18, y: 30},\n radius: 30\n}); function drawES2015Chart({size = 'big', cords = {x: 0, y: 0}, radius = 25} = {}) {\n console.log(size, cords, radius);\n // do some chart drawing\n}\n\ndrawES2015Chart({\n cords: {x: 18, y: 30},\n radius: 30\n}); In the function signature for drawES2015Chart above, the destructured left-hand side is assigned to an empty object literal on the right-hand side: {size = 'big', cords = {x: 0, y: 0}, radius = 25} = {}. You could have also written the function without the right-hand side assignment. However, if you leave out the right-hand side assignment, the function will look for at least one argument to be supplied when invoked, whereas in its current form, you can simply call drawES2015Chart() without supplying any parameters. The current design is useful if you want to be able to call the function without supplying any parameters, the other can be useful when you want to ensure an object is passed to the function.
const metadata = {\n title: 'Scratchpad',\n translations: [\n {\n locale: 'de',\n localization_tags: [],\n last_edit: '2014-04-14T08:43:37',\n url: '/de/docs/Tools/Scratchpad',\n title: 'JavaScript-Umgebung'\n }\n ],\n url: '/en-US/docs/Tools/Scratchpad'\n};\n\nlet {\n title: englishTitle,// rename\n translations: [\n {\n title: localeTitle,// rename\n },\n ],\n} = metadata;\n\nconsole.log(englishTitle); // \"Scratchpad\"\nconsole.log(localeTitle); // \"JavaScript-Umgebung\" var people = [\n {\n name: 'Mike Smith',\n family: {\n mother: 'Jane Smith',\n father: 'Harry Smith',\n sister: 'Samantha Smith'\n },\n age: 35\n },\n {\n name: 'Tom Jones',\n family: {\n mother: 'Norah Jones',\n father: 'Richard Jones',\n brother: 'Howard Jones'\n },\n age: 25\n }\n];\n\nfor (var {name: n, family: {father: f}} of people) {\n console.log('Name: ' + n + ', Father: ' + f);\n}\n\n// \"Name: Mike Smith, Father: Harry Smith\"\n// \"Name: Tom Jones, Father: Richard Jones\" function userId({id}) {\n return id;\n}\n\nfunction whois({displayName, fullName: {firstName: name}}) {\n console.log(displayName + ' is ' + name);\n}\n\nvar user = { \n id: 42, \n displayName: 'jdoe',\n fullName: { \n firstName: 'John',\n lastName: 'Doe'\n }\n};\n\nconsole.log('userId: ' + userId(user)); // \"userId: 42\"\nwhois(user); // \"jdoe is John\" This unpacks the id, displayName and firstName from the user object and prints them.
Computed property names, like on object literals, can be used with destructuring.
let key = 'z';\nlet {[key]: foo} = {z: 'bar'};\n\nconsole.log(foo); // \"bar\"\n The Rest/Spread Properties for ECMAScript proposal (stage 3) adds the rest syntax to destructuring. Rest properties collect the remaining own enumerable property keys that are not already picked off by the destructuring pattern.
let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40}\na; // 10 \nb; // 20 \nrest; // { c: 30, d: 40 } Destructuring can be used with property names that are not valid JavaScript identifiers by providing an alternative identifer that is valid.
const foo = { 'fizz-buzz': true };\nconst { 'fizz-buzz': fizzBuzz } = foo;\n\nconsole.log(fizzBuzz); // \"true\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Destructuring assignment' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Destructuring assignment' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n14 | \n 41\n
| \nNo | \nYes | \n8 | \n
| Computed property names | \n49 | \n14 | \n34 | \nNo | \nYes | \nNo | \n
| Rest in arrays | \n49 | \n 14\n
| \n34 | \nNo | \nYes | \nNo | \n
| Rest in objects \n | \n60 | \nNo | \n55 | \nNo | \nYes | \n11.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \n14 | \n 41\n
| \nYes | \n8 | \n5.0 | \n
| Computed property names | \n49 | \n49 | \n14 | \n34 | \nYes | \nNo | \n5.0 | \n
| Rest in arrays | \n49 | \n49 | \n 14\n
| \n34 | \nYes | \nNo | \n5.0 | \n
| Rest in objects \n | \n60 | \n60 | \nNo | \n55 | \nYes | \n11.1 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
| Computed property names | \nYes | \n
| Rest in arrays | \n6.0.0 | \n
| Rest in objects \n | \n8.3.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment\n
The async function keyword can be used to define async functions inside expressions.
You can also define async functions using an async function statement.
async function [name]([param1[, param2[, ..., paramN]]]) {\n statements\n} As of ES2015, you can also use arrow functions.
nameparamNstatementsAn async function expression is very similar to, and has almost the same syntax as, an async function statement. The main difference between an async function expression and an async function statement is the function name, which can be omitted in async function expressions to create anonymous functions. An async function expression can be used as an IIFE (Immediately Invoked Function Expression) which runs as soon as it is defined. See also the chapter about functions for more information.
function resolveAfter2Seconds(x) {\n return new Promise(resolve => {\n setTimeout(() => {\n resolve(x);\n }, 2000);\n });\n};\n\n\nvar add = async function(x) { // async function expression assigned to a variable\n var a = await resolveAfter2Seconds(20);\n var b = await resolveAfter2Seconds(30);\n return x + a + b;\n};\n\nadd(10).then(v => {\n console.log(v); // prints 60 after 4 seconds.\n});\n\n\n(async function(x) { // async function expression used as an IIFE\n var p_a = resolveAfter2Seconds(20);\n var p_b = resolveAfter2Seconds(30);\n return x + await p_a + await p_b;\n})(10).then(v => {\n console.log(v); // prints 60 after 2 seconds.\n});\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'async function' in that specification. | Draft | |
| ECMAScript 2018 (ECMA-262) The definition of 'async function' in that specification. | Standard | |
| ECMAScript 2017 (ECMA-262) The definition of 'async function' in that specification. | Standard | Initial definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n55 | \n? | \n52 | \nNo | \n42 | \n10.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n55 | \n55 | \n? | \n52 | \n42 | \n10.1 | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 7.6.0\n
| \n
async functionAsyncFunction objectawait\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/async_function\n
The function keyword can be used to define a function inside an expression.
You can also define functions using the Function constructor and a function declaration.
var myFunction = function [name]([param1[, param2[, ..., paramN]]]) {\n statements\n}; As of ES2015, you can also use arrow functions.
nameparamNstatementsA function expression is very similar to and has almost the same syntax as a function statement (see function statement for details). The main difference between a function expression and a function statement is the function name, which can be omitted in function expressions to create anonymous functions. A function expression can be used as a IIFE (Immediately Invoked Function Expression) which runs as soon as it is defined. See also the chapter about functions for more information.
Function expressions in JavaScript are not hoisted, unlike function declarations. You can't use function expressions before you define them:
console.log(notHoisted) // undefined \n//even though the variable name is hoisted, the definition isn't. so it's undefined.\nnotHoisted(); // TypeError: notHoisted is not a function\n\nvar notHoisted = function() {\n console.log('bar');\n};\n If you want to refer to the current function inside the function body, you need to create a named function expression. This name is then local only to the function body (scope). This also avoids using the non-standard arguments.callee property.
var math = {\n 'factit': function factorial(n) {\n console.log(n)\n if (n <= 1) {\n return 1;\n }\n return n * factorial(n - 1);\n }\n};\n\nmath.factit(3) //3;2;1;\n The variable the function expression is assigned to will have a name property. The name doesn't change if it's assigned to a different variable. If function name is omitted, it will be the variable name (implicit name). If function name is present, it will be the function name (explicit name). This also applies to arrow functions (arrows don't have a name so you can only give the variable an implicit name).
var foo = function() {}\nfoo.name // \"foo\"\n\nvar foo2 = foo\nfoo2.name // \"foo\"\n\nvar bar = function baz() {}\nbar.name // \"baz\"\n\nconsole.log(foo === foo2); // true\nconsole.log(typeof baz); // undefined\nconsole.log(bar === baz); // false (errors because baz == undefined)\n The following example defines an unnamed function and assigns it to x. The function returns the square of its argument:
var x = function(y) {\n return y * y;\n};\n More commonly it is used as a callback:
button.addEventListener('click', function(event) {\n console.log('button is clicked!')\n}) | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function definitions' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function definitions' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'Function definition' in that specification. | Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'Function definition' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.5. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Trailing comma in parameters | \n58 | \nNo | \n52 | \nNo | \n45 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Trailing comma in parameters | \n58 | \n58 | \nNo | \n52 | \n45 | \nNo | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Trailing comma in parameters | \n8.0.0 | \n
Arrow functionsFunctions and function scopeFunctionfunction statementfunction* statementfunction* expressionGeneratorFunctionasync functionasync function expression\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function\n
The instanceof tests whether the prototype property of a constructor appears anywhere in the prototype chain of an object.
object instanceof constructor
objectconstructorThe instanceof operator tests the presence of constructor.prototype in object's prototype chain.
// defining constructors\nfunction C() {}\nfunction D() {}\n\nvar o = new C();\n\n// true, because: Object.getPrototypeOf(o) === C.prototype\no instanceof C;\n\n// false, because D.prototype is nowhere in o's prototype chain\no instanceof D;\n\no instanceof Object; // true, because:\nC.prototype instanceof Object // true\n\nC.prototype = {};\nvar o2 = new C();\n\no2 instanceof C; // true\n\n// false, because C.prototype is nowhere in\n// o's prototype chain anymore\no instanceof C; \n\nD.prototype = new C(); // add C to [[Prototype]] linkage of D\nvar o3 = new D();\no3 instanceof D; // true\no3 instanceof C; // true since C.prototype is now in o3's prototype chain\n Note that the value of an instanceof test can change based on changes to the prototype property of constructors, and it can also be changed by changing an object prototype using Object.setPrototypeOf. It is also possible using the non-standard __proto__ pseudo-property.
instanceof and multiple context (e.g. frames or windows)Different scopes have different execution environments. This means that they have different built-ins (different global object, different constructors, etc.). This may result in unexpected results. For instance, [] instanceof window.frames[0].Array will return false, because Array.prototype !== window.frames[0].Array and arrays inherit from the former.
This may not make sense at first but when you start dealing with multiple frames or windows in your script and pass objects from one context to another via functions, this will be a valid and strong issue. For instance, you can securely check if a given object is, in fact, an Array using Array.isArray(myObj)
For example checking if a Nodes is a SVGElement in a different context you can use myNode instanceof myNode.ownerDocument.defaultView.SVGElement
instanceof has special effect: obj instanceof xpcomInterface (e.g. Components.interfaces.nsIFile) calls obj.QueryInterface(xpcomInterface) and returns true if QueryInterface succeeded. A side effect of such call is that you can use xpcomInterface's properties on obj after a successful instanceof test. Unlike standard JavaScript globals, the test obj instanceof xpcomInterface works as expected even if obj is from a different scope.String and Date are of type Object and exceptional casesThe following code uses instanceof to demonstrate that String and Date objects are also of type Object (they are derived from Object).
However, objects created with the object literal notation are an exception here: Although the prototype is undefined, instanceof Object returns true.
var simpleStr = 'This is a simple string'; \nvar myString = new String();\nvar newStr = new String('String created with constructor');\nvar myDate = new Date();\nvar myObj = {};\nvar myNonObj = Object.create(null);\n\nsimpleStr instanceof String; // returns false, checks the prototype chain, finds undefined\nmyString instanceof String; // returns true\nnewStr instanceof String; // returns true\nmyString instanceof Object; // returns true\n\nmyObj instanceof Object; // returns true, despite an undefined prototype\n({}) instanceof Object; // returns true, same case as above\nmyNonObj instanceof Object; // returns false, a way to create an object that is not an instance of Object\n\nmyString instanceof Date; // returns false\n\nmyDate instanceof Date; // returns true\nmyDate instanceof Object; // returns true\nmyDate instanceof String; // returns false\n mycar is of type Car and type Object\nThe following code creates an object type Car and an instance of that object type, mycar. The instanceof operator demonstrates that the mycar object is of type Car and of type Object.
function Car(make, model, year) {\n this.make = make;\n this.model = model;\n this.year = year;\n}\nvar mycar = new Car('Honda', 'Accord', 1998);\nvar a = mycar instanceof Car; // returns true\nvar b = mycar instanceof Object; // returns true\n To test if an object is not an instanceof a specific Constructor, you can do
if (!(mycar instanceof Car)) {\n // Do something, like mycar = new Car(mycar)\n}\n This is really different from
if (!mycar instanceof Car)
that will always be false (!mycar will be treated before instanceof, so you always try to know if a boolean is an instance of Car).
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Relational Operators' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Relational Operators' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'The instanceof operator' in that specification. | Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'The instanceof operator' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.4. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof\n
Objects can be initialized using new Object(), Object.create(), or using the literal notation (initializer notation). An object initializer is a comma-delimited list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}).
var o = {};\nvar o = {a: 'foo', b: 42, c: {}};\n\nvar a = 'foo', b = 42, c = {};\nvar o = {a: a, b: b, c: c};\n\nvar o = {\n property: function (parameters) {},\n get property() {},\n set property(value) {}\n};\n Please see the compatibility table for support for these notations. In non-supporting environments, these notations will lead to syntax errors.
// Shorthand property names (ES2015)\nvar a = 'foo', b = 42, c = {};\nvar o = {a, b, c};\n\n// Shorthand method names (ES2015)\nvar o = {\n property(parameters) {}\n};\n\n// Computed property names (ES2015)\nvar prop = 'foo';\nvar o = {\n [prop]: 'hey',\n ['b' + 'ar']: 'there'\n}; An object initializer is an expression that describes the initialization of an Object. Objects consist of properties, which are used to describe an object. Values of object properties can either contain primitive data types or other objects.
An empty object with no properties can be created like this:
var object = {}; However, the advantage of the literal or initializer notation is, that you are able to quickly create objects with properties inside the curly braces. You simply notate a list of key: value pairs delimited by comma. The following code creates an object with three properties and the keys are \"foo\", \"age\" and \"baz\". The values of these keys are a string \"bar\", a number 42, and another object.
var object = {\n foo: 'bar',\n age: 42,\n baz: {myProp: 12}\n} Once you have created an object, you might want to read or change them. Object properties can be accessed by using the dot notation or the bracket notation. See property accessors for detailed information.
object.foo; // \"bar\"\nobject['age']; // 42\n\nobject.foo = 'baz';\n
We have already learned how to notate properties using the initializer syntax. Oftentimes, there are variables in your code that you would like to put into an object. You will see code like this:
var a = 'foo', \n b = 42,\n c = {};\n\nvar o = { \n a: a,\n b: b,\n c: c\n}; With ECMAScript 2015, there is a shorter notation available to achieve the same:
var a = 'foo', \n b = 42, \n c = {};\n\n// Shorthand property names (ES2015)\nvar o = {a, b, c};\n\n// In other words,\nconsole.log((o.a === {a}.a)); // true\n When using the same name for your properties, the second property will overwrite the first.
var a = {x: 1, x: 2};\nconsole.log(a); // {x: 2}\n In ECMAScript 5 strict mode code, duplicate property names were considered a SyntaxError. With the introduction of computed property names making duplication possible at runtime, ECMAScript 2015 has removed this restriction.
function haveES2015DuplicatePropertySemantics() {\n 'use strict';\n try {\n ({prop: 1, prop: 2});\n\n // No error thrown, duplicate property names allowed in strict mode\n return true;\n } catch(e) {\n // Error thrown, duplicates prohibited in strict mode\n return false;\n }\n} A property of an object can also refer to a function or a getter or setter method.
var o = {\n property: function (parameters) {},\n get property() {},\n set property(value) {}\n}; In ECMAScript 2015, a shorthand notation is available, so that the keyword \"function\" is no longer necessary.
// Shorthand method names (ES2015)\nvar o = {\n property(parameters) {},\n *generator() {}\n}; In ECMAScript 2015 There is a way to concisely define properties whose values are generator functions:
var o = {\n *generator() {\n ...........\n }\n}; Which is equivalent to this ES5-like notation (but note that ECMAScript 5 has no generators):
var o = {\n generator: function* () {\n ...........\n }\n}; For more information and examples about methods, see method definitions.
Starting with ECMAScript 2015, the object initializer syntax also supports computed property names. That allows you to put an expression in brackets [], that will be computed and used as the property name. This is reminiscent of the bracket notation of the property accessor syntax, which you might have used to read and set properties already. Now you can use a similar syntax in object literals, too:
// Computed property names (ES2015)\nvar i = 0;\nvar a = {\n ['foo' + ++i]: i,\n ['foo' + ++i]: i,\n ['foo' + ++i]: i\n};\n\nconsole.log(a.foo1); // 1\nconsole.log(a.foo2); // 2\nconsole.log(a.foo3); // 3\n\nvar param = 'size';\nvar config = {\n [param]: 12,\n ['mobile' + param.charAt(0).toUpperCase() + param.slice(1)]: 4\n};\n\nconsole.log(config); // {size: 12, mobileSize: 4} The Rest/Spread Properties for ECMAScript proposal (stage 4) adds spread properties to object literals. It copies own enumerable properties from a provided object onto a new object.
Shallow-cloning (excluding prototype) or merging objects is now possible using a shorter syntax than Object.assign().
var obj1 = { foo: 'bar', x: 42 };\nvar obj2 = { foo: 'baz', y: 13 };\n\nvar clonedObj = { ...obj1 };\n// Object { foo: \"bar\", x: 42 }\n\nvar mergedObj = { ...obj1, ...obj2 };\n// Object { foo: \"baz\", x: 42, y: 13 } Note that Object.assign() triggers setters whereas the spread operator doesn't.
A property definition of the form __proto__: value or \"__proto__\": value does not create a property with the name __proto__. Instead, if the provided value is an object or null, it changes the [[Prototype]] of the created object to that value. (If the value is not an object or null, the object is not changed.)
var obj1 = {};\nassert(Object.getPrototypeOf(obj1) === Object.prototype);\n\nvar obj2 = {__proto__: null};\nassert(Object.getPrototypeOf(obj2) === null);\n\nvar protoObj = {};\nvar obj3 = {'__proto__': protoObj};\nassert(Object.getPrototypeOf(obj3) === protoObj);\n\nvar obj4 = {__proto__: 'not an object or null'};\nassert(Object.getPrototypeOf(obj4) === Object.prototype);\nassert(!obj4.hasOwnProperty('__proto__'));\n Only a single prototype mutation is permitted in an object literal: multiple prototype mutations are a syntax error.
Property definitions that do not use \"colon\" notation are not prototype mutations: they are property definitions that behave identically to similar definitions using any other name.
var __proto__ = 'variable';\n\nvar obj1 = {__proto__};\nassert(Object.getPrototypeOf(obj1) === Object.prototype);\nassert(obj1.hasOwnProperty('__proto__'));\nassert(obj1.__proto__ === 'variable');\n\nvar obj2 = {__proto__() { return 'hello'; }};\nassert(obj2.__proto__() === 'hello');\n\nvar obj3 = {['__prot' + 'o__']: 17};\nassert(obj3.__proto__ === 17);\n The object literal notation is not the same as the JavaScript Object Notation (JSON). Although they look similar, there are differences between them:
\"property\": value syntax. The property name must be double-quoted, and the definition cannot be a shorthand.true, false, null, or another (JSON) object.Date will be a string after JSON.parse().JSON.parse() will reject computed property names and an error will be thrown.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Object Initializer' in that specification. | Standard | \ngetter and setter added. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object Initializer' in that specification. | Standard | Shorthand method/property names and computed property names added. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object Initializer' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n1 | \nYes | \n1 | \n
| Computed property names | \n47 | \nYes | \n34 | \nNo | \n34 | \n8 | \n
| Shorthand property names | \n47 | \nYes | \n33 | \nNo | \n34 | \n9 | \n
| Shorthand method names | \n47 | \nYes | \n34 | \nNo | \n34 | \n9 | \n
| Spread properties \n | \n60 | \nNo | \n55 | \nNo | \n? | \n11.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n1 | \n18 | \nYes | \n4 | \nYes | \n1 | \nYes | \n
| Computed property names | \n47 | \n47 | \nYes | \n34 | \n34 | \n8 | \n5.0 | \n
| Shorthand property names | \n47 | \n47 | \nYes | \n33 | \n34 | \n9 | \n5.0 | \n
| Shorthand method names | \n47 | \n47 | \nYes | \n34 | \n34 | \n9 | \n5.0 | \n
| Spread properties \n | \n60 | \n60 | \nNo | \n55 | \n? | \n11.1 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Computed property names | \nYes | \n
| Shorthand property names | \nYes | \n
| Shorthand method names | \nYes | \n
| Spread properties \n | \n8.3.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer\n
The await operator is used to wait for a Promise. It can only be used inside an async function.
[rv] = await expression;
expressionPromise or any value to wait for.rvReturns the fulfilled value of the promise, or the value itself if it's not a Promise.
The await expression causes async function execution to pause until a Promise is resolved, that is fulfilled or rejected, and to resume execution of the async function after fulfillment. When resumed, the value of the await expression is that of the fulfilled Promise.
If the Promise is rejected, the await expression throws the rejected value.
If the value of the expression following the await operator is not a Promise, it's converted to a resolved Promise.
If a Promise is passed to an await expression, it waits for the Promise to be fulfilled and returns the fulfilled value.
function resolveAfter2Seconds(x) { \n return new Promise(resolve => {\n setTimeout(() => {\n resolve(x);\n }, 2000);\n });\n}\n\nasync function f1() {\n var x = await resolveAfter2Seconds(10);\n console.log(x); // 10\n}\nf1();\n If the value is not a Promise, it converts the value to a resolved Promise, and waits for it.
async function f2() {\n var y = await 20;\n console.log(y); // 20\n}\nf2(); If the Promise is rejected, the rejected value is thrown.
async function f3() {\n try {\n var z = await Promise.reject(30);\n } catch(e) {\n console.log(e); // 30\n }\n}\nf3(); Handle rejected Promise without try block.
var response = await promisedFunction().catch((err) => { console.log(err); });\n// response will be undefined if the promise is rejected\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'async functions' in that specification. | Draft | |
| ECMAScript 2018 (ECMA-262) The definition of 'async functions' in that specification. | Standard | |
| ECMAScript 2017 (ECMA-262) The definition of 'async functions' in that specification. | Standard | Initial definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n55 | \nYes | \n52 | \n? | \n42 | \n10.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n55 | \n55 | \nYes | \n52 | \n42 | \n10.1 | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 7.6.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await\n
The super keyword is used to access and call functions on an object's parent.
The super.prop and super[expr] expressions are valid in any method definition in both classes and object literals.
super([arguments]); // calls the parent constructor.\nsuper.functionOnParent([arguments]);\n
When used in a constructor, the super keyword appears alone and must be used before the this keyword is used. The super keyword can also be used to call functions on a parent object.
super in classesThis code snippet is taken from the classes sample (live demo). Here super() is called to avoid duplicating the constructor parts' that are common between Rectangle and Square.
class Rectangle {\n constructor(height, width) {\n this.name = 'Rectangle';\n this.height = height;\n this.width = width;\n }\n sayName() {\n console.log('Hi, I am a ', this.name + '.');\n }\n get area() {\n return this.height * this.width;\n }\n set area(value) {\n this.height = this.width = Math.sqrt(value);\n }\n}\n\nclass Square extends Rectangle {\n constructor(length) {\n // Here, it calls the parent class' constructor with lengths\n // provided for the Rectangle's width and height\n super(length, length);\n\n this.height; // ReferenceError, super needs to be called first!\n \n // Note: In derived classes, super() must be called before you\n // can use 'this'. Leaving this out will cause a reference error.\n this.name = 'Square';\n }\n} You are also able to call super on static methods.
class Rectangle {\n constructor() {}\n static logNbSides() {\n return 'I have 4 sides';\n }\n}\n\nclass Square extends Rectangle {\n constructor() {}\n static logDescription() {\n return super.logNbSides() + ' which are all equal';\n }\n}\nSquare.logDescription(); // 'I have 4 sides which are all equal'\n You cannot use the delete operator and super.prop or super[expr] to delete a parent class' property, it will throw a ReferenceError.
class Base {\n constructor() {}\n foo() {}\n}\nclass Derived extends Base {\n constructor() {}\n delete() {\n delete super.foo; // this is bad\n }\n}\n\nnew Derived().delete(); // ReferenceError: invalid delete involving 'super'. super.prop cannot overwrite non-writable propertiesWhen defining non-writable properties with e.g. Object.defineProperty, super cannot overwrite the value of the property.
class X {\n constructor() {\n Object.defineProperty(this, 'prop', {\n configurable: true,\n writable: false, \n value: 1\n });\n }\n}\n\nclass Y extends X {\n constructor() {\n super();\n }\n foo() {\n super.prop = 2; // Cannot overwrite the value.\n }\n}\n\nvar y = new Y();\ny.foo(); // TypeError: \"prop\" is read-only\nconsole.log(y.prop); // 1\n super.prop in object literalsSuper can also be used in the object initializer / literal notation. In this example, two objects define a method. In the second object, super calls the first object's method. This works with the help of Object.setPrototypeOf() with which we are able to set the prototype of obj2 to obj1, so that super is able to find method1 on obj1.
var obj1 = {\n method1() {\n console.log('method 1');\n }\n}\n\nvar obj2 = {\n method2() {\n super.method1();\n }\n}\n\nObject.setPrototypeOf(obj2, obj1);\nobj2.method2(); // logs \"method 1\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'super' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'super' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n42 | \nYes | \n45 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n42 | \n42 | \nYes | \n45 | \nYes | \nYes | \n4.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/super\n
A TypedArray object describes an array-like view of an underlying binary data buffer. There is no global property named TypedArray, nor is there a directly visible TypedArray constructor. Instead, there are a number of different global properties, whose values are typed array constructors for specific element types, listed below. On the following pages you will find common properties and methods that can be used with any typed array containing elements of any type.
new TypedArray(); // new in ES2017\nnew TypedArray(length);\nnew TypedArray(typedArray);\nnew TypedArray(object);\nnew TypedArray(buffer [, byteOffset [, length]]);\n\nwhere TypedArray() is one of:\n\nInt8Array();\nUint8Array();\nUint8ClampedArray();\nInt16Array();\nUint16Array();\nInt32Array();\nUint32Array();\nFloat32Array();\nFloat64Array();\n
length argument, an internal array buffer is created in memory, of size length multiplied by BYTES_PER_ELEMENT bytes, containing zeros.typedArray argument, which can be an object of any of the typed array types (such as Int32Array), the typedArray gets copied into a new typed array. Each value in typedArray is converted to the corresponding type of the constructor before being copied into the new array. The length of the new typed array will be same as the length of the typedArray argument.object argument, a new typed array is created as if by the TypedArray.from() method.buffer, and optionally a byteOffset and a length argument, a new typed array view is created that views the specified ArrayBuffer. The byteOffset and length parameters specify the memory range that will be exposed by the typed array view. If both are omitted, all of buffer is viewed; if only length is omitted, the remainder of buffer is viewed.ECMAScript 2015 defines a TypedArray constructor that serves as the [[Prototype]] of all TypedArray constructors. This constructor is not directly exposed: there is no global %TypedArray% or TypedArray property. It is only directly accessible through Object.getPrototypeOf(Int8Array) and similar. All TypedArrays constructors inherit common properties from the %TypedArray% constructor function. Additionally, all typed array prototypes (TypedArray.prototype) have %TypedArray%.prototype as their [[Prototype]].
The %TypedArray% constructor on its own is not particularly useful. Calling it or using it in a new expression will throw a TypeError, except when used during object creation in JS engines that support subclassing. There are at present no such engines, so %TypedArray% is only useful to polyfill functions or properties onto all TypedArray constructors.
When creating an instance of a TypedArray (e.g. Int8Array), an array buffer is created internally in memory or, if an ArrayBuffer object is given as constructor argument, then this is used instead. The buffer address is saved as an internal property of the instance and all the methods of %TypedArray%.prototype, i.e. set value and get value etc., operate on that array buffer address.
You can reference elements in the array using standard array index syntax (that is, using bracket notation). However, getting or setting indexed properties on typed arrays will not search in the prototype chain for this property, even when the indices are out of bound. Indexed properties will consult the ArrayBuffer and will never look at object properties. You can still use named properties, just like with all objects.
// Setting and getting using standard array syntax\nvar int16 = new Int16Array(2);\nint16[0] = 42;\nconsole.log(int16[0]); // 42\n\n// Indexed properties on prototypes are not consulted (Fx 25)\nInt8Array.prototype[20] = 'foo';\n(new Int8Array(32))[20]; // 0\n// even when out of bound\nInt8Array.prototype[20] = 'foo';\n(new Int8Array(8))[20]; // undefined\n// or with negative integers\nInt8Array.prototype[-1] = 'foo';\n(new Int8Array(8))[-1]; // undefined\n\n// Named properties are allowed, though (Fx 30)\nInt8Array.prototype.foo = 'bar';\n(new Int8Array(32)).foo; // \"bar\"
| Type | Value Range | Size in bytes | Description | Web IDL type | Equivalent C type |
|---|---|---|---|---|---|
Int8Array | -128 to 127 | 1 | 8-bit two's complement signed integer | byte | int8_t |
Uint8Array | 0 to 255 | 1 | 8-bit unsigned integer | octet | uint8_t |
Uint8ClampedArray | 0 to 255 | 1 | 8-bit unsigned integer (clamped) | octet | uint8_t |
Int16Array | -32768 to 32767 | 2 | 16-bit two's complement signed integer | short | int16_t |
Uint16Array | 0 to 65535 | 2 | 16-bit unsigned integer | unsigned short | uint16_t |
Int32Array | -2147483648 to 2147483647 | 4 | 32-bit two's complement signed integer | long | int32_t |
Uint32Array | 0 to 4294967295 | 4 | 32-bit unsigned integer | unsigned long | uint32_t |
Float32Array | 1.2x10-38 to 3.4x1038\n | 4 | 32-bit IEEE floating point number ( 7 significant digits e.g. 1.1234567) | unrestricted float | float |
Float64Array | 5.0x10-324 to 1.8x10308\n | 8 | 64-bit IEEE floating point number (16 significant digits e.g. 1.123...15) | unrestricted double | double |
TypedArray.BYTES_PER_ELEMENTTypedArray.nameget TypedArray[@@species]TypedArray.prototypeTypedArray.from()Array.from().TypedArray.of()Array.of().All TypedArrays inherit from TypedArray.prototype.
TypedArray.prototype.constructorTypedArray.prototype.buffer Read only \nArrayBuffer referenced by the typed array. Fixed at construction time and thus read only.TypedArray.prototype.byteLength Read only \nTypedArray.prototype.byteOffset Read only \nArrayBuffer. Fixed at construction time and thus read only.\nTypedArray.prototype.length Read only \nTypedArray.prototype.copyWithin()Array.prototype.copyWithin().TypedArray.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().TypedArray.prototype.every()Array.prototype.every().TypedArray.prototype.fill()Array.prototype.fill().TypedArray.prototype.filter()Array.prototype.filter().TypedArray.prototype.find()undefined if not found. See also Array.prototype.find().TypedArray.prototype.findIndex()Array.prototype.findIndex().TypedArray.prototype.forEach()Array.prototype.forEach().TypedArray.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().TypedArray.prototype.indexOf()Array.prototype.indexOf().TypedArray.prototype.join()Array.prototype.join().TypedArray.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().TypedArray.prototype.lastIndexOf()Array.prototype.lastIndexOf().TypedArray.prototype.map()Array.prototype.map().TypedArray.prototype.move() Unimplemented\nTypedArray.prototype.copyWithin().TypedArray.prototype.reduce()Array.prototype.reduce().TypedArray.prototype.reduceRight()Array.prototype.reduceRight().TypedArray.prototype.reverse()Array.prototype.reverse().TypedArray.prototype.set()TypedArray.prototype.slice()Array.prototype.slice().TypedArray.prototype.some()Array.prototype.some().TypedArray.prototype.sort()Array.prototype.sort().TypedArray.prototype.subarray()TypedArray.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().TypedArray.prototype.toLocaleString()Array.prototype.toLocaleString().TypedArray.prototype.toString()Array.prototype.toString().TypedArray.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Many of the methods used in Typed Arrays can be polyfilled using the methods present in regular Javascript Arrays. The following snippet of JavaScript demonstrates how you might polyfill any missing Typed Array methods.
var typedArrayTypes = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array,\n Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];\n\nfor (var k in typedArrayTypes)\n for (var v in Array.prototype)\n if (Array.prototype.hasOwnProperty(v) && \n !typedArrayTypes[k].prototype.hasOwnProperty(v))\n typedArrayTypes[k].prototype[v] = Array.prototype[v];\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Defined as TypedArray and ArrayBufferView interface with typed array view types. Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray Objects' in that specification. | Standard | Initial definition in an ECMA standard. Specified behaviour for indexed and named properties. Specified that new is required. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray Objects' in that specification. | Draft | ECMAScript 2017 changed the TypedArray constructor to use the ToIndex operation and allows constructors with no arguments. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
| Constructor without arguments | \n? | \n? | \n55 | \n10 | \n? | \n? | \n
| Indexed properties not consulting prototype | \n Yes\n
| \n? | \n25 | \n 10\n
| \n? | \n? | \n
| Iterable in constructor | \n? | \n? | \n52 | \n10 | \n? | \n? | \n
| Named properties | \nYes | \n? | \n30 | \n10 | \n? | \n? | \n
\nTypedArray() without new throws | \n? | \n? | \n44 | \nNo | \n? | \n? | \n
BYTES_PER_ELEMENT | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
buffer | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
byteLength | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
byteOffset | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
copyWithin | \n45 | \n14 | \n34 | \nNo | \n36 | \nNo | \n
entries | \n45 | \n14 | \n37 | \nNo | \n36 | \nNo | \n
every | \n45 | \n14 | \n37 | \nNo | \n36 | \nNo | \n
fill | \n45 | \n14 | \n37 | \nNo | \n36 | \nNo | \n
filter | \n45 | \n14 | \n38 | \nNo | \nNo | \nNo | \n
find | \nYes | \n14 | \n37 | \nNo | \nNo | \nNo | \n
findIndex | \nYes | \n14 | \n37 | \nNo | \nNo | \nNo | \n
forEach | \nYes | \n14 | \n38 | \nNo | \n? | \n10 | \n
from | \n45 | \n14 | \n38 | \nNo | \nNo | \n10 | \n
includes | \n47 | \n14 | \n43 | \nNo | \n34 | \n10 | \n
indexOf | \n45 | \n14 | \n 37\n
| \nNo | \n32 | \nNo | \n
join | \nYes | \n14 | \n37 | \nNo | \nNo | \nNo | \n
keys | \nYes | \n14 | \n37 | \nNo | \nNo | \n10 | \n
lastIndexOf | \nYes | \n14 | \n 37\n
| \nNo | \nYes | \n10 | \n
length | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
map | \nYes | \n14 | \n38 | \nNo | \nNo | \nNo | \n
\nmove \n | \nNo | \nNo | \n16 — 34\n
| \nNo | \nNo | \nNo | \n
name | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
of | \n45 | \n14 | \n38 | \nNo | \nNo | \nNo | \n
prototype | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
reduce | \n45 | \n14 | \n37 | \nNo | \n32 | \n10 | \n
reduceRight | \n45 | \n14 | \n37 | \nNo | \n32 | \n10 | \n
reverse | \n45 | \n14 | \n37 | \nNo | \n32 | \n10 | \n
set | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
slice | \n45 | \n14 | \n38 | \nNo | \n? | \n? | \n
some | \n45 | \n14 | \n37 | \nNo | \n32 | \n10 | \n
sort | \nYes | \n14 | \n46 | \nNo | \nYes | \n? | \n
subarray | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
toLocaleString | \nYes | \n? | \n51 | \n10 | \nYes | \nYes | \n
toString | \nYes | \n? | \n51 | \nNo | \nYes | \nYes | \n
values | \nYes | \n14 | \n37 | \nNo | \n26 | \n10 | \n
@@iterator | \nYes | \n? | \n 36\n
| \nNo | \nYes | \nYes | \n
@@species | \nYes | \n? | \n48 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| Constructor without arguments | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| Indexed properties not consulting prototype | \n Yes\n
| \n Yes\n
| \n? | \n25 | \n? | \n? | \nYes | \n
| Iterable in constructor | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Named properties | \nYes | \nYes | \n? | \n30 | \n? | \n? | \nYes | \n
\nTypedArray() without new throws | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
BYTES_PER_ELEMENT | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
buffer | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
byteLength | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
byteOffset | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
copyWithin | \nNo | \nNo | \n? | \n34 | \nNo | \nNo | \nNo | \n
entries | \nNo | \nYes | \n? | \n37 | \nNo | \nNo | \nYes | \n
every | \nNo | \nYes | \n? | \n37 | \nNo | \nNo | \nYes | \n
fill | \nNo | \nYes | \n? | \n37 | \nNo | \nNo | \nYes | \n
filter | \nNo | \nYes | \n? | \n38 | \nNo | \nNo | \nYes | \n
find | \nNo | \nNo | \n? | \n37 | \nNo | \nNo | \nNo | \n
findIndex | \nNo | \nNo | \n? | \n37 | \nNo | \nNo | \nNo | \n
forEach | \nNo | \nYes | \n? | \n38 | \n? | \n? | \nYes | \n
from | \nNo | \nNo | \n? | \n38 | \nNo | \n10 | \nNo | \n
includes | \nNo | \n47 | \n? | \n43 | \n34 | \n10 | \n5.0 | \n
indexOf | \nNo | \n45 | \nYes | \n 37\n
| \n32 | \nNo | \n5.0 | \n
join | \nNo | \nYes | \nYes | \n37 | \nNo | \nNo | \nYes | \n
keys | \nNo | \nYes | \nYes | \n37 | \nNo | \n10 | \nYes | \n
lastIndexOf | \nNo | \nYes | \nYes | \n 37\n
| \nYes | \n10 | \nYes | \n
length | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
map | \nNo | \nYes | \nYes | \n38 | \nNo | \nNo | \nYes | \n
\nmove \n | \nNo | \nNo | \nNo | \n38 — 34\n
| \nNo | \nNo | \nNo | \n
name | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
of | \nNo | \nNo | \n? | \n38 | \nNo | \nNo | \nNo | \n
prototype | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
reduce | \n? | \n? | \nYes | \n37 | \nNo | \n10 | \n? | \n
reduceRight | \n? | \n? | \nYes | \n37 | \nNo | \n10 | \n? | \n
reverse | \n? | \n? | \nYes | \n37 | \nNo | \n10 | \n? | \n
set | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
slice | \n? | \n? | \n? | \n38 | \n? | \n? | \n? | \n
some | \n? | \n? | \n? | \n37 | \nNo | \n10 | \n? | \n
sort | \n? | \n? | \n? | \n46 | \n? | \n? | \n? | \n
subarray | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
toLocaleString | \nYes | \nYes | \n? | \n51 | \nYes | \nYes | \nYes | \n
toString | \nYes | \nYes | \n? | \n51 | \nYes | \nYes | \nYes | \n
values | \nYes | \nYes | \nYes | \n37 | \nYes | \n10 | \nYes | \n
@@iterator | \nYes | \nYes | \n? | \n 36\n
| \nYes | \nYes | \nYes | \n
@@species | \n? | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Constructor without arguments | \n? | \n
| Indexed properties not consulting prototype | \n ? \n
| \n
| Iterable in constructor | \n4.0.0 | \n
| Named properties | \n? | \n
\nTypedArray() without new throws | \n0.12 | \n
BYTES_PER_ELEMENT | \nYes | \n
buffer | \nYes | \n
byteLength | \nYes | \n
byteOffset | \nYes | \n
copyWithin | \n4.0.0 | \n
entries | \n0.12 | \n
every | \n4.0.0 | \n
fill | \n4.0.0 | \n
filter | \n4.0.0 | \n
find | \n4.0.0 | \n
findIndex | \n4.0.0 | \n
forEach | \n4.0.0 | \n
from | \n4.0.0 | \n
includes | \n 6.0.0\n
| \n
indexOf | \n4.0.0 | \n
join | \n4.0.0 | \n
keys | \n0.12 | \n
lastIndexOf | \n4.0.0 | \n
length | \nYes | \n
map | \n4.0.0 | \n
\nmove \n | \nNo | \n
name | \nYes | \n
of | \n4.0.0 | \n
prototype | \nYes | \n
reduce | \n4.0.0 | \n
reduceRight | \n4.0.0 | \n
reverse | \n4.0.0 | \n
set | \n? | \n
slice | \n4.0.0 | \n
some | \n4.0.0 | \n
sort | \n4.0.0 | \n
subarray | \n0.12 | \n
toLocaleString | \n? | \n
toString | \n? | \n
values | \n0.12 | \n
@@iterator | \n0.12 | \n
@@species | \n 6.5.0\n
| \n
Starting with ECMAScript 2015, TypedArray constructors require to be constructed with a new operator. Calling a TypedArray constructor as a function without new, will throw a TypeError from now on.
var dv = Int8Array([1, 2, 3]);\n// TypeError: calling a builtin Int8Array constructor \n// without new is forbidden
var dv = new Int8Array([1, 2, 3]);
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\n
The function* keyword can be used to define a generator function inside an expression.
function* [name]([param1[, param2[, ..., paramN]]]) {\n statements\n} nameparamNstatementsA function* expression is very similar to and has almost the same syntax as a function* statement. The main difference between a function* expression and a function* statement is the function name, which can be omitted in function* expressions to create anonymous generator functions. See also the chapter about functions for more information.
The following example defines an unnamed generator function and assigns it to x. The function yields the square of its argument:
var x = function*(y) {\n yield y * y;\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'function*' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'function*' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n26 | \nNo | \nYes | \n10 | \n
| Trailing comma in parameters | \n58 | \n? | \n52 | \n? | \n45 | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n26 | \nYes | \n10 | \nYes | \n
| Trailing comma in parameters | \n58 | \n58 | \n? | \n52 | \n45 | \n? | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Trailing comma in parameters | \n8.0.0 | \n
function* statementGeneratorFunction objectyieldyield*Function objectfunction statementfunction expressionFunctions and function scope\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function*\n
Spread syntax allows an iterable such as an array expression or string to be expanded in places where zero or more arguments (for function calls) or elements (for array literals) are expected, or an object expression to be expanded in places where zero or more key-value pairs (for object literals) are expected.
For function calls:
myFunction(...iterableObj);\n
For array literals or strings:
[...iterableObj, '4', 'five', 6];
For object literals (new in ECMAScript 2018):
let objClone = { ...obj }; It is common to use Function.prototype.apply in cases where you want to use the elements of an array as arguments to a function.
function myFunction(x, y, z) { }\nvar args = [0, 1, 2];\nmyFunction.apply(null, args); With spread syntax the above can be written as:
function myFunction(x, y, z) { }\nvar args = [0, 1, 2];\nmyFunction(...args); Any argument in the argument list can use spread syntax and it can be used multiple times.
function myFunction(v, w, x, y, z) { }\nvar args = [0, 1];\nmyFunction(-1, ...args, 2, ...[3]); When calling a constructor with new, it's not possible to directly use an array and apply (apply does a [[Call]] and not a [[Construct]]). However, an array can be easily used with new thanks to spread syntax:
var dateFields = [1970, 0, 1]; // 1 Jan 1970\nvar d = new Date(...dateFields);\n
To use new with an array of parameters without spread syntax, you would have to do it indirectly through partial application:
function applyAndNew(constructor, args) {\n function partial () {\n return constructor.apply(this, args);\n };\n if (typeof constructor.prototype === \"object\") {\n partial.prototype = Object.create(constructor.prototype);\n }\n return partial;\n}\n\n\nfunction myConstructor () {\n console.log(\"arguments.length: \" + arguments.length);\n console.log(arguments);\n this.prop1=\"val1\";\n this.prop2=\"val2\";\n};\n\nvar myArguments = [\"hi\", \"how\", \"are\", \"you\", \"mr\", null];\nvar myConstructorWithArguments = applyAndNew(myConstructor, myArguments);\n\nconsole.log(new myConstructorWithArguments);\n// (internal log of myConstructor): arguments.length: 6\n// (internal log of myConstructor): [\"hi\", \"how\", \"are\", \"you\", \"mr\", null]\n// (log of \"new myConstructorWithArguments\"): {prop1: \"val1\", prop2: \"val2\"} Without spread syntax, to create a new array using an existing array as one part of it, the array literal syntax is no longer sufficient and imperative code must be used instead using a combination of push, splice, concat, etc. With spread syntax this becomes much more succinct:
var parts = ['shoulders', 'knees']; \nvar lyrics = ['head', ...parts, 'and', 'toes']; \n// [\"head\", \"shoulders\", \"knees\", \"and\", \"toes\"]\n
Just like spread for argument lists, ... can be used anywhere in the array literal and it can be used multiple times.
var arr = [1, 2, 3];\nvar arr2 = [...arr]; // like arr.slice()\narr2.push(4); \n\n// arr2 becomes [1, 2, 3, 4]\n// arr remains unaffected\n
Note: Spread syntax effectively goes one level deep while copying an array. Therefore, it may be unsuitable for copying multidimensional arrays as the following example shows (it's the same with Object.assign() and spread syntax).
var a = [[1], [2], [3]];\nvar b = [...a];\nb.shift().shift(); // 1\n// Now array a is affected as well: [[], [2], [3]]\n
Array.concat is often used to concatenate an array to the end of an existing array. Without spread syntax this is done as:
var arr1 = [0, 1, 2];\nvar arr2 = [3, 4, 5];\n// Append all items from arr2 onto arr1\narr1 = arr1.concat(arr2);
With spread syntax this becomes:
var arr1 = [0, 1, 2];\nvar arr2 = [3, 4, 5];\narr1 = [...arr1, ...arr2];\n
Array.unshift is often used to insert an array of values at the start of an existing array. Without spread syntax this is done as:
var arr1 = [0, 1, 2];\nvar arr2 = [3, 4, 5];\n// Prepend all items from arr2 onto arr1\nArray.prototype.unshift.apply(arr1, arr2) // arr1 is now [3, 4, 5, 0, 1, 2]
With spread syntax this becomes [Note, however, that this creates a new arr1 array. Unlike Array.unshift, it does not modify the original arr1 array in-place]:
var arr1 = [0, 1, 2];\nvar arr2 = [3, 4, 5];\narr1 = [...arr2, ...arr1]; // arr1 is now [3, 4, 5, 0, 1, 2]\n
The Rest/Spread Properties for ECMAScript proposal (stage 4) adds spread properties to object literals. It copies own enumerable properties from a provided object onto a new object.
Shallow-cloning (excluding prototype) or merging of objects is now possible using a shorter syntax than Object.assign().
var obj1 = { foo: 'bar', x: 42 };\nvar obj2 = { foo: 'baz', y: 13 };\n\nvar clonedObj = { ...obj1 };\n// Object { foo: \"bar\", x: 42 }\n\nvar mergedObj = { ...obj1, ...obj2 };\n// Object { foo: \"baz\", x: 42, y: 13 } Note that Object.assign() triggers setters whereas spread syntax doesn't.
Note that you cannot replace nor mimic the Object.assign() function:
var obj1 = { foo: 'bar', x: 42 };\nvar obj2 = { foo: 'baz', y: 13 };\nconst merge = ( ...objects ) => ( { ...objects } );\n\nvar mergedObj = merge ( obj1, obj2);\n// Object { 0: { foo: 'bar', x: 42 }, 1: { foo: 'baz', y: 13 } }\n\nvar mergedObj = merge ( {}, obj1, obj2);\n// Object { 0: {}, 1: { foo: 'bar', x: 42 }, 2: { foo: 'baz', y: 13 } } In the above example, the spread syntax does not work as one might expect: it spreads an array of arguments into the object literal, due to the rest parameter.
Spread syntax (other than in the case of spread properties) can be applied only to iterable objects:
var obj = {'key1': 'value1'};\nvar array = [...obj]; // TypeError: obj is not iterable\n When using spread syntax for function calls, be aware of the possibility of exceeding the JavaScript engine's argument length limit. See apply() for more details.
Rest syntax looks exactly like spread syntax, but is used for destructuring arrays and objects. In a way, rest syntax is the opposite of spread syntax: spread 'expands' an array into its elements, while rest collects multiple elements and 'condenses' them into a single element. See rest parameters.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) | Standard | Defined in several sections of the specification: Array Initializer, Argument Lists\n |
| ECMAScript 2018 (ECMA-262) | Standard | Defined in Object Initializer\n |
| ECMAScript Latest Draft (ECMA-262) | Draft | No changes. |
| ECMAScript Latest Draft (ECMA-262) | Draft | No changes. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Spread in array literals | \n46 | \n12 | \n16 | \nNo | \n37 | \n8 | \n
| Spread in function calls | \n46 | \n12 | \n27 | \nNo | \n37 | \n8 | \n
| Spread in destructuring | \n49 | \nNo | \n34 | \nNo | \n37 | \n? | \n
| \nSpread in object literals \n | \n60 | \nNo | \n55 | \nNo | \n? | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Spread in array literals | \n46 | \n46 | \n12 | \n16 | \n37 | \n8 | \n5.0 | \n
| Spread in function calls | \n46 | \n46 | \n12 | \n27 | \n37 | \n8 | \n5.0 | \n
| Spread in destructuring | \n49 | \n49 | \nNo | \n34 | \n37 | \n? | \n5.0 | \n
| \nSpread in object literals \n | \n60 | \n60 | \nNo | \n55 | \n? | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Spread in array literals | \n 5.0.0\n
| \n
| Spread in function calls | \n 5.0.0\n
| \n
| Spread in destructuring | \nYes | \n
| \nSpread in object literals \n | \n 8.3.0\n
| \n
...’)...’)\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax\n
The void evaluates the given expression and then returns undefined.
void expression
This operator allows evaluating expressions that produce a value into places where an expression that evaluates to undefined is desired.
The void operator is often used merely to obtain the undefined primitive value, usually using \"void(0)\" (which is equivalent to \"void 0\"). In these cases, the global variable undefined can be used instead (assuming it has not been assigned to a non-default value).
When using an immediately-invoked function expression, void can be used to force the function keyword to be treated as an expression instead of a declaration.
void function iife() {\n var bar = function () {};\n var baz = function () {};\n var foo = function () {\n bar();\n baz();\n };\n var biz = function () {};\n\n foo();\n biz();\n}();\n When a browser follows a javascript: URI, it evaluates the code in the URI and then replaces the contents of the page with the returned value, unless the returned value is undefined. The void operator can be used to return undefined. For example:
<a href=\"javascript:void(0);\">\n Click here to do nothing\n</a>\n\n<a href=\"javascript:void(document.body.style.backgroundColor='green');\">\n Click here for green background\n</a>\n
Note, however, that the javascript: pseudo protocol is discouraged over other alternatives, such as unobtrusive event handlers.
Arrow functions introduce a short-hand braceless syntax that returns an expression. This can cause unintended side effects by returning the result of a function call that previously returned nothing. To be safe, when the return value of a function is not intended to be used, it can be passed to the void operator to ensure that (for example) changing APIs do not cause arrow functions' behaviors to change.
button.onclick = () => void doSomething();
This ensures the return value of doSomething changing from undefined to true will not change the behavior of this code.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'The void Operator' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'The void Operator' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'The void Operator' in that specification. | Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'The void Operator' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'The void Operator' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.1 |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void\n
Thenew creates an instance of a user-defined object type or of one of the built-in object types that has a constructor function.
new constructor[([arguments])]
constructorargumentsconstructor will be called with.Creating a user-defined object requires two steps:
new.To define an object type, create a function for the object type that specifies its name and properties. An object can have a property that is itself or another object. See the examples below.
When the code new Foo(...) is executed, the following things happen:
Foo.prototype.Foo is called with the specified arguments, and with this bound to the newly created object. new Foo is equivalent to new Foo(), i.e. if no argument list is specified, Foo is called without arguments.new expression. If the constructor function doesn't explicitly return an object, the object created in step 1 is used instead. (Normally constructors don't return a value, but they can choose to do so if they want to override the normal object creation process.)You can always add a property to a previously defined object. For example, the statement car1.color = \"black\" adds a property color to car1, and assigns it a value of \"black\". However, this does not affect any other objects. To add the new property to all objects of the same type, you must add the property to the definition of the Car object type.
You can add a shared property to a previously defined object type by using the Function.prototype property. This defines a property that is shared by all objects created with that function, rather than by just one instance of the object type. The following code adds a color property with value \"original color\" to all objects of type Car, and then overwrites that value with the string \"black\" only in the instance object car1. For more information, see prototype.
function Car() {}\ncar1 = new Car();\ncar2 = new Car();\n \nconsole.log(car1.color); // undefined\n \nCar.prototype.color = \"original color\";\nconsole.log(car1.color); // original color\n \ncar1.color = 'black';\nconsole.log(car1.color); // black\n\nconsole.log(car1.__proto__.color) //original color\nconsole.log(car2.__proto__.color) //original color\nconsole.log(car1.color) // black\nconsole.log(car2.color) // original color\n If you didn't write the new operator, the Constructor Function would be invoked like any Regular Function, without creating an Object.In this case, the value of this is also different.
Suppose you want to create an object type for cars. You want this type of object to be called Car, and you want it to have properties for make, model, and year. To do this, you would write the following function:
function Car(make, model, year) {\n this.make = make;\n this.model = model;\n this.year = year;\n}\n Now you can create an object called mycar as follows:
var mycar = new Car('Eagle', 'Talon TSi', 1993);\n This statement creates mycar and assigns it the specified values for its properties. Then the value of mycar.make is the string \"Eagle\", mycar.year is the integer 1993, and so on.
You can create any number of car objects by calls to new. For example:
var kenscar = new Car('Nissan', '300ZX', 1992);\n Suppose you define an object called person as follows:
function Person(name, age, sex) {\n this.name = name;\n this.age = age;\n this.sex = sex;\n}\n And then instantiate two new person objects as follows:
var rand = new Person('Rand McNally', 33, 'M');\nvar ken = new Person('Ken Jones', 39, 'M');\n Then you can rewrite the definition of car to include an owner property that takes a person object, as follows:
function Car(make, model, year, owner) {\n this.make = make;\n this.model = model;\n this.year = year;\n this.owner = owner;\n}\n To instantiate the new objects, you then use the following:
var car1 = new Car('Eagle', 'Talon TSi', 1993, rand);\nvar car2 = new Car('Nissan', '300ZX', 1992, ken);\n Instead of passing a literal string or integer value when creating the new objects, the above statements pass the objects rand and ken as the parameters for the owners. To find out the name of the owner of car2, you can access the following property:
car2.owner.name\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'The new Operator' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'The new Operator' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'The new Operator' in that specification. | Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'The new Operator' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'The new Operator' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new\n
The typeof operator returns a string indicating the type of the unevaluated operand.
The typeof operator is followed by its operand:
typeof operand\n
operand is an expression representing the object or primitive whose type is to be returned.
The parentheses are optional.
The following table summarizes the possible return values of typeof. For more information about types and primitives, see also the JavaScript data structure page.
| Type | Result |
|---|---|
| Undefined | \"undefined\" |
| Null | \n\"object\" (see below) |
| Boolean | \"boolean\" |
| Number | \"number\" |
| String | \"string\" |
| Symbol (new in ECMAScript 2015) | \"symbol\" |
| Host object (provided by the JS environment) | Implementation-dependent |
| Function object (implements [[Call]] in ECMA-262 terms) | \"function\" |
| Any other object | \"object\" |
// Numbers\ntypeof 37 === 'number';\ntypeof 3.14 === 'number';\ntypeof(42) === 'number';\ntypeof Math.LN2 === 'number';\ntypeof Infinity === 'number';\ntypeof NaN === 'number'; // Despite being \"Not-A-Number\"\ntypeof Number('1') === 'number'; // Number tries to parse things into numbers\n\n\n// Strings\ntypeof '' === 'string';\ntypeof 'bla' === 'string';\ntypeof `template literal` === 'string';\ntypeof '1' === 'string'; // note that a number within a string is still typeof string\ntypeof (typeof 1) === 'string'; // typeof always returns a string\ntypeof String(1) === 'string'; // String converts anything into a string, safer than toString\n\n\n// Booleans\ntypeof true === 'boolean';\ntypeof false === 'boolean';\ntypeof Boolean(1) === 'boolean'; // Boolean() will convert values based on if they're truthy or falsy\ntypeof !!(1) === 'boolean'; // two calls of the ! (logical NOT) operator are equivalent to Boolean()\n\n\n// Symbols\ntypeof Symbol() === 'symbol'\ntypeof Symbol('foo') === 'symbol'\ntypeof Symbol.iterator === 'symbol'\n\n\n// Undefined\ntypeof undefined === 'undefined';\ntypeof declaredButUndefinedVariable === 'undefined';\ntypeof undeclaredVariable === 'undefined'; \n\n\n// Objects\ntypeof {a: 1} === 'object';\n\n// use Array.isArray or Object.prototype.toString.call\n// to differentiate regular objects from arrays\ntypeof [1, 2, 4] === 'object';\n\ntypeof new Date() === 'object';\ntypeof /regex/ === 'object'; // See Regular expressions section for historical results\n\n\n// The following are confusing, dangerous, and wasteful. Avoid them.\ntypeof new Boolean(true) === 'object'; \ntypeof new Number(1) === 'object'; \ntypeof new String('abc') === 'object';\n\n\n// Functions\ntypeof function() {} === 'function';\ntypeof class C {} === 'function';\ntypeof Math.sin === 'function';\n null// This stands since the beginning of JavaScript\ntypeof null === 'object';\n
In the first implementation of JavaScript, JavaScript values were represented as a type tag and a value. The type tag for objects was 0. null was represented as the NULL pointer (0x00 in most platforms). Consequently, null had 0 as type tag, hence the bogus typeof return value. (reference)
A fix was proposed for ECMAScript (via an opt-in), but was rejected. It would have resulted in typeof null === 'null'.
new operator// All constructor functions, with the exception of the Function constructor, will always be typeof 'object'\nvar str = new String('String');\nvar num = new Number(100);\n\ntypeof str; // It will return 'object'\ntypeof num; // It will return 'object'\n\nvar func = new Function();\n\ntypeof func; // It will return 'function'\n // Parentheses can be used for determining the data type of expressions.\nvar iData = 99;\n\ntypeof iData + ' Wisen'; // 'number Wisen'\ntypeof (iData + ' Wisen'); // 'string'\n\n\n
Callable regular expressions were a non-standard addition in some browsers.
typeof /s/ === 'function'; // Chrome 1-12 Non-conform to ECMAScript 5.1\ntypeof /s/ === 'object'; // Firefox 5+ Conform to ECMAScript 5.1\n
Before ECMAScript 2015, typeof was always guaranteed to return a string for any operand it was supplied with. Even with undeclared identifiers, typeof will return 'undefined'. Using typeof could never generate an error.
But with the addition of non-hoisted, block-scoped let and const, using typeof on let and const variables (or using typeof on a class) in a block before they are declared will throw a ReferenceError. Block scoped variables are in a \"temporal dead zone\" from the start of the block until the initialization is processed, during which, it will throw an error if accessed.
typeof undeclaredVariable === 'undefined';\n\ntypeof newLetVariable; // ReferenceError\ntypeof newConstVariable; // ReferenceError\ntypeof newClass; // ReferenceError\n\nlet newLetVariable;\nconst newConstVariable = 'hello';\nclass newClass{}; All current browsers expose a non-standard host object document.all with type undefined.
typeof document.all === 'undefined';\n
Although the specification allows custom type tags for non-standard exotic objects, it requires those type tags to be different from the predefined ones. The case of document.all having type 'undefined' is classified in the web standards as a \"willful violation\" of the original ECMA JavaScript standard.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'The typeof Operator' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'The typeof Operator' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'The typeof Operator' in that specification. | Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'The typeof Operator' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'The typeof Operator' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.1. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
On IE 6, 7, and 8 a lot of host objects are objects and not functions. For example:
typeof alert === 'object'
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof\n
The break statement terminates the current loop, switch, or label statement and transfers program control to the statement following the terminated statement.
break [label];
labelswitch, this is required.The break statement includes an optional label that allows the program to break out of a labeled statement. The break statement needs to be nested within the referenced label. The labeled statement can be any block statement; it does not have to be preceded by a loop statement.
A break statement, with or without a following label, cannot be used within the body of a function that is itself nested within the current loop, switch, or label statement that the break statement is intended to break out of.
The following function has a break statement that terminates the while loop when i is 3, and then returns the value 3 * x.
function testBreak(x) {\n var i = 0;\n\n while (i < 6) {\n if (i == 3) {\n break;\n }\n i += 1;\n }\n\n return i * x;\n} The following code uses break statements with labeled blocks. A break statement must be nested within any label it references. Notice that inner_block is nested within outer_block.
outer_block: {\n inner_block: {\n console.log('1');\n break outer_block; // breaks out of both inner_block and outer_block\n console.log(':-('); // skipped\n }\n console.log('2'); // skipped\n}\n The following code also uses break statements with labeled blocks but generates a Syntax Error because its break statement is within block_1 but references block_2. A break statement must always be nested within any label it references.
block_1: {\n console.log('1');\n break block_2; // SyntaxError: label not found\n}\n\nblock_2: {\n console.log('2');\n}\n Syntax Errors are also generated in the following code examples which use break statements within functions that are nested within a loop or labeled block that the break statements are intended to break out of.
function testBreak(x) {\n var i = 0;\n\n while (i < 6) {\n if (i == 3) {\n (function() {\n break;\n })();\n }\n i += 1;\n }\n\nreturn i * x;\n}\n\ntestBreak(1); // SyntaxError: Illegal break statement\n block_1: {\n console.log('1');\n ( function() {\n break block_1; // SyntaxError: Undefined label 'block_1'\n })();\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Unlabeled version. |
| ECMAScript 3rd Edition (ECMA-262) | Standard | Labeled version added. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Break statement' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Break statement' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Break statement' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/break\n
The yield keyword is used to pause and resume a generator function (function* or legacy generator function).
[rv] = yield [expression];
expressionundefined is returned instead.rvReturns the optional value passed to the generator's next() method to resume its execution.
The yield keyword pauses generator function execution and the value of the expression following the yield keyword is returned to the generator's caller. It can be thought of as a generator-based version of the return keyword.
The yield keyword actually returns an IteratorResult object with two properties, value and done. The value property is the result of evaluating the yield expression, and done is false, indicating that the generator function has not fully completed.
Once paused on a yield expression, the generator's code execution remains paused until the generator's next() method is called. Each time the generator's next() method is called, the generator resumes execution and runs until it reaches one of the following:
yield, which causes the generator to once again pause and return the generator's new value. The next time next() is called, execution resumes with the statement immediately after the yield.throw is used to throw an exception from the generator. This halts execution of the generator entirely, and execution resumes in the caller as is normally the case when an exception is thrown.IteratorResult is returned to the caller in which the value is undefined and done is true.return statement is reached. In this case, execution of the generator ends and an IteratorResult is returned to the caller in which the value is the value specified by the return statement and done is true.If an optional value is passed to the generator's next() method, that value becomes the value returned by the generator's current yield operation.
Between the generator's code path, its yield operators, and the ability to specify a new starting value by passing it to Generator.prototype.next(), generators offer enormous power and control.
The following code is the declaration of an example generator function.
function* countAppleSales () {\n var saleList = [3, 7, 5];\n for (var i = 0; i < saleList.length; i++) {\n yield saleList[i];\n }\n} Once a generator function is defined, it can be used by constructing an iterator as shown.
var appleStore = countAppleSales(); // Generator { }\nconsole.log(appleStore.next()); // { value: 3, done: false }\nconsole.log(appleStore.next()); // { value: 7, done: false }\nconsole.log(appleStore.next()); // { value: 5, done: false }\nconsole.log(appleStore.next()); // { value: undefined, done: true } | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Yield' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Yield' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n39 | \nYes | \n 26\n
| \nNo | \nYes | \n10 | \n
\nIteratorResult object instead of throwing | \n? | \n? | \n29 | \nNo | \n? | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n39 | \n39 | \nYes | \n 26\n
| \nYes | \n10 | \n4.0 | \n
\nIteratorResult object instead of throwing | \n? | \n? | \n? | \n29 | \n? | \n10 | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
\nIteratorResult object instead of throwing | \n? | \n
TypeError \"generator has already finished\". Instead, it returns an IteratorResult object like { value: undefined, done: true } (bug 958951).yield expression has been updated to conform with the ES2015 specification (bug 981599): yield keyword is optional and omitting it no longer throws a SyntaxError: function* countAppleSales() { yield; }\n\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield\n
Thenew.target property lets you detect whether a function or constructor was called using the new operator. In constructors and functions instantiated with the new operator, new.target returns a reference to the constructor or function. In normal function calls, new.target is undefined.
new.target
The new.target syntax consists of the keyword \"new\", a dot, and a property name \"target\". Normally \"new.\" serves as the context for a property access, but here \"new.\" is not really an object. In constructor calls, however, new.target refers to the constructor invoked by new and so \"new.\" becomes a virtual context.
The new.target property is a meta property that is available to all functions. In arrow functions, new.target refers to the new.target of the surrounding function.
In normal function calls (as opposed to constructor function calls), new.target is undefined. This lets you detect if a function was called with new as a constructor.
function Foo() {\n if (!new.target) throw 'Foo() must be called with new';\n console.log('Foo instantiated with new');\n}\n\nFoo(); // throws \"Foo() must be called with new\"\nnew Foo(); // logs \"Foo instantiated with new\"\n In class constructors, new.target refers to the constructor that was directly invoked by new. This is also the case if the constructor is in a parent class and was delegated from a child constructor.
class A {\n constructor() {\n console.log(new.target.name);\n }\n}\n\nclass B extends A { constructor() { super(); } }\n\nvar a = new A(); // logs \"A\"\nvar b = new B(); // logs \"B\"\n\nclass C { constructor() { console.log(new.target); } }\nclass D extends C { constructor() { super(); } }\n \nvar c = new C(); // logs class C{constructor(){console.log(new.target);}}\nvar d = new D(); // logs class D extends C{constructor(){super();}} Thus from the above example of class C and D, it seems that new.target points to the class Definition of class which is initialized. For example, when D was initialized using new, the class definition of D was printed and similarly in case of c, class C was printed
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Built-in Function Objects' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Built-in Function Objects' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n46 | \nYes | \n41 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n46 | \n46 | \nYes | \n41 | \nYes | \nYes | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n5.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new.target\n
A block statement (or compound statement in other languages) is used to group zero or more statements. The block is delimited by a pair of curly brackets and may optionally be labelled:
{\n StatementList\n}\n LabelIdentifier: {\n StatementList\n}\n StatementListLabelIdentifierlabel for visual identification or as a target for break.The block statement is often called compound statement in other languages. It allows you to use multiple statements where JavaScript expects only one statement. Combining statements into blocks is a common practice in JavaScript. The opposite behavior is possible using an empty statement, where you provide no statement, although one is required.
var\nVariables declared with var do not have block scope. Variables introduced with a block are scoped to the containing function or script, and the effects of setting them persist beyond the block itself. In other words, block statements do not introduce a scope. Although \"standalone\" blocks are valid syntax, you do not want to use standalone blocks in JavaScript, because they don't do what you think they do, if you think they do anything like such blocks in C or Java. For example:
var x = 1;\n{\n var x = 2;\n}\nconsole.log(x); // logs 2\n This logs 2 because the var x statement within the block is in the same scope as the var x statement before the block. In C or Java, the equivalent code would have outputted 1.
let and const\nBy contrast, identifiers declared with let and const do have block scope:
let x = 1;\n{\n let x = 2;\n}\nconsole.log(x); // logs 1 The x = 2 is limited in scope to the block in which it was defined.
The same is true of const:
const c = 1;\n{\n const c = 2;\n}\nconsole.log(c); // logs 1 and does not throw SyntaxError... Note that the block-scoped const c = 2 does not throw a SyntaxError: Identifier 'c' has already been declared because it can be declared uniquely within the block.
function\nA function declaration is also limited in scope inside the block where the declaration occurs:
foo('outside'); // TypeError: foo is not a function\n{\n function foo(location) {\n console.log('foo is called ' + location);\n }\n foo('inside'); // works correctly and logs 'foo is called inside'\n} To be more precise, the block statement is preventing the function declaration from being hoisted to the top of the scope. The function is behaving as if it were defined as a function expression and, as such, it is only the implicit variable declaration that gets hoisted to the top of the scope:
foo; // returns undefined\n{\n function foo(location) {\n console.log('foo is called ' + location);\n }\n foo('inside'); // works correctly and logs 'foo is called inside'\n} Consequently, this means that if we move the call to foo below the block statement that there will be no error:
{\n function foo(location) {\n console.log('foo is called ' + location);\n }\n foo('inside'); // works correctly and logs 'foo is called inside'\n}\nfoo('outside'); // works correctly and logs 'foo is called outside' | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Block statement' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Block statement' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'Block statement' in that specification. | Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'Block statement' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'Block statement' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block\n
let statement. The value of a constant cannot change through reassignment, and it can't be redeclared. const name1 = value1 [, name2 = value2 [, ... [, nameN = valueN]]];
nameNvalueNThis declaration creates a constant whose scope can be either global or local to the block in which it is declared. Global constants do not become properties of the window object, unlike var variables. An initializer for a constant is required; that is, you must specify its value in the same statement in which it's declared (which makes sense, given that it can't be changed later).
Theconst creates a read-only reference to a value. It does not mean the value it holds is immutable, just that the variable identifier cannot be reassigned. For instance, in the case where the content is an object, this means the object's contents (e.g., its properties) can be altered.
All the considerations about the \"temporal dead zone\" apply to both let and const.
A constant cannot share its name with a function or a variable in the same scope.
The following example demonstrates how constants behave. Try this in your browser console.
// NOTE: Constants can be declared with uppercase or lowercase, but a common\n// convention is to use all-uppercase letters.\n\n// define MY_FAV as a constant and give it the value 7\nconst MY_FAV = 7;\n\n// this will throw an error - Uncaught TypeError: Assignment to constant variable.\nMY_FAV = 20;\n\n// MY_FAV is 7\nconsole.log('my favorite number is: ' + MY_FAV);\n\n// trying to redeclare a constant throws an error - Uncaught SyntaxError: Identifier 'MY_FAV' has already been declared\nconst MY_FAV = 20;\n\n// the name MY_FAV is reserved for constant above, so this will fail too\nvar MY_FAV = 20;\n\n// this throws an error too\nlet MY_FAV = 20;\n\n// it's important to note the nature of block scoping\nif (MY_FAV === 7) { \n // this is fine and creates a block scoped MY_FAV variable \n // (works equally well with let to declare a block scoped non const variable)\n let MY_FAV = 20;\n\n // MY_FAV is now 20\n console.log('my favorite number is ' + MY_FAV);\n\n // this gets hoisted into the global context and throws an error\n var MY_FAV = 20;\n}\n\n// MY_FAV is still 7\nconsole.log('my favorite number is ' + MY_FAV);\n\n// throws an error - Uncaught SyntaxError: Missing initializer in const declaration\nconst FOO; \n\n// const also works on objects\nconst MY_OBJECT = {'key': 'value'};\n\n// Attempting to overwrite the object throws an error - Uncaught TypeError: Assignment to constant variable.\nMY_OBJECT = {'OTHER_KEY': 'value'};\n\n// However, object keys are not protected,\n// so the following statement is executed without problem\nMY_OBJECT.key = 'otherValue'; // Use Object.freeze() to make object immutable\n\n// The same applies to arrays\nconst MY_ARRAY = [];\n// It's possible to push items into the array\nMY_ARRAY.push('A'); // [\"A\"]\n// However, assigning a new array to the variable throws an error - Uncaught TypeError: Assignment to constant variable.\nMY_ARRAY = ['B']; | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Let and Const Declarations' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Let and Const Declarations' in that specification. | Draft | No changes. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n21 | \nYes | \n 36\n
| \n11 | \nYes | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n 36\n
| \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const\n
The yield* is used to delegate to another generator or iterable object.
yield* [[expression]];
expressionThe yield* expression iterates over the operand and yields each value returned by it.
The value of yield* expression itself is the value returned by that iterator when it's closed (i.e., when done is true).
In following code, values yielded by g1() are returned from next() calls just like those which are yielded by g2().
function* g1() {\n yield 2;\n yield 3;\n yield 4;\n}\n\nfunction* g2() {\n yield 1;\n yield* g1();\n yield 5;\n}\n\nvar iterator = g2();\n\nconsole.log(iterator.next()); // {value: 1, done: false}\nconsole.log(iterator.next()); // {value: 2, done: false}\nconsole.log(iterator.next()); // {value: 3, done: false}\nconsole.log(iterator.next()); // {value: 4, done: false}\nconsole.log(iterator.next()); // {value: 5, done: false}\nconsole.log(iterator.next()); // {value: undefined, done: true}\n Besides generator objects, yield* can also yield other kinds of iterables, e.g. arrays, strings or arguments objects.
function* g3() {\n yield* [1, 2];\n yield* '34';\n yield* Array.from(arguments);\n}\n\nvar iterator = g3(5, 6);\n\nconsole.log(iterator.next()); // {value: 1, done: false}\nconsole.log(iterator.next()); // {value: 2, done: false}\nconsole.log(iterator.next()); // {value: \"3\", done: false}\nconsole.log(iterator.next()); // {value: \"4\", done: false}\nconsole.log(iterator.next()); // {value: 5, done: false}\nconsole.log(iterator.next()); // {value: 6, done: false}\nconsole.log(iterator.next()); // {value: undefined, done: true}\n yield* expression itselfyield* is an expression, not a statement, so it evaluates to a value.
function* g4() {\n yield* [1, 2, 3];\n return 'foo';\n}\n\nvar result;\n\nfunction* g5() {\n result = yield* g4();\n}\n\nvar iterator = g5();\n\nconsole.log(iterator.next()); // {value: 1, done: false}\nconsole.log(iterator.next()); // {value: 2, done: false}\nconsole.log(iterator.next()); // {value: 3, done: false}\nconsole.log(iterator.next()); // {value: undefined, done: true}, \n // g4() returned {value: 'foo', done: true} at this point\n\nconsole.log(result); // \"foo\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Yield' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Yield' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n 27\n
| \nNo | \nYes | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n 27\n
| \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
SyntaxError: function* foo() {\n yield\n *[];\n} \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield*\n
The continue statement terminates execution of the statements in the current iteration of the current or labeled loop, and continues execution of the loop with the next iteration.
continue [label];
labelIn contrast to the break statement, continue does not terminate the execution of the loop entirely: instead,
while loop, it jumps back to the condition.for loop, it jumps to the update expression.The continue statement can include an optional label that allows the program to jump to the next iteration of a labeled loop statement instead of the current loop. In this case, the continue statement needs to be nested within this labeled statement.
The following example shows a while loop that has a continue statement that executes when the value of i is 3. Thus, n takes on the values 1, 3, 7, and 12.
var i = 0;\nvar n = 0;\n\nwhile (i < 5) {\n i++;\n\n if (i === 3) {\n continue;\n }\n\n n += i;\n}\n In the following example, a statement labeled checkiandj contains a statement labeled checkj. If continue is encountered, the program continues at the top of the checkj statement. Each time continue is encountered, checkj reiterates until its condition returns false. When false is returned, the remainder of the checkiandj statement is completed.
If continue had a label of checkiandj, the program would continue at the top of the checkiandj statement.
See also label.
var i = 0;\nvar j = 8;\n\ncheckiandj: while (i < 4) {\n console.log('i: ' + i);\n i += 1;\n\n checkj: while (j > 4) {\n console.log('j: ' + j);\n j -= 1;\n\n if ((j % 2) == 0)\n continue checkj;\n console.log(j + ' is odd.');\n }\n console.log('i = ' + i);\n console.log('j = ' + j);\n}\n Output:
i: 0\n\n// start checkj\nj: 8\n7 is odd.\nj: 7\nj: 6\n5 is odd.\nj: 5\n// end checkj\n\ni = 1 \nj = 4 \n\ni: 1\ni = 2 \nj = 4\n\ni: 2\ni = 3\nj = 4\n\ni: 3\ni = 4\nj = 4\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Unlabeled version. |
| ECMAScript 3rd Edition (ECMA-262) | Standard | Labeled version added. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Continue statement' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Continue statement' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Continue statement' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/continue\n
The async function declaration defines an asynchronous function, which returns an AsyncFunction object. An asynchronous function is a function which operates asynchronously via the event loop, using an implicit Promise to return its result. But the syntax and structure of your code using async functions is much more like using standard synchronous functions.
You can also define async functions using an async function expression.
async function name([param[, param[, ... param]]]) {\n statements\n}\n nameparamstatementsA Promise which will be resolved with the value returned by the async function, or rejected with an uncaught exception thrown from within the async function.
An async function can contain an await expression that pauses the execution of the async function and waits for the passed Promise's resolution, and then resumes the async function's execution and returns the resolved value.
Remember, the await keyword is only valid inside async functions. If you use it outside of an async function's body, you will get a SyntaxError.
The purpose of async/await functions is to simplify the behavior of using promises synchronously and to perform some behavior on a group of Promises. Just as Promises are similar to structured callbacks, async/await is similar to combining generators and promises.
var resolveAfter2Seconds = function() {\n console.log(\"starting slow promise\");\n return new Promise(resolve => {\n setTimeout(function() {\n resolve(20);\n console.log(\"slow promise is done\");\n }, 2000);\n });\n};\n\nvar resolveAfter1Second = function() {\n console.log(\"starting fast promise\");\n return new Promise(resolve => {\n setTimeout(function() {\n resolve(10);\n console.log(\"fast promise is done\");\n }, 1000);\n });\n};\n\nvar sequentialStart = async function() {\n console.log('==SEQUENTIAL START==');\n\n // If the value of the expression following the await operator is not a Promise, it's converted to a resolved Promise.\n const slow = await resolveAfter2Seconds();\n\n const fast = await resolveAfter1Second();\n console.log(slow);\n console.log(fast);\n}\n\nvar concurrentStart = async function() {\n console.log('==CONCURRENT START with await==');\n const slow = resolveAfter2Seconds(); // starts timer immediately\n const fast = resolveAfter1Second();\n\n console.log(await slow);\n console.log(await fast); // waits for slow to finish, even though fast is already done!\n}\n\nvar stillConcurrent = function() {\n console.log('==CONCURRENT START with Promise.all==');\n Promise.all([resolveAfter2Seconds(), resolveAfter1Second()]).then((messages) => {\n console.log(messages[0]); // slow\n console.log(messages[1]); // fast\n });\n}\n\nvar parallel = function() {\n console.log('==PARALLEL with Promise.then==');\n resolveAfter2Seconds().then((message)=>console.log(message));\n resolveAfter1Second().then((message)=>console.log(message));\n}\n\nsequentialStart(); // after 2 seconds, logs \"slow\", then after 1 more second, \"fast\"\n// wait above to finish\nsetTimeout(concurrentStart, 4000); // after 2 seconds, logs \"slow\" and then \"fast\"\n// wait again\nsetTimeout(stillConcurrent, 7000); // same as concurrentStart\n// wait again\nsetTimeout(parallel, 10000); // trully parallel: after 1 second, logs \"fast\", then after 1 more second, \"slow\"\n await for Promise#then\nIn sequentialStart, execution suspends 2 seconds for the first await, and then again another 1 second for the second await. The second timer is not created until the first has already fired.
In concurrentStart, both timers are created and then awaited. The timers are running concurrently but the await calls are still running in series, meaning the second await will wait for the first one to finish. This leads the code to finish in 2 rather than 3 seconds, which is the time the slowest timer needs. The same happens in stillConcurrent using Promise.all this time.
If you wish to await two or more promises in parallel, you must still use Promise#then, as parallel does in the example.
async functionAn API that returns a Promise will result in a promise chain, and it splits the function into many parts. Consider the following code:
function getProcessedData(url) {\n return downloadData(url) // returns a promise\n .catch(e => {\n return downloadFallbackData(url) // returns a promise\n })\n .then(v => {\n return processDataInWorker(v); // returns a promise\n });\n}\n it can be rewritten with a single async function as follows:
async function getProcessedData(url) {\n let v;\n try {\n v = await downloadData(url); \n } catch(e) {\n v = await downloadFallbackData(url);\n }\n return processDataInWorker(v);\n}\n Note that in the above example, there is no await statement on the return statement, because the return value of an async function is implicitly wrapped in Promise.resolve.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'async function' in that specification. | Draft | Initial definition in ES2017. |
| ECMAScript 2017 (ECMA-262) The definition of 'async function' in that specification. | Standard |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n55 | \nYes | \n52 | \nNo | \n42 | \n10.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n55 | \nYes | \n52 | \n42 | \n10.1 | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 7.6.0\n
| \n
async function expressionAsyncFunction objectawait\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function\n
The JavaScript delete removes a property from an object; if no more references to the same property are held, it is eventually released automatically.
delete expression
where expression should evaluate to a property reference, e.g.:
delete object.property\ndelete object['property']\n
objectpropertytrue for all cases except when the property is an own non-configurable property, in which case, false is returned in non-strict mode.
Throws Global_objects/SyntaxError in strict mode if the property is an own non-configurable property.
Unlike what common belief suggests, the delete operator has nothing to do with directly freeing memory. Memory management is done indirectly via breaking references. See the memory management page for more details.
The delete operator removes a given property from an object. On successful deletion, it will return true, else false will be returned. However, it is important to consider the following scenarios:
delete will not have any effect and will return true\ndelete only has an effect on own properties).var cannot be deleted from the global scope or from a function's scope. delete cannot delete any functions in the global scope (whether this is part from a function definition or a function expression).delete.let or const cannot be deleted from the scope within which they were defined.Math, Array, Object and properties that are created as non-configurable with methods like Object.defineProperty().The following snippet gives a simple example:
var Employee = {\n age: 28,\n name: 'abc',\n designation: 'developer'\n}\n\nconsole.log(delete Employee.name); // returns true\nconsole.log(delete Employee.age); // returns true\n\n// When trying to delete a property that does \n// not exist, true is returned \nconsole.log(delete Employee.salary); // returns true\n When a property is marked as non-configurable, delete won't have any effect, and will return false. In strict mode this will raise a SyntaxError.
var Employee = {};\nObject.defineProperty(Employee, 'name', {configurable: false});\n\nconsole.log(delete Employee.name); // returns false\n var, let and const create non-configurable properties that cannot be deleted with the delete operator:
var nameOther = 'XYZ';\n\n// We can access this global property using:\nObject.getOwnPropertyDescriptor(window, 'nameOther'); \n\n// output: Object {value: \"XYZ\", \n// writable: true, \n// enumerable: true,\n// configurable: false}\n\n// Since \"nameOther\" is added using with the\n// var keyword, it is marked as \"non-configurable\"\n\ndelete nameOther; // return false In strict mode, this would have raised an exception.
When in strict mode, if delete is used on a direct reference to a variable, a function argument or a function name, it will throw a SyntaxError.
Any variable defined with var is marked as non-configurable. In the following example, salary is non-configurable and cannot be deleted. In non-strict mode, the delete operation will return false.
function Employee() { \n delete salary;\n var salary;\n}\n\nEmployee();\n Let's see how the same code behaves in strict mode. Instead of returning false, the statement raises a SyntaxError.
\"use strict\";\n\nfunction Employee() {\n delete salary; // SyntaxError\n var salary; \n}\n\n// Similarly, any direct access to a function\n// with delete will raise a SyntaxError\n\nfunction DemoFunction() {\n //some code\n}\n\ndelete DemoFunction; // SyntaxError\n // Creates the property adminName on the global scope.\nadminName = 'xyz'; \n\n// Creates the property empCount on the global scope.\n// Since we are using var, this is marked as non-configurable. The same is true of let and const.\nvar empCount = 43;\n\nEmployeeDetails = {\n name: 'xyz',\n age: 5,\n designation: 'Developer'\n};\n\n// adminName is a property of the global scope.\n// It can be deleted since it is created without var,\n// and is therefore configurable.\ndelete adminName; // returns true\n\n// On the contrary, empCount is not configurable\n// since var was used.\ndelete empCount; // returns false \n\n// delete can be used to remove properties from objects.\ndelete EmployeeDetails.name; // returns true \n\n// Even when the property does not exist, delete returns \"true\".\ndelete EmployeeDetails.salary; // returns true \n\n// delete does not affect built-in static properties.\ndelete Math.PI; // returns false \n\n// EmployeeDetails is a property of the global scope.\n// Since it was defined without \"var\", it is marked configurable.\ndelete EmployeeDetails; // returns true\n\nfunction f() {\n var z = 44;\n\n // delete doesn't affect local variable names\n delete z; // returns false\n}\n delete and the prototype chainIn the following example, we delete an own property of an object while a property with the same name is available on the prototype chain:
function Foo() {\n this.bar = 10;\n}\n\nFoo.prototype.bar = 42;\n\nvar foo = new Foo();\n\n// foo.bar is associated with the \n// own property. \nconsole.log(foo.bar); // 10 \n\n// Delete the own property within the \n// foo object. \ndelete foo.bar; // returns true \n\n// foo.bar is still available in the \n// prototype chain. \nconsole.log(foo.bar); // 42 \n\n// Delete the property on the prototype.\ndelete Foo.prototype.bar; // returns true \n\n// The \"bar\" property can no longer be \n// inherited from Foo since it has been \n// deleted. \nconsole.log(foo.bar); // undefined When you delete an array element, the array length is not affected. This holds even if you delete the last element of the array.
When the delete operator removes an array element, that element is no longer in the array. In the following example, trees[3] is removed with delete.
var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];\ndelete trees[3];\nif (3 in trees) {\n // this is not executed\n} If you want an array element to exist but have an undefined value, use the undefined value instead of the delete operator. In the following example, trees[3] is assigned the value undefined, but the array element still exists:
var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];\ntrees[3] = undefined;\nif (3 in trees) {\n // this is executed\n} If instead, you want to remove an array element by changing the contents of the array, use the splicetrees[3] is removed from the array completely using splice
var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];\ntrees.splice(3,1);\nconsole.log(trees); // [\"redwood\", \"bay\", \"cedar\", \"maple\"]\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'The delete Operator' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'The delete Operator' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'The delete Operator' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'The delete Operator' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.2. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Temporal dead zone | \n? | \n? | \n36 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Temporal dead zone | \n? | \n? | \n? | \n36 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Temporal dead zone | \n? | \n
Although ECMAScript makes iteration order of objects implementation-dependent, it may appear that all major browsers support an iteration order based on the earliest added property coming first (at least for properties not on the prototype). However, in the case of Internet Explorer, when one uses delete on a property, some confusing behavior results, preventing other browsers from using simple objects like object literals as ordered associative arrays. In Explorer, while the property value is indeed set to undefined, if one later adds back a property with the same name, the property will be iterated in its old position--not at the end of the iteration sequence as one might expect after having deleted the property and then added it back.
If you want to use an ordered associative array in a cross-browser environment, use a Map object if available, or simulate this structure with two separate arrays (one for the keys and the other for the values), or build an array of single-property objects, etc.
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete\n
The String global object is a constructor for strings or a sequence of characters.
String literals take the forms:
'string text'\n\"string text\"\n\"中文 español Deutsch English देवनागरी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ் עברית\"
Strings can also be created using the String global object directly:
String(thing)
thingStarting with ECMAScript 2015, string literals can also be so-called Template literals:
`hello world`\n`hello!\n world!`\n`hello ${who}`\ntag `<a>${who}</a>` Besides regular, printable characters, special characters can be encoded using escape notation:
| Code | Output |
|---|---|
\\XXX | an octal Latin-1 character. |
\\' | single quote |
\\\" | double quote |
\\\\ | backslash |
\\n | new line |
\\r | carriage return |
\\v | vertical tab |
\\t | tab |
\\b | backspace |
\\f | form feed |
\\uXXXX | unicode codepoint |
\n\\u{X} ... \\u{XXXXXX}\n | unicode codepoint \n |
\\xXX | the Latin-1 character |
Unlike some other languages, JavaScript makes no distinction between single-quoted strings and double-quoted strings; therefore, the escape sequences above work in strings created with either single or double quotes.
Sometimes, your code will include strings which are very long. Rather than having lines that go on endlessly, or wrap at the whim of your editor, you may wish to specifically break the string into multiple lines in the source code without affecting the actual string contents. There are two ways you can do this.
You can use the + operator to append multiple strings together, like this:
let longString = \"This is a very long string which needs \" +\n \"to wrap across multiple lines because \" +\n \"otherwise my code is unreadable.\";\n
Or you can use the backslash character (\"\\\") at the end of each line to indicate that the string will continue on the next line. Make sure there is no space or any other character after the backslash (except for a line break), or as an indent; otherwise it will not work. That form looks like this:
let longString = \"This is a very long string which needs \\\nto wrap across multiple lines because \\\notherwise my code is unreadable.\";\n
Both of these result in identical strings being created.
Strings are useful for holding data that can be represented in text form. Some of the most-used operations on strings are to check their length, to build and concatenate them using the + and += string operators, checking for the existence or location of substrings with the indexOf() method, or extracting substrings with the substring() method.
There are two ways to access an individual character in a string. The first is the charAt() method:
return 'cat'.charAt(1); // returns \"a\"\n
The other way (introduced in ECMAScript 5) is to treat the string as an array-like object, where individual characters correspond to a numerical index:
return 'cat'[1]; // returns \"a\"\n
For character access using bracket notation, attempting to delete or assign a value to these properties will not succeed. The properties involved are neither writable nor configurable. (See Object.defineProperty() for more information.)
C developers have the strcmp() function for comparing strings. In JavaScript, you just use the less-than and greater-than operators:
var a = 'a';\nvar b = 'b';\nif (a < b) { // true\n console.log(a + ' is less than ' + b);\n} else if (a > b) {\n console.log(a + ' is greater than ' + b);\n} else {\n console.log(a + ' and ' + b + ' are equal.');\n}\n A similar result can be achieved using the localeCompare() method inherited by String instances.
String objectsNote that JavaScript distinguishes between String objects and primitive string values. (The same is true of Boolean and Numbers.)
String literals (denoted by double or single quotes) and strings returned from String calls in a non-constructor context (i.e., without using the new keyword) are primitive strings. JavaScript automatically converts primitives to String objects, so that it's possible to use String object methods for primitive strings. In contexts where a method is to be invoked on a primitive string or a property lookup occurs, JavaScript will automatically wrap the string primitive and call the method or perform the property lookup.
var s_prim = 'foo';\nvar s_obj = new String(s_prim);\n\nconsole.log(typeof s_prim); // Logs \"string\"\nconsole.log(typeof s_obj); // Logs \"object\"\n
String primitives and String objects also give different results when using eval(). Primitives passed to eval are treated as source code; String objects are treated as all other objects are, by returning the object. For example:
var s1 = '2 + 2'; // creates a string primitive\nvar s2 = new String('2 + 2'); // creates a String object\nconsole.log(eval(s1)); // returns the number 4\nconsole.log(eval(s2)); // returns the string \"2 + 2\"\n For these reasons, the code may break when it encounters String objects when it expects a primitive string instead, although generally, authors need not worry about the distinction.
A String object can always be converted to its primitive counterpart with the valueOf() method.
console.log(eval(s2.valueOf())); // returns the number 4\n
StringView — a C-like representation of strings based on typed arrays.String.prototypeString object.String.fromCharCode()String.fromCodePoint()String.raw() \nString generic methodsString generics are non-standard, deprecated and will get removed in the near future.
The String instance methods are also available in Firefox as of JavaScript 1.6 (not part of the ECMAScript standard) on the String object for applying String methods to any object:
var num = 15;\nconsole.log(String.replace(num, \"5\", \"2\"));\n
For migrating away from String generics, see also Warning: String.x is deprecated; use String.prototype.x instead.
Generics are also available on Array methods.
String instancesString.prototype.constructorString.prototype.lengthNlength. These properties are read-only.String.prototype.charAt()String.prototype.charCodeAt()String.prototype.codePointAt()String.prototype.concat()String.prototype.includes()String.prototype.endsWith()String.prototype.indexOf()String object of the first occurrence of the specified value, or -1 if not found.String.prototype.lastIndexOf()String object of the last occurrence of the specified value, or -1 if not found.String.prototype.localeCompare()String.prototype.match()String.prototype.normalize()String.prototype.padEnd()String.prototype.padStart()String.prototype.quote() \"\").String.prototype.repeat()String.prototype.replace()String.prototype.search()String.prototype.slice()String.prototype.split()String object into an array of strings by separating the string into substrings.String.prototype.startsWith()String.prototype.substr() \nString.prototype.substring()String.prototype.toLocaleLowerCase()toLowerCase().String.prototype.toLocaleUpperCase()toUpperCase().String.prototype.toLowerCase()String.prototype.toSource() \nObject.prototype.toSource() method.String.prototype.toString()Object.prototype.toString() method.String.prototype.toUpperCase()String.prototype.trim()String.prototype.trimStart()String.prototype.trimLeft()\nString.prototype.trimEnd()String.prototype.trimRight()\nString.prototype.valueOf()Object.prototype.valueOf() method.String.prototype[@@iterator]()Iterator object that iterates over the code points of a String value, returning each code point as a String value.These methods are of limited use, as they provide only a subset of the available HTML tags and attributes.
String.prototype.anchor() \n<a name=\"name\"> (hypertext target)String.prototype.big() \n<big>String.prototype.blink() \n<blink>String.prototype.bold() \n<b>String.prototype.fixed() \n<tt>String.prototype.fontcolor() \n<font color=\"color\">String.prototype.fontsize() \n<font size=\"size\">String.prototype.italics() \n<i>String.prototype.link() \n<a href=\"url\"> (link to URL)String.prototype.small() \n<small>String.prototype.strike() \n<strike>String.prototype.sub() \n<sub>String.prototype.sup() \n<sup>It's possible to use String as a more reliable toString() alternative, as it works when used on null, undefined, and on symbols. For example:
var outputStrings = [];\nfor (var i = 0, n = inputValues.length; i < n; ++i) {\n outputStrings.push(String(inputValues[i]));\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
@@iterator | \nYes | \nYes | \n 36\n
| \nNo | \nNo | \nNo | \n
| Unicode code point escapes \\u{xxxxxx} | \nYes | \n? | \n40 | \n? | \nYes | \nYes | \n
\nanchor \n | \nYes | \nYes | \n 1\n
| \nNo | \nYes | \nYes | \n
\nbig \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nblink \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nbold \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
charAt | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
charCodeAt | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
codePointAt | \n41 | \nYes | \n29 | \nNo | \n28 | \n10 | \n
concat | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
endsWith | \n41 | \nYes | \n17 | \nNo | \n28 | \n9 | \n
\nfixed \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nfontcolor \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nfontsize \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
fromCharCode | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
fromCodePoint | \n41 | \nYes | \n29 | \nNo | \n28 | \n10 | \n
includes | \n41 | \nYes | \n 40\n
| \nNo | \nYes | \n9 | \n
indexOf | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nitalics \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
lastIndexOf | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
length | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nlink \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
localeCompare | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
localeCompare.locales | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
localeCompare.options | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
match | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nmatch.flags \n | \nNo | \nNo | \n1 — 49 | \nNo | \nNo | \nNo | \n
normalize | \n34 | \nYes | \n31 | \nNo | \nYes | \n10 | \n
padEnd | \n57 | \n15 | \n48 | \nNo | \n44 | \n10 | \n
padStart | \n57 | \n15 | \n48 | \nNo | \n44 | \n10 | \n
prototype | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nquote \n | \nNo | \nNo | \n1 — 37 | \nNo | \nNo | \nNo | \n
raw | \n41 | \nYes | \n34 | \nNo | \nNo | \n10 | \n
repeat | \n41 | \nYes | \n24 | \nNo | \nYes | \n9 | \n
replace | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nreplace.flags \n | \nNo | \nNo | \n1 — 49 | \nNo | \nNo | \nNo | \n
search | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nsearch.flags \n | \nNo | \nNo | \n1 — 49 | \nNo | \nNo | \nNo | \n
slice | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nsmall \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
split | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
startsWith | \n41 | \nYes | \n17 | \nNo | \n28 | \n9 | \n
\nstrike \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nsub \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nsubstr \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
substring | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nsup \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toLocaleLowerCase | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toLocaleLowerCase.locale | \n? | \n? | \n55 | \n? | \n? | \n? | \n
toLocaleUpperCase | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toLocaleUpperCase.locale | \n? | \n? | \n55 | \n? | \n? | \n? | \n
toLowerCase | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \n1 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
toUpperCase | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
trim | \nYes | \nYes | \n3.5 | \n9 | \n10.5 | \n5 | \n
trimEnd | \n 66\n
| \n? | \n 61\n
| \nNo | \n53 | \n? | \n
trimStart | \n 66\n
| \n? | \n 61\n
| \nNo | \n53 | \n? | \n
valueOf | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
@@iterator | \nNo | \nNo | \n? | \n 36\n
| \nNo | \nNo | \nNo | \n
| Unicode code point escapes \\u{xxxxxx} | \nYes | \nYes | \n? | \n40 | \nYes | \nYes | \nYes | \n
\nanchor \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nbig \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nblink \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nbold \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
charAt | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
charCodeAt | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
codePointAt | \nYes | \nYes | \nYes | \n29 | \nYes | \n10 | \nYes | \n
concat | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
endsWith | \nYes | \n36 | \nYes | \n17 | \nYes | \n9 | \nYes | \n
\nfixed \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nfontcolor \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nfontsize \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
fromCharCode | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
fromCodePoint | \nYes | \nYes | \nYes | \n29 | \nYes | \n10 | \nYes | \n
includes | \nYes | \nYes | \nYes | \n 40\n
| \nYes | \n9 | \nYes | \n
indexOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nitalics \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
lastIndexOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
length | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nlink \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
localeCompare | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
localeCompare.locales | \nNo | \n26 | \n? | \nNo | \nNo | \n10 | \nYes | \n
localeCompare.options | \nNo | \n26 | \n? | \nNo | \nNo | \n10 | \nYes | \n
match | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nmatch.flags \n | \nNo | \nNo | \nNo | \n4 — 49 | \nNo | \nNo | \nNo | \n
normalize | \nNo | \n34 | \nYes | \n31 | \nYes | \n10 | \nYes | \n
padEnd | \n57 | \n57 | \nYes | \n48 | \n44 | \n10 | \n7.0 | \n
padStart | \n57 | \n57 | \nYes | \n48 | \n44 | \n10 | \n7.0 | \n
prototype | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nquote \n | \nNo | \nNo | \nNo | \n4 — 37 | \nNo | \nNo | \nNo | \n
raw | \nNo | \n41 | \nYes | \n34 | \nNo | \n10 | \n4.0 | \n
repeat | \nNo | \n36 | \nYes | \n24 | \nYes | \n9 | \nYes | \n
replace | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nreplace.flags \n | \nNo | \nNo | \nNo | \n4 — 49 | \nNo | \nNo | \nNo | \n
search | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nsearch.flags \n | \nNo | \nNo | \nNo | \n4 — 49 | \nNo | \nNo | \nNo | \n
slice | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nsmall \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
split | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
startsWith | \nYes | \n36 | \nYes | \n17 | \nYes | \n9 | \nYes | \n
\nstrike \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nsub \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nsubstr \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
substring | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nsup \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toLocaleLowerCase | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toLocaleLowerCase.locale | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
toLocaleUpperCase | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toLocaleUpperCase.locale | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
toLowerCase | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ntoSource \n | \nNo | \nNo | \nNo | \n4 | \nNo | \nNo | \nNo | \n
toString | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
toUpperCase | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
trim | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
trimEnd | \n 66\n
| \n 66\n
| \n? | \n 61\n
| \n53 | \n? | \n? | \n
trimStart | \n 66\n
| \n 66\n
| \n? | \n 61\n
| \n53 | \n? | \n? | \n
valueOf | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
@@iterator | \n0.12 | \n
| Unicode code point escapes \\u{xxxxxx} | \nYes | \n
\nanchor \n | \nYes | \n
\nbig \n | \nYes | \n
\nblink \n | \nYes | \n
\nbold \n | \nYes | \n
charAt | \nYes | \n
charCodeAt | \nYes | \n
codePointAt | \n 4.0.0\n
| \n
concat | \nYes | \n
endsWith | \n 4.0.0\n
| \n
\nfixed \n | \nYes | \n
\nfontcolor \n | \nYes | \n
\nfontsize \n | \nYes | \n
fromCharCode | \nYes | \n
fromCodePoint | \n 4.0.0\n
| \n
includes | \n4.0.0 | \n
indexOf | \nYes | \n
\nitalics \n | \nYes | \n
lastIndexOf | \nYes | \n
length | \nYes | \n
\nlink \n | \nYes | \n
localeCompare | \nYes | \n
localeCompare.locales | \n? | \n
localeCompare.options | \n? | \n
match | \nYes | \n
\nmatch.flags \n | \nNo | \n
normalize | \n0.12 | \n
padEnd | \n 8.0.0\n
| \n
padStart | \n 8.0.0\n
| \n
prototype | \nYes | \n
\nquote \n | \nNo | \n
raw | \n4.0.0 | \n
repeat | \n 4.0.0\n
| \n
replace | \nYes | \n
\nreplace.flags \n | \nNo | \n
search | \nYes | \n
\nsearch.flags \n | \nNo | \n
slice | \nYes | \n
\nsmall \n | \nYes | \n
split | \nYes | \n
startsWith | \n 4.0.0\n
| \n
\nstrike \n | \nYes | \n
\nsub \n | \nYes | \n
\nsubstr \n | \nYes | \n
substring | \nYes | \n
\nsup \n | \nYes | \n
toLocaleLowerCase | \nYes | \n
toLocaleLowerCase.locale | \n? | \n
toLocaleUpperCase | \nYes | \n
toLocaleUpperCase.locale | \n? | \n
toLowerCase | \nYes | \n
\ntoSource \n | \nNo | \n
toString | \nYes | \n
toUpperCase | \nYes | \n
trim | \nYes | \n
trimEnd | \n10.0.0 | \n
trimStart | \n10.0.0 | \n
valueOf | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String\n
A this behaves a little differently in JavaScript compared to other languages. It also has some differences between strict mode and non-strict mode.
In most cases, the value of this is determined by how a function is called. It can't be set by assignment during execution, and it may be different each time the function is called. ES5 introduced the bind() method to set the value of a function's this regardless of how it's called, and ES2015 introduced arrow functions which don't provide their own this binding (it retains the this value of the enclosing lexical context).
this
In the global execution context (outside of any function), this refers to the global object whether in strict mode or not.
// In web browsers, the window object is also the global object:\nconsole.log(this === window); // true\n\na = 37;\nconsole.log(window.a); // 37\n\nthis.b = \"MDN\";\nconsole.log(window.b) // \"MDN\"\nconsole.log(b) // \"MDN\"\n
Inside a function, the value of this depends on how the function is called.
Since the following code is not in strict mode, and because the value of this is not set by the call, this will default to the global object, which is window in a browser.
function f1() {\n return this;\n}\n\n// In a browser:\nf1() === window; // true \n\n// In Node:\nf1() === global; // true In strict mode, however, the value of this remains at whatever it was set to when entering the execution context, so, in the following case, thiswill default to undefined:
function f2() {\n 'use strict'; // see strict mode\n return this;\n}\n\nf2() === undefined; // true\n So, in strict mode, if this was not defined by the execution context, it remains undefined.
this should be undefined, because f2 was called directly and not as a method or property of an object (e.g. window.f2()). This feature wasn't implemented in some browsers when they first started to support strict mode. As a result, they incorrectly returned the window object.To pass the value of this from one context to another, use call(), or apply():
// An object can be passed as the first argument to call or apply and this will be bound to it.\nvar obj = {a: 'Custom'};\n\n// This property is set on the global object\nvar a = 'Global';\n\nfunction whatsThis() {\n return this.a; // The value of this is dependent on how the function is called\n}\n\nwhatsThis(); // 'Global'\nwhatsThis.call(obj); // 'Custom'\nwhatsThis.apply(obj); // 'Custom'\n Where a function uses the this keyword in its body, its value can be bound to a particular object in the call using the call() or apply() methods which all functions inherit from Function.prototype.
function add(c, d) {\n return this.a + this.b + c + d;\n}\n\nvar o = {a: 1, b: 3};\n\n// The first parameter is the object to use as\n// 'this', subsequent parameters are passed as \n// arguments in the function call\nadd.call(o, 5, 7); // 16\n\n// The first parameter is the object to use as\n// 'this', the second is an array whose\n// members are used as the arguments in the function call\nadd.apply(o, [10, 20]); // 34\n Note that with call and apply, if the value passed as this is not an object, an attempt will be made to convert it to an object using the internal ToObject operation. So if the value passed is a primitive like 7 or 'foo', it will be converted to an Object using the related constructor, so the primitive number 7 is converted to an object as if by new Number(7) and the string 'foo' to an object as if by new String('foo'), e.g.
function bar() {\n console.log(Object.prototype.toString.call(this));\n}\n\nbar.call(7); // [object Number]\nbar.call('foo'); // [object String]\n bind methodECMAScript 5 introduced Function.prototype.bind(). Calling f.bind(someObject) creates a new function with the same body and scope as f, but where this occurs in the original function, in the new function it is permanently bound to the first argument of bind, regardless of how the function is being used.
function f() {\n return this.a;\n}\n\nvar g = f.bind({a: 'azerty'});\nconsole.log(g()); // azerty\n\nvar h = g.bind({a: 'yoo'}); // bind only works once!\nconsole.log(h()); // azerty\n\nvar o = {a: 37, f: f, g: g, h: h};\nconsole.log(o.a, o.f(), o.g(), o.h()); // 37,37, azerty, azerty\n In arrow functions, this retains the value of the enclosing lexical context's this. In global code, it will be set to the global object:
var globalObject = this;\nvar foo = (() => this);\nconsole.log(foo() === globalObject); // true
Note: if this arg is passed to call, bind, or apply on invocation of an arrow function it will be ignored. You can still prepend arguments to the call, but the first argument (thisArg) should be set to null.
// Call as a method of an object\nvar obj = {func: foo};\nconsole.log(obj.func() === globalObject); // true\n\n// Attempt to set this using call\nconsole.log(foo.call(obj) === globalObject); // true\n\n// Attempt to set this using bind\nfoo = foo.bind(obj);\nconsole.log(foo() === globalObject); // true No matter what, foo's this is set to what it was when it was created (in the example above, the global object). The same applies to arrow functions created inside other functions: their this remains that of the enclosing lexical context.
// Create obj with a method bar that returns a function that\n// returns its this. The returned function is created as \n// an arrow function, so its this is permanently bound to the\n// this of its enclosing function. The value of bar can be set\n// in the call, which in turn sets the value of the \n// returned function.\nvar obj = {\n bar: function() {\n var x = (() => this);\n return x;\n }\n};\n\n// Call bar as a method of obj, setting its this to obj\n// Assign a reference to the returned function to fn\nvar fn = obj.bar();\n\n// Call fn without setting this, would normally default\n// to the global object or undefined in strict mode\nconsole.log(fn() === obj); // true\n\n// But caution if you reference the method of obj without calling it\nvar fn2 = obj.bar;\n// Then calling the arrow function this is equals to window because it follows the this from bar.\nconsole.log(fn2()() == window); // true\n In the above, the function(call it anonymous function A) assigned to obj.bar returns another function(call it anonymous function B) that is created as an arrow function. As a result, function B's this is permanently set to the this of obj.bar (function A)when called. When the returned function(function B) is called, its this will always be what it was set to initially. In the above code example, function B's this is set to function A's this which is obj, so it remains set to obj even when called in a manner that would normally set its this to undefined or the global object (or any other method as in the previous example in the global execution context).
When a function is called as a method of an object, its this is set to the object the method is called on.
In the following example, when o.f() is invoked, inside the function this is bound to the o object.
var o = {\n prop: 37,\n f: function() {\n return this.prop;\n }\n};\n\nconsole.log(o.f()); // 37\n Note that this behavior is not at all affected by how or where the function was defined. In the previous example, we defined the function inline as the f member during the definition of o. However, we could have just as easily defined the function first and later attached it to o.f. Doing so results in the same behavior:
var o = {prop: 37};\n\nfunction independent() {\n return this.prop;\n}\n\no.f = independent;\n\nconsole.log(o.f()); // 37\n This demonstrates that it matters only that the function was invoked from the f member of o.
Similarly, the this binding is only affected by the most immediate member reference. In the following example, when we invoke the function, we call it as a method g of the object o.b. This time during execution, this inside the function will refer to o.b. The fact that the object is itself a member of o has no consequence; the most immediate reference is all that matters.
o.b = {g: independent, prop: 42};\nconsole.log(o.b.g()); // 42\n this on the object's prototype chainThe same notion holds true for methods defined somewhere on the object's prototype chain. If the method is on an object's prototype chain, this refers to the object the method was called on, as if the method were on the object.
var o = {f: function() { return this.a + this.b; }};\nvar p = Object.create(o);\np.a = 1;\np.b = 4;\n\nconsole.log(p.f()); // 5\n In this example, the object assigned to the variable p doesn't have its own f property, it inherits it from its prototype. But it doesn't matter that the lookup for f eventually finds a member with that name on o; the lookup began as a reference to p.f, so this inside the function takes the value of the object referred to as p. That is, since f is called as a method of p, its this refers to p. This is an interesting feature of JavaScript's prototype inheritance.
this with a getter or setterAgain, the same notion holds true when a function is invoked from a getter or a setter. A function used as getter or setter has its this bound to the object from which the property is being set or gotten.
function sum() {\n return this.a + this.b + this.c;\n}\n\nvar o = {\n a: 1,\n b: 2,\n c: 3,\n get average() {\n return (this.a + this.b + this.c) / 3;\n }\n};\n\nObject.defineProperty(o, 'sum', {\n get: sum, enumerable: true, configurable: true});\n\nconsole.log(o.average, o.sum); // 2, 6\n When a function is used as a constructor (with the new keyword), its this is bound to the new object being constructed.
While the default for a constructor is to return the object referenced by this, it can instead return some other object (if the return value isn't an object, then the this object is returned).
/*\n * Constructors work like this:\n *\n * function MyConstructor(){\n * // Actual function body code goes here. \n * // Create properties on |this| as\n * // desired by assigning to them. E.g.,\n * this.fum = \"nom\";\n * // et cetera...\n *\n * // If the function has a return statement that\n * // returns an object, that object will be the\n * // result of the |new| expression. Otherwise,\n * // the result of the expression is the object\n * // currently bound to |this|\n * // (i.e., the common case most usually seen).\n * }\n */\n\nfunction C() {\n this.a = 37;\n}\n\nvar o = new C();\nconsole.log(o.a); // 37\n\n\nfunction C2() {\n this.a = 37;\n return {a: 38};\n}\n\no = new C2();\nconsole.log(o.a); // 38\n In the last example (C2), because an object was returned during construction, the new object that this was bound to simply gets discarded. (This essentially makes the statement \"this.a = 37;\" dead code. It's not exactly dead because it gets executed, but it can be eliminated with no outside effects.)
When a function is used as an event handler, its this is set to the element the event fired from (some browsers do not follow this convention for listeners added dynamically with methods other than addEventListener()).
// When called as a listener, turns the related element blue\nfunction bluify(e) {\n // Always true\n console.log(this === e.currentTarget); \n // true when currentTarget and target are the same object\n console.log(this === e.target);\n this.style.backgroundColor = '#A5D9F3';\n}\n\n// Get a list of every element in the document\nvar elements = document.getElementsByTagName('*');\n\n// Add bluify as a click listener so when the\n// element is clicked on, it turns blue\nfor (var i = 0; i < elements.length; i++) {\n elements[i].addEventListener('click', bluify, false);\n} When the code is called from an inline on-event handler, its this is set to the DOM element on which the listener is placed:
<button onclick=\"alert(this.tagName.toLowerCase());\">\n Show this\n</button>\n
The above alert shows button. Note however that only the outer code has its this set this way:
<button onclick=\"alert((function() { return this; })());\">\n Show inner this\n</button>\n In this case, the inner function's this isn't set so it returns the global/window object (i.e. the default object in non–strict mode where this isn't set by the call).
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'The this keyword' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'The this keyword' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'The this keyword' in that specification. | Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'The this keyword' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'The this keyword' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this\n
An empty statement is used to provide no statement, although the JavaScript syntax would expect one.
;\n
The empty statement is a semicolon (;) indicating that no statement will be executed, even if JavaScript syntax requires one. The opposite behavior, where you want multiple statements, but JavaScript only allows a single one, is possible using a block statement; it combines several statements into a single one.
The empty statement is sometimes used with loop statements. See the following example with an empty loop body:
var arr = [1, 2, 3];\n\n// Assign all array values to 0\nfor (i = 0; i < arr.length; arr[i++] = 0) /* empty statement */ ;\n\nconsole.log(arr)\n// [0, 0, 0]\n
Note: It is a good idea to comment the intentional use of the empty statement, as it is not really obvious to distinguish between a normal semicolon. In the following example the usage is probably not intentional:
if (condition); // Caution, this \"if\" does nothing!\n killTheUniverse() // So this always gets executed!!!\n
Another Example: An if...else statement without curly braces ({}). If three is true, nothing will happen, four does not matter, and also the launchRocket() function in the else case will not be executed.
if (one)\n doOne();\nelse if (two)\n doTwo();\nelse if (three)\n ; // nothing here\nelse if (four)\n doFour();\nelse\n launchRocket();
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/Empty\n
The class declaration creates a new class with a given name using prototype-based inheritance.
You can also define a class using a class expression. But unlike the class expression, the class declaration doesn't allow an existing class to be declared again and will throw a type error if attempted.
class name [extends] {\n // class body\n}\n The class body of a class declaration is executed in strict mode. The constructor property is optional.
Class declarations are not hoisted (unlike function declarations).
In the following example, we first define a class named Polygon, then extend it to create a class named Square. Note that super(), used in the constructor, can only be used in constructors and must be called before the this keyword can be used.
class Polygon {\n constructor(height, width) {\n this.name = 'Polygon';\n this.height = height;\n this.width = width;\n }\n}\n\nclass Square extends Polygon {\n constructor(length) {\n super(length, length);\n this.name = 'Square';\n }\n} Re-declaring a class using the class declaration throws a type error.
class Foo {};\nclass Foo {}; // Uncaught TypeError: Identifier 'Foo' has already been declared\n The same error is thrown when a class has been defined before using the class expression.
var Foo = class {};\nclass Foo {}; // Uncaught TypeError: Identifier 'Foo' has already been declared\n\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n42 | \nYes | \n45 | \nNo | \n? | \n10.1 | \n
| Array subclassing | \n43 | \n? | \n? | \nNo | \n? | \n? | \n
| Allowed in sloppy mode | \n49 | \n? | \n? | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n42 | \n42 | \nYes | \n45 | \n? | \n10.1 | \n4.0 | \n
| Array subclassing | \n43 | \n43 | \n? | \n? | \n? | \n? | \n4.0 | \n
| Allowed in sloppy mode | \n49 | \n49 | \n? | \n? | \n? | \n? | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
| Array subclassing | \n? | \n
| Allowed in sloppy mode | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/class\n
The default keyword can be used in two situations in JavaScript: within a switch statement, or with an export statement.
Within a switch statement:
switch (expression) {\n case value1:\n //Statements executed when the result of expression matches value1\n [break;]\n default:\n //Statements executed when none of the values match the value of the expression\n [break;]\n} With export statement:
export default nameN
For more details see the
default in switch statementsIn the following example, if expr evaluates to \"Oranges\" or \"Apples\", the program matches the values with either the case \"Oranges\" or \"Apples\" and executes the corresponding statement. The default keyword will help in any other case and executes the associated statement.
switch (expr) {\n case 'Oranges':\n console.log('Oranges are $0.59 a pound.');\n break;\n case 'Apples':\n console.log('Apples are $0.32 a pound.');\n break;\n default:\n console.log('Sorry, we are out of ' + expr + '.');\n} default with export\nIf you want to export a single value or need a fallback value for a module, a default export can be used:
// module \"my-module.js\"\nlet cube = function cube(x) {\n return x * x * x;\n};\nexport default cube; Then, in another script, it will be straightforward to import the default export:
// module \"my-module.js\"\nimport cube from 'my-module'; //default export gave us the liberty to say import cube, instead of import cube from 'my-module'\nconsole.log(cube(3)); // 27\n
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
\ndefault keyword in switch\n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\ndefault keyword with export\n | \n61 | \n 16\n
| \n 60\n
| \nNo | \n47 | \n10.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
\ndefault keyword in switch\n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ndefault keyword with export\n | \nNo | \n61 | \nYes | \n 60\n
| \n47 | \n10.1 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
\ndefault keyword in switch\n | \nYes | \n
\ndefault keyword with export\n | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/default\n
The debugger statement invokes any available debugging functionality, such as setting a breakpoint. If no debugging functionality is available, this statement has no effect.
debugger;
The following example shows code where a debugger statement has been inserted, to invoke a debugger (if one exists) when the function is called.
function potentiallyBuggyCode() {\n debugger;\n // do potentially buggy stuff to examine, step through, etc.\n} When the debugger is invoked, execution is paused at the debugger statement. It is like a breakpoint in the script source.
![\"Paused](\"https://mdn.mozillademos.org/files/6963/Screen%20Shot%202014-02-07%20at%209.14.35%20AM.png\")
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Debugger statement' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Debugger statement' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'Debugger statement' in that specification. | Standard | Initial definition |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'Debugger statement' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'Debugger statement' in that specification. | Standard | Only mentioned as reserved word. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/debugger\n
The export statement is used when creating JavaScript modules to export functions, objects, or primitive values from the module so they can be used by other programs with the import statement.
Exported modules are in strict mode whether you declare them as such or not. The export statement cannot be used in embedded scripts.
export { name1, name2, …, nameN };\nexport { variable1 as name1, variable2 as name2, …, nameN };\nexport let name1, name2, …, nameN; // also var, const\nexport let name1 = …, name2 = …, …, nameN; // also var, const\nexport function FunctionName(){...}\nexport class ClassName {...}\n\nexport default expression;\nexport default function (…) { … } // also class, function*\nexport default function name1(…) { … } // also class, function*\nexport { name1 as default, … };\n\nexport * from …;\nexport { name1, name2, …, nameN } from …;\nexport { import1 as name1, import2 as name2, …, nameN } from …;\nexport { default } from …; nameNimport in another script).There are two different types of export, named and default. You can have multiple named exports per module but only one default export. Each type corresponds to one of the above syntax:
// exports a function declared earlier\nexport { myFunction }; \n\n// exports a constant\nexport const foo = Math.sqrt(2); export default function() {} export default class {} Named exports are useful to export several values. During the import, it is mandatory to use the same name of the corresponding object.
But a default export can be imported with any name for example:
let k; export default k = 12; // in file test.js\n\nimport m from './test' // note that we have the freedom to use import m instead of import k, because k was default export\n\nconsole.log(m); // will log 12\n
The following syntax does not export a default export from the imported module:
export * from …;
If you need to export the default, write the following instead:
export {default} from 'mod';\n In the module, we could use the following code:
// module \"my-module.js\"\nfunction cube(x) {\n return x * x * x;\n}\nconst foo = Math.PI + Math.SQRT2;\nvar graph = {\n options:{\n color:'white',\n thickness:'2px'\n },\n draw: function(){\n console.log('From graph draw function');\n }\n}\nexport { cube, foo, graph };\n This way, in another script, we could have:
//You should use this script in html with the type module ,\n//eg ''<script type=\"module\" src=\"demo.js\"></script>\",\n//open the page in a httpserver,otherwise there will be a CORS policy error.\n//script demo.js\n\nimport { cube, foo, graph } from 'my-module';\ngraph.options = {\n color:'blue',\n thickness:'3px'\n}; \ngraph.draw();\nconsole.log(cube(3)); // 27\nconsole.log(foo); // 4.555806215962888 If we want to export a single value or to have a fallback value for our module, we could use a default export:
// module \"my-module.js\"\nexport default function cube(x) {\n return x * x * x;\n}\n Then, in another script, it will be straightforward to import the default export:
import cube from 'my-module';\nconsole.log(cube(3)); // 27\n
Note that it is not possible to use var, let or const with export default.
If we want to export default, and star from another module (effectively creating a \"redirect\"):
// module \"redirect-module.js\"\nexport {default} from './other-module';\nexport * from './other-module'; | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Exports' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Exports' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n61 | \n 16\n
| \n 60\n
| \nNo | \n47 | \n10.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n61 | \nYes | \n 60\n
| \n47 | \n10.1 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
import\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export\n
The do...while creates a loop that executes a specified statement until the test condition evaluates to false. The condition is evaluated after executing the statement, resulting in the specified statement executing at least once.
do\n statement\nwhile (condition);\n
statementblock statement ({ ... }) to group those statements.conditioncondition evaluates to true, the statement is re-executed. When condition evaluates to false, control passes to the statement following the do...while.do...while\nIn the following example, the do...while loop iterates at least once and reiterates until i is no longer less than 5.
<div id=\"example\"></div>
var result = '';\nvar i = 0;\ndo {\n i += 1;\n result += i + ' ';\n} while (i < 5);\ndocument.getElementById('example').innerHTML = result; | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2 |
| ECMAScript 5.1 (ECMA-262) The definition of 'do-while statement' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'do-while statement' in that specification. | Standard | Trailing ; is now optional. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'do-while statement' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/do...while\n
The for statement creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a statement (usually a block statement) to be executed in the loop.
for ([initialization]; [condition]; [final-expression])\n statement
initializationvar or let keywords. Variables declared with var are not local to the loop, i.e. they are in the same scope the for loop is in. Variables declared with let are local to the statement.conditionstatement is executed. This conditional test is optional. If omitted, the condition always evaluates to true. If the expression evaluates to false, execution skips to the first expression following the for construct.final-expressioncondition. Generally used to update or increment the counter variable.statement{ ... }) to group those statements. To execute no statement within the loop, use an empty statement (;).for\nThe following for statement starts by declaring the variable i and initializing it to 0. It checks that i is less than nine, performs the two succeeding statements, and increments i by 1 after each pass through the loop.
for (var i = 0; i < 9; i++) {\n console.log(i);\n // more statements\n}\n for expressionsAll three expressions in the head of the for loop are optional.
For example, in the initialization block it is not required to initialize variables:
var i = 0;\nfor (; i < 9; i++) {\n console.log(i);\n // more statements\n}\n Like the initialization block, the condition block is also optional. If you are omitting this expression, you must make sure to break the loop in the body in order to not create an infinite loop.
for (var i = 0;; i++) {\n console.log(i);\n if (i > 3) break;\n // more statements\n} You can also omit all three blocks. Again, make sure to use a break statement to end the loop and also modify (increase) a variable, so that the condition for the break statement is true at some point.
var i = 0;\n\nfor (;;) {\n if (i > 3) break;\n console.log(i);\n i++;\n}\n for without a statementThe following for cycle calculates the offset position of a node in the [final-expression] section, and therefore it does not require the use of a statement or block statement section, a semicolon is used instead.
function showOffsetPos(sId) {\n\n var nLeft = 0, nTop = 0;\n\n for (\n\n var oItNode = document.getElementById(sId); /* initialization */\n\n oItNode; /* condition */\n\n nLeft += oItNode.offsetLeft, nTop += oItNode.offsetTop, oItNode = oItNode.offsetParent /* final-expression */\n\n ); /* semicolon */ \n\n console.log('Offset position of \\'' + sId + '\\' element:\\n left: ' + nLeft + 'px;\\n top: ' + nTop + 'px;');\n\n}\n\n/* Example call: */\n\nshowOffsetPos('content');\n\n// Output:\n// \"Offset position of \"content\" element:\n// left: 0px;\n// top: 153px;\" | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for\n
The for each...in statement is deprecated as the part of ECMA-357 (E4X) standard. E4X support has been removed. Consider using for...of instead.
Firefox now warns about the usage of for each...in and it no longer works starting with Firefox 57.
Please see Warning: JavaScript 1.6's for-each-in loops are deprecated for migration help.
The for each...in statement iterates a specified variable over all values of object's properties. For each distinct property, a specified statement is executed.
for each (variable in object) {\n statement\n} variablevar keyword. This variable is local to the function, not to the loop.objectstatement{ ... }) to group those statements.Some built-in properties are not iterated over. These include all built-in methods of objects, e.g. String's indexOf method. However, all user-defined properties are iterated over.
for each...in\nWarning: Never use a loop like this on arrays. Only use it on objects. See for...in for more details.
The following snippet iterates over an object's properties, calculating their sum:
var sum = 0;\nvar obj = {prop1: 5, prop2: 13, prop3: 8};\n\nfor each (var item in obj) {\n sum += item;\n}\n\nconsole.log(sum); // logs \"26\", which is 5+13+8 Not part of a current ECMA-262 specification. Implemented in JavaScript 1.6 and deprecated.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nNo | \nNo | \n1.5 — 57 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nNo | \nNo | \nNo | \n4 — 57 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
for...in - a similar statement that iterates over the property names.for...of - a similar statement that iterates over the property values but can only be used for iteratable types, so not for generic objectsfor\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for_each...in\n
The for...in iterates over all non-Symbol, enumerable properties of an object.
for (variable in object) { ...\n} variableobjectA for...in loop only iterates over enumerable, non-Symbol properties. Objects created from built–in constructors like Array and Object have inherited non–enumerable properties from Object.prototype and String.prototype, such as String's indexOf() method or Object's toString() method. The loop will iterate over all enumerable properties of the object itself and those the object inherits from its constructor's prototype (properties closer to the object in the prototype chain override prototypes' properties).
A for...in loop iterates over the properties of an object in an arbitrary order (see the delete operator for more on why one cannot depend on the seeming orderliness of iteration, at least in a cross-browser setting).
If a property is modified in one iteration and then visited at a later time, its value in the loop is its value at that later time. A property that is deleted before it has been visited will not be visited later. Properties added to the object over which iteration is occurring may either be visited or omitted from iteration.
In general, it is best not to add, modify, or remove properties from the object during iteration, other than the property currently being visited. There is no guarantee whether an added property will be visited, whether a modified property (other than the current one) will be visited before or after it is modified, or whether a deleted property will be visited before it is deleted.
Note: for...in should not be used to iterate over an Array where the index order is important.
Array indexes are just enumerable properties with integer names and are otherwise identical to general object properties. There is no guarantee that for...in will return the indexes in any particular order. The for...in loop statement will return all enumerable properties, including those with non–integer names and those that are inherited.
Because the order of iteration is implementation-dependent, iterating over an array may not visit elements in a consistent order. Therefore, it is better to use a for loop with a numeric index (or Array.prototype.forEach() or the for...of loop) when iterating over arrays where the order of access is important.
If you only want to consider properties attached to the object itself, and not its prototypes, use getOwnPropertyNames() or perform a hasOwnProperty() check (propertyIsEnumerable can also be used). Alternatively, if you know there won't be any outside code interference, you can extend built-in prototypes with a check method.
The for...in loop below iterates over all of the object's enumerable, non-Symbol properties and logs a string of the property names and their values.
var obj = {a: 1, b: 2, c: 3};\n \nfor (const prop in obj) {\n console.log(`obj.${prop} = ${obj[prop]}`);\n}\n\n// Output:\n// \"obj.a = 1\"\n// \"obj.b = 2\"\n// \"obj.c = 3\" The following function illustrates the use of hasOwnProperty(): the inherited properties are not displayed.
var triangle = {a: 1, b: 2, c: 3};\n\nfunction ColoredTriangle() {\n this.color = 'red';\n}\n\nColoredTriangle.prototype = triangle;\n\nvar obj = new ColoredTriangle();\n\nfor (const prop in obj) {\n if (obj.hasOwnProperty(prop)) {\n console.log(`obj.${prop} = ${obj[prop]}`);\n } \n}\n\n// Output:\n// \"obj.color = red\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Prior to SpiderMonkey 40 (Firefox 40 / Thunderbird 40 / SeaMonkey 2.37), it was possible to use an initializer expression (i=0) in a for...in loop:
var obj = {a: 1, b: 2, c: 3};\nfor (var i = 0 in obj) {\n console.log(obj[i]);\n}\n// 1\n// 2\n// 3\n This nonstandard behavior is now ignored in version 40 and later, and will present a SyntaxError (\"for-in loop head declarations may not have initializers\") error in strict mode (bug 748550 and bug 1164741).
Other engines such as v8 (Chrome), Chakra (IE/Edge), and JSC (WebKit/Safari) are investigating whether to remove the nonstandard behavior as well.
for...of – a similar statement that iterates over the property values\nfor each...in – a similar but deprecated statement that iterates over the values of an object's properties, rather than the property names themselvesforfor...in syntax)Object.getOwnPropertyNames()Object.prototype.hasOwnProperty()Array.prototype.forEach()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in\n
The if statement executes a statement if a specified condition is truthy. If the condition is falsy, another statement can be executed.
if (condition)\n statement1\n[else\n statement2]\n
if statements. To execute multiple statements, use a block statement ({ ... }) to group those statements. To execute no statements, use an empty statement.else clause exists. Can be any statement, including block statements and further nested if statements.Multiple if...else statements can be nested to create an else if clause. Note that there is no elseif (in one word) keyword in JavaScript.
if (condition1)\n statement1\nelse if (condition2)\n statement2\nelse if (condition3)\n statement3\n...\nelse\n statementN\n
To see how this works, this is how it would look if the nesting were properly indented:
if (condition1)\n statement1\nelse\n if (condition2)\n statement2\n else\n if (condition3)\n...\n
To execute multiple statements within a clause, use a block statement ({ ... }) to group those statements. In general, it is a good practice to always use block statements, especially in code involving nested if statements:
if (condition) {\n statements1\n} else {\n statements2\n}\n Do not confuse the primitive boolean values true and false with truthiness or falsiness of the Boolean object. Any value that is not false, undefined, null, 0, NaN, or the empty string (\"\"), and any object, including a Boolean object whose value is false, is considered truthy when used as the condition. For example:
var b = new Boolean(false);\nif (b) // this condition is truthy\n
if...else\nif (cipher_char === from_char) {\n result = result + to_char;\n x++;\n} else {\n result = result + clear_char;\n}\n else if\nNote that there is no elseif syntax in JavaScript. However, you can write it with a space between else and if:
if (x > 5) {\n /* do the right thing */\n} else if (x > 50) {\n /* do the right thing */\n} else {\n /* do the right thing */\n} It is advisable to not use simple assignments in a conditional expression, because the assignment can be confused with equality when glancing over the code. For example, do not use the following code:
if (x = y) {\n /* do the right thing */\n}\n If you need to use an assignment in a conditional expression, a common practice is to put additional parentheses around the assignment. For example:
if ((x = y)) {\n /* do the right thing */\n}\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else\n
The for await...ofcreates a loop iterating over async iterable objects as well as on sync iterables, including: built-in String, Array, Array-like objects (e.g., arguments or NodeList), TypedArray, Map, Set, and user-defined async/sync iterables. It invokes a custom iteration hook with statements to be executed for the value of each distinct property of the object.
for await (variable of iterable) {\n statement\n}\n variableiterableYou can also iterate over an object that explicitly implements async iterable protocol:
var asyncIterable = {\n [Symbol.asyncIterator]() {\n return {\n i: 0,\n next() {\n if (this.i < 3) {\n return Promise.resolve({ value: this.i++, done: false });\n }\n\n return Promise.resolve({ done: true });\n }\n };\n }\n};\n\n(async function() {\n for await (num of asyncIterable) {\n console.log(num);\n }\n})();\n// 0\n// 1\n// 2\n Since async generators implement async Iterator protocol, they can be looped using for await...of
async function* asyncGenerator() {\n var i = 0;\n while (i < 3) {\n yield i++;\n }\n}\n\n(async function() {\n for await (num of asyncGenerator()) {\n console.log(num);\n }\n})();\n// 0\n// 1\n// 2 | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'ECMAScript Language: The for-in, for-of, and for-await-of Statements' in that specification. | Draft |
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of\n
The for...ofcreates a loop iterating over iterable objects, including: built-in String, Array, Array-like objects (e.g., arguments or NodeList), TypedArray, Map, Set, and user-defined iterables. It invokes a custom iteration hook with statements to be executed for the value of each distinct property of the object.
for (variable of iterable) {\n statement\n}\n variableiterableArray\nlet iterable = [10, 20, 30];\n\nfor (let value of iterable) {\n value += 1;\n console.log(value);\n}\n// 11\n// 21\n// 31\n You can use const instead of let too, if you don't reassign the variable inside the block.
let iterable = [10, 20, 30];\n\nfor (const value of iterable) {\n console.log(value);\n}\n// 10\n// 20\n// 30\n String\nlet iterable = 'boo';\n\nfor (let value of iterable) {\n console.log(value);\n}\n// \"b\"\n// \"o\"\n// \"o\"\n TypedArray\nlet iterable = new Uint8Array([0x00, 0xff]);\n\nfor (let value of iterable) {\n console.log(value);\n}\n// 0\n// 255\n Map\nlet iterable = new Map([['a', 1], ['b', 2], ['c', 3]]);\n\nfor (let entry of iterable) {\n console.log(entry);\n}\n// ['a', 1]\n// ['b', 2]\n// ['c', 3]\n\nfor (let [key, value] of iterable) {\n console.log(value);\n}\n// 1\n// 2\n// 3\n Set\nlet iterable = new Set([1, 1, 2, 2, 3, 3]);\n\nfor (let value of iterable) {\n console.log(value);\n}\n// 1\n// 2\n// 3\n You can iterate over the arguments object to examine all of the parameters passed into a JavaScript function:
(function() {\n for (let argument of arguments) {\n console.log(argument);\n }\n})(1, 2, 3);\n\n// 1\n// 2\n// 3 Iterating over DOM collections like NodeList: the following example adds a read class to paragraphs that are direct descendants of an article:
// Note: This will only work in platforms that have\n// implemented NodeList.prototype[Symbol.iterator]\nlet articleParagraphs = document.querySelectorAll('article > p');\n\nfor (let paragraph of articleParagraphs) {\n paragraph.classList.add('read');\n}\n In for...of loops, abrupt iteration termination can be caused by break, continue, throw or return. In these cases, the iterator is closed.
function* foo(){ \n yield 1; \n yield 2; \n yield 3; \n}; \n\nfor (let o of foo()) { \n console.log(o); \n break; // closes iterator, triggers return\n} You can also iterate over generators, i.e. functions generating an iterable object:
function* fibonacci() { // a generator function\n let [prev, curr] = [0, 1];\n while (true) {\n [prev, curr] = [curr, prev + curr];\n yield curr;\n }\n}\n\nfor (let n of fibonacci()) {\n console.log(n);\n // truncate the sequence at 1000\n if (n >= 1000) {\n break;\n }\n}\n Generators should not be re-used, even if the for...of loop is terminated early, for example via the break keyword. Upon exiting a loop, the generator is closed and trying to iterate over it again does not yield any further results.
var gen = (function *(){\n yield 1;\n yield 2;\n yield 3;\n})();\nfor (let o of gen) {\n console.log(o);\n break; // Closes iterator\n}\n\n// The generator should not be re-used, the following does not make sense!\nfor (let o of gen) {\n console.log(o); // Never called.\n}\n You can also iterate over an object that explicitly implements iterable protocol:
var iterable = {\n [Symbol.iterator]() {\n return {\n i: 0,\n next() {\n if (this.i < 3) {\n return { value: this.i++, done: false };\n }\n return { value: undefined, done: true };\n }\n };\n }\n};\n\nfor (var value of iterable) {\n console.log(value);\n}\n// 0\n// 1\n// 2\n Difference between for...of and for...in
Both for...in and for...of statements iterate over something. The main difference between them is in what they iterate over.
The for...in statement iterates over the enumerable properties of an object, in an arbitrary order.
The for...of statement iterates over data that iterable object defines to be iterated over.
The following example shows the difference between a for...of loop and a for...in loop when used with an Array.
Object.prototype.objCustom = function() {}; \nArray.prototype.arrCustom = function() {};\n\nlet iterable = [3, 5, 7];\niterable.foo = 'hello';\n\nfor (let i in iterable) {\n console.log(i); // logs 0, 1, 2, \"foo\", \"arrCustom\", \"objCustom\"\n}\n\nfor (let i in iterable) {\n if (iterable.hasOwnProperty(i)) {\n console.log(i); // logs 0, 1, 2, \"foo\"\n }\n}\n\nfor (let i of iterable) {\n console.log(i); // logs 3, 5, 7\n}\n Let us look into the above code step by step.
Object.prototype.objCustom = function() {};\nArray.prototype.arrCustom = function() {}; \n\nlet iterable = [3, 5, 7]; \niterable.foo = 'hello'; Every object will inherit objCustom property and every object that is an Array will inherit arrCustom property because of adding those properties to Object.prototype and Array.prototype. The object iterable inherits properties objCustom and arrCustom because of inheritance and the prototype chain.
for (let i in iterable) {\n console.log(i); // logs 0, 1, 2, \"foo\", \"arrCustom\", \"objCustom\" \n} This loop logs only enumerable properties of iterable object, in original insertion order. It doesn't log array elements 3, 5, 7 or hello because those are not enumerable properties. But it logs array indexes as well as arrCustom and objCustom, which are. If you're not sure why the properties are iterated over, there's a more thorough explanation of how array iteration and for...in work.
for (let i in iterable) {\n if (iterable.hasOwnProperty(i)) {\n console.log(i); // logs 0, 1, 2, \"foo\"\n }\n} This loop is similar to the first one, but it uses hasOwnProperty() to check, if the found enumerable property is object's own (not inherited). And if it is, the property is logged. Properties 0, 1, 2 and foo are logged because they are own properties (not inherited). Properties arrCustom and objCustom are not logged because they are inherited.
for (let i of iterable) {\n console.log(i); // logs 3, 5, 7 \n} This loop iterates and logs values that iterable as an iterable objectdefines to be iterated over, which are array elements 3, 5, 7 and not any of object's properties.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'for...of statement' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'for...of statement' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n 13\n
| \nNo | \n25 | \n8 | \n
| async iterators | \n63 | \n? | \n57 | \n? | \n50 | \n? | \n
| Closing iterators | \n51 | \nYes | \n53 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \nYes | \n12 | \n 14\n
| \n25 | \n8 | \nYes | \n
| async iterators | \n63 | \n63 | \n? | \n57 | \n50 | \n? | \n? | \n
| Closing iterators | \nYes | \nYes | \nYes | \n53 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| async iterators | \n? | \n
| Closing iterators | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of\n
The static import statement is used to import bindings which are exported by another module. Imported modules are in strict mode whether you declare them as such or not. The import statement cannot be used in embedded scripts unless such script has a type=\"module\".
There is also a function-like dynamic import(), which does not require scripts of type=\"module\".
Dynamic import is useful in situations where you wish to load a module conditionally, or on demand. The static form is preferable for loading initial dependencies, and can benefit more readily from static analysis tools and tree shaking.
import defaultExport from \"module-name\";\nimport * as name from \"module-name\";\nimport { export } from \"module-name\";\nimport { export as alias } from \"module-name\";\nimport { export1 , export2 } from \"module-name\";\nimport { foo , bar } from \"module-name/path/to/specific/un-exported/file\";\nimport { export1 , export2 as alias2 , [...] } from \"module-name\";\nimport defaultExport, { export [ , [...] ] } from \"module-name\";\nimport defaultExport, * as name from \"module-name\";\nimport \"module-name\";\nvar promise = import(\"module-name\"); defaultExportmodule-name.js file containing the module. Certain bundlers may permit or require the use of the extension; check your environment. Only single quotes and double quotes Strings are allowed.nameexport, exportNalias, aliasNThe name parameter is the name of the \"module object\" which will be used as a kind of namespace to refer to the exports. The export parameters specify individual named exports, while the import * as name syntax imports all of them. Below are examples to clarify the syntax.
This inserts myModule into the current scope, containing all the exports from the module in the file located in /modules/my-module.js.
import * as myModule from '/modules/my-module.js';\n
Here, accessing the exports means using the module name (\"myModule\" in this case) as a namespace. For example, if the module imported above includes an export doAllTheAmazingThings(), you would call it like this:
myModule.doAllTheAmazingThings();
Given an object or value named myExport which has been exported from the module my-module either implicitly (because the entire module is exported) or explicitly (using the export statement), this inserts myExport into the current scope.
import {myExport} from '/modules/my-module.js'; This inserts both foo and bar into the current scope.
import {foo, bar} from '/modules/my-module.js'; You can rename an export when importing it. For example, this inserts shortName into the current scope.
import {reallyReallyLongModuleExportName as shortName}\n from '/modules/my-module.js'; Import multiple exports from a module with convenient aliases.
import {\n reallyReallyLongModuleExportName as shortName,\n anotherLongModuleName as short\n} from '/modules/my-module.js'; Import an entire module for side effects only, without importing anything. This runs the module's global code, but doesn't actually import any values.
import '/modules/my-module.js';\n
It is possible to have a default export (whether it is an object, a function, a class, etc.). The import statement may then be used to import such defaults.
The simplest version directly imports the default:
import myDefault from '/modules/my-module.js';
It is also possible to use the default syntax with the ones seen above (namespace imports or named imports). In such cases, the default import will have to be declared first. For instance:
import myDefault, * as myModule from '/modules/my-module.js';\n// myModule used as a namespace
or
import myDefault, {foo, bar} from '/modules/my-module.js';\n// specific, named imports\n The import keyword may be called as a function to dynamically import a module. When used this way, it returns a promise.
import('/modules/my-module.js')\n .then((module) => {\n // Do something with the module.\n });\n This form also supports the await keyword.
let module = await import('/modules/my-module.js'); The code below shows how to import from a secondary module to assist in processing an AJAX JSON request.
function getJSON(url, callback) {\n let xhr = new XMLHttpRequest();\n xhr.onload = function () { \n callback(this.responseText) \n };\n xhr.open('GET', url, true);\n xhr.send();\n}\n\nexport function getUsefulContents(url, callback) {\n getJSON(url, data => callback(JSON.parse(data)));\n} import { getUsefulContents } from '/modules/file.js';\n\ngetUsefulContents('http://www.example.com',\n data => { doSomethingUseful(data); }); This example shows how to load functionality on to a page based on a user action, in this case a button click, and then call a function within that module. This is not the only way to implement this functionality. The import() function also supports await.
const main = document.querySelector(\"main\");\nfor (const link of document.querySelectorAll(\"nav > a\")) {\n link.addEventListener(\"click\", e => {\n e.preventDefault();\n\n import('/modules/my-module.js')\n .then(module => {\n module.loadPageInto(main);\n })\n .catch(err => {\n main.textContent = err.message;\n });\n });\n} | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n61 | \n 16\n
| \n 60\n
| \nNo | \n47 | \n10.1 | \n
| Dynamic import | \n63 | \n No\n
| \n No\n
| \nNo | \n50 | \n11.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n61 | \n61 | \nYes | \n 60\n
| \n47 | \n10.1 | \nNo | \n
| Dynamic import | \n63 | \n63 | \nNo | \n No\n
| \n50 | \n11.1 | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 8.5.0\n
| \n
| Dynamic import | \n? | \n
exportimport.meta\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import\n
The function declaration (function statement) defines a function with the specified parameters.
You can also define functions using the Function constructor and a function expression.
function name([param[, param,[..., param]]]) {\n [statements]\n}\n nameparamstatementsA function created with a function declaration is a Function object and has all the properties, methods and behavior of Function objects. See Function for detailed information on functions.
A function can also be created using an expression (see function expression).
By default, functions return undefined. To return any other value, the function must have a return statement that specifies the value to return.
Functions can be conditionally declared, that is, a function statement can be nested within an if statement, however the results are inconsistent across implementations and therefore this pattern should not be used in production code. For conditional function creation, use function expressions instead.
var hoisted = \"foo\" in this;\nconsole.log(`'foo' name ${hoisted ? \"is\" : \"is not\"} hoisted. typeof foo is ${typeof foo}`);\nif (false) {\n function foo(){ return 1; }\n}\n\n// In Chrome: \n// 'foo' name is hoisted. typeof foo is undefined\n// \n// In Firefox:\n// 'foo' name is hoisted. typeof foo is undefined\n//\n// In Edge:\n// 'foo' name is not hoisted. typeof foo is undefined\n// \n// In Safari:\n// 'foo' name is hoisted. typeof foo is function\n The results are exactly the same for a condition that evaluates to true
var hoisted = \"foo\" in this;\nconsole.log(`'foo' name ${hoisted ? \"is\" : \"is not\"} hoisted. typeof foo is ${typeof foo}`);\nif (true) {\n function foo(){ return 1; }\n}\n\n// In Chrome: \n// 'foo' name is hoisted. typeof foo is undefined\n// \n// In Firefox:\n// 'foo' name is hoisted. typeof foo is undefined\n//\n// In Edge:\n// 'foo' name is not hoisted. typeof foo is undefined\n// \n// In Safari:\n// 'foo' name is hoisted. typeof foo is function\n Function declarations in JavaScript are hoisted to the top of the enclosing function or global scope. You can use the function before you declared it:
hoisted(); // logs \"foo\"\n\nfunction hoisted() {\n console.log('foo');\n}\n Note that function expressions are not hoisted:
notHoisted(); // TypeError: notHoisted is not a function\n\nvar notHoisted = function() {\n console.log('bar');\n};\n function\nThe following code declares a function that returns the total amount of sales, when given the number of units sold of products a, b, and c.
function calc_sales(units_a, units_b, units_c) {\n return units_a * 79 + units_b * 129 + units_c * 699;\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function definitions' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function definitions' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'Function definition' in that specification. | Standard | |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'Function definition' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'Function definition' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Allowed in sloppy mode | \n49 | \n? | \n? | \n? | \nYes | \n? | \n
| Trailing comma in parameters | \n58 | \n? | \n52 | \n? | \n45 | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Allowed in sloppy mode | \n? | \n? | \n? | \n? | \n? | \n? | \n? | \n
| Trailing comma in parameters | \n58 | \n58 | \n? | \n52 | \n45 | \n? | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Allowed in sloppy mode | \n? | \n
| Trailing comma in parameters | \n8.0.0 | \n
Functions and function scopeFunctionfunction expressionfunction* statementfunction* expressionArrow functionsGeneratorFunctionasync functionasync function expression\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function\n
Theimport.meta object is a meta-property exposing context-specific meta data to a JavaScript module. It contains information about the module, like the module's URL.
import.meta
The import.meta object consists of the keyword import, a dot, and a property name meta. Normally import. serves as the context for a property access, but here import. is not really an object.
The import.meta object is created by the ECMAScript implementation, with a null prototype. The object is extensible, and its properties are writable, configurable, and enumerable.
Given a module my-module.js
<script type=\"module\" src=\"my-module.js\"></script>\n
you can can access meta information about the module using the import.meta object.
console.log(import.meta); // { url: \"file:///home/user/my-module.mjs\" } It returns an object with a url property indicating the base URL of the module. This will either be the URL from which the script was obtained, for external scripts, or the document base URL of the containing document, for inline scripts.
| Specification | Status | Comment |
|---|---|---|
\nimport.meta proposal | Stage 3 | |
| HTML Living Standard The definition of 'import.meta' in that specification. | Living Standard | Defines import.meta properties in HTML. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n64 | \n? | \n62 | \nNo | \n51 | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n64 | \n64 | \n? | \n62 | \n51 | \n? | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import.meta\n
The switch evaluates an expression, matching the expression's value to a case clause, and executes statements associated with that case, as well as statements in cases that follow the matching case.
switch (expression) {\n case value1:\n //Statements executed when the\n //result of expression matches value1\n [break;]\n case value2:\n //Statements executed when the\n //result of expression matches value2\n [break;]\n ...\n case valueN:\n //Statements executed when the\n //result of expression matches valueN\n [break;]\n [default:\n //Statements executed when none of\n //the values match the value of the expression\n [break;]]\n} expressioncase valueN Optional\ncase clause used to match against expression. If the expression matches the specified valueN, the statements inside the case clause are executed until either the end of the switch statement or a break.default Optional\ndefault clause; if provided, this clause is executed if the value of expression doesn't match any of the case clauses.A switch statement first evaluates its expression. It then looks for the first case clause whose expression evaluates to the same value as the result of the input expression (using the strict comparison, ===) and transfers control to that clause, executing the associated statements. (If multiple cases match the provided value, the first case that matches is selected, even if the cases are not equal to each other.)
If no matching case clause is found, the program looks for the optional default clause, and if found, transfers control to that clause, executing the associated statements. If no default clause is found, the program continues execution at the statement following the end of switch. By convention, the default clause is the last clause, but it does not need to be so.
The optional break statement associated with each case label ensures that the program breaks out of switch once the matched statement is executed and continues execution at the statement following switch. If break is omitted, the program continues execution at the next statement in the switch statement.
switch\nIn the following example, if expr evaluates to \"Bananas\", the program matches the value with case \"Bananas\" and executes the associated statement. When break is encountered, the program breaks out of switch and executes the statement following switch. If break were omitted, the statement for case \"Cherries\" would also be executed.
switch (expr) {\n case 'Oranges':\n console.log('Oranges are $0.59 a pound.');\n break;\n case 'Apples':\n console.log('Apples are $0.32 a pound.');\n break;\n case 'Bananas':\n console.log('Bananas are $0.48 a pound.');\n break;\n case 'Cherries':\n console.log('Cherries are $3.00 a pound.');\n break;\n case 'Mangoes':\n case 'Papayas':\n console.log('Mangoes and papayas are $2.79 a pound.');\n break;\n default:\n console.log('Sorry, we are out of ' + expr + '.');\n}\n\nconsole.log(\"Is there anything else you'd like?\");\n If you forget a break then the script will run from the case where the criterion is met and will run the case after that regardless if criterion was met. See example here:
var foo = 0;\nswitch (foo) {\n case -1:\n console.log('negative 1');\n break;\n case 0: // foo is 0 so criteria met here so this block will run\n console.log(0);\n // NOTE: the forgotten break would have been here\n case 1: // no break statement in 'case 0:' so this case will run as well\n console.log(1);\n break; // it encounters this break so will not continue into 'case 2:'\n case 2:\n console.log(2);\n break;\n default:\n console.log('default');\n} Yes, you can! JavaScript will drop you back to the default if it can't find a match:
var foo = 5;\nswitch (foo) {\n case 2:\n console.log(2);\n break; // it encounters this break so will not continue into 'default:'\n default:\n console.log('default')\n // fall-through\n case 1: \n console.log('1');\n}\n It also works when you put default before all other cases.
Source for this technique is here:
Switch statement multiple cases in JavaScript (Stack Overflow)
This method takes advantage of the fact that if there is no break below a case statement it will continue to execute the next case statement regardless if the case meets the criteria. See the section titled \"What happens if I forgot a break?\"
This is an example of a single operation sequential switch statement, where four different values perform exactly the same.
var Animal = 'Giraffe';\nswitch (Animal) {\n case 'Cow':\n case 'Giraffe':\n case 'Dog':\n case 'Pig':\n console.log('This animal will go on Noah\\'s Ark.');\n break;\n case 'Dinosaur':\n default:\n console.log('This animal will not.');\n} This is an example of a multiple-operation sequential switch statement, where, depending on the provided integer, you can receive different output. This shows you that it will traverse in the order that you put the case statements, and it does not have to be numerically sequential. In JavaScript, you can even mix in definitions of strings into these case statements as well.
var foo = 1;\nvar output = 'Output: ';\nswitch (foo) {\n case 0:\n output += 'So ';\n case 1:\n output += 'What ';\n output += 'Is ';\n case 2:\n output += 'Your ';\n case 3:\n output += 'Name';\n case 4:\n output += '?';\n console.log(output);\n break;\n case 5:\n output += '!';\n console.log(output);\n break;\n default:\n console.log('Please pick a number from 0 to 5!');\n} The output from this example:
| Value | Log text |
|---|---|
| foo is NaN or not 1, 2, 3, 4, 5 or 0 | Please pick a number from 0 to 5! |
| 0 | Output: So What Is Your Name? |
| 1 | Output: What Is Your Name? |
| 2 | Output: Your Name? |
| 3 | Output: Name? |
| 4 | Output: ? |
| 5 | Output: ! |
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2 |
| ECMAScript 5.1 (ECMA-262) The definition of 'switch statement' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'switch statement' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'switch statement' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch\n
The var declares a variable, optionally initializing it to a value.
var varname1 [= value1] [, varname2 [= value2] ... [, varnameN [= valueN]]];
varnameNvalueNvar declarations, wherever they occur, are processed before any code is executed. This is called hoisting, and is discussed further below.
The scope of a variable declared with var is its current execution context, which is either the enclosing function or, for variables declared outside any function, global. If you re-declare a JavaScript variable, it will not lose its value.
Assigning a value to an undeclared variable implicitly creates it as a global variable (it becomes a property of the global object) when the assignment is executed. The differences between declared and undeclared variables are:
1. Declared variables are constrained in the execution context in which they are declared. Undeclared variables are always global.
function x() {\n y = 1; // Throws a ReferenceError in strict mode\n var z = 2;\n}\n\nx();\n\nconsole.log(y); // logs \"1\" \nconsole.log(z); // Throws a ReferenceError: z is not defined outside x\n 2. Declared variables are created before any code is executed. Undeclared variables do not exist until the code assigning to them is executed.
console.log(a); // Throws a ReferenceError.\nconsole.log('still going...'); // Never executes. var a;\nconsole.log(a); // logs \"undefined\" or \"\" depending on browser.\nconsole.log('still going...'); // logs \"still going...\". 3. Declared variables are a non-configurable property of their execution context (function or global). Undeclared variables are configurable (e.g. can be deleted).
var a = 1;\nb = 2;\n\ndelete this.a; // Throws a TypeError in strict mode. Fails silently otherwise.\ndelete this.b;\n\nconsole.log(a, b); // Throws a ReferenceError. \n// The 'b' property was deleted and no longer exists.
Because of these three differences, failure to declare variables will very likely lead to unexpected results. Thus it is recommended to always declare variables, regardless of whether they are in a function or global scope. And in ECMAScript 5 strict mode, assigning to an undeclared variable throws an error.
Because variable declarations (and declarations in general) are processed before any code is executed, declaring a variable anywhere in the code is equivalent to declaring it at the top. This also means that a variable can appear to be used before it's declared. This behavior is called \"hoisting\", as it appears that the variable declaration is moved to the top of the function or global code.
bla = 2;\nvar bla;\n// ...\n\n// is implicitly understood as:\n\nvar bla;\nbla = 2;\n
For that reason, it is recommended to always declare variables at the top of their scope (the top of global code and the top of function code) so it's clear which variables are function scoped (local) and which are resolved on the scope chain.
It's important to point out that the hoisting will affect the variable declaration, but not its value's initialization. The value will be indeed assigned when the assignment statement is reached:
function do_something() {\n console.log(bar); // undefined\n var bar = 111;\n console.log(bar); // 111\n}\n\n// is implicitly understood as: \nfunction do_something() {\n var bar;\n console.log(bar); // undefined\n bar = 111;\n console.log(bar); // 111\n}\n var a = 0, b = 0;\n
var a = 'A';\nvar b = a;\n\n// Equivalent to:\n\nvar a, b = a = 'A';\n
Be mindful of the order:
var x = y, y = 'A';\nconsole.log(x + y); // undefinedA\n
Here, x and y are declared before any code is executed, but the assignments occur later. At the time \"x = y\" is evaluated, y exists so no ReferenceError is thrown and its value is undefined. So, x is assigned the undefined value. Then, y is assigned the value 'A'. Consequently, after the first line, x === undefined && y === 'A', hence the result.
var x = 0;\n\nfunction f() {\n var x = y = 1; // x is declared locally. y is not!\n}\nf();\n\nconsole.log(x, y); // Throws a ReferenceError in strict mode (y is not defined). 0, 1 otherwise. \n// In non-strict mode:\n// x is the global one as expected\n// y leaked outside of the function, though! Variables that appear to be implicit globals may be references to variables in an outer function scope:
var x = 0; // x is declared within file scope, then assigned a value of 0\n\nconsole.log(typeof z); // undefined, since z doesn't exist yet\n\nfunction a() { // when a is called,\n var y = 2; // y is declared within scope of function a, then assigned a value of 2\n\n console.log(x, y); // 0 2 \n\n function b() { // when b is called\n x = 3; // assigns 3 to existing file scoped x, doesn't create a new global var\n y = 4; // assigns 4 to existing outer y, doesn't create a new global var\n z = 5; // creates a new global variable z and assigns a value of 5. \n } // (Throws a ReferenceError in strict mode.)\n\n b(); // calling b creates z as a global variable\n console.log(x, y, z); // 3 4 5\n}\n\na(); // calling a also calls b\nconsole.log(x, z); // 3 5\nconsole.log(typeof y); // undefined as y is local to function a | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0 |
| ECMAScript 5.1 (ECMA-262) The definition of 'var statement' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'variable statement' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'variable statement' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var\n
The labeled statement can be used with break or continue statements. It is prefixing a statement with an identifier which you can refer to.
Note: Labeled loops or blocks are very uncommon. Usually function calls can be used instead of loop jumps.
label :\n statement\n
labelstatementbreak can be used with any labeled statement, and continue can be used with looping labeled statements.You can use a label to identify a loop, and then use the break or continue statements to indicate whether a program should interrupt the loop or continue its execution.
Note that JavaScript has no goto statement, you can only use labels with break or continue.
In strict mode code, you can't use \"let\" as a label name. It will throw a SyntaxError (let is a reserved identifier).
continue with for loopsvar i, j;\n\nloop1:\nfor (i = 0; i < 3; i++) { //The first for statement is labeled \"loop1\"\n loop2:\n for (j = 0; j < 3; j++) { //The second for statement is labeled \"loop2\"\n if (i === 1 && j === 1) {\n continue loop1;\n }\n console.log('i = ' + i + ', j = ' + j);\n }\n}\n\n// Output is:\n// \"i = 0, j = 0\"\n// \"i = 0, j = 1\"\n// \"i = 0, j = 2\"\n// \"i = 1, j = 0\"\n// \"i = 2, j = 0\"\n// \"i = 2, j = 1\"\n// \"i = 2, j = 2\"\n// Notice how it skips both \"i = 1, j = 1\" and \"i = 1, j = 2\"\n continue statementGiven an array of items and an array of tests, this example counts the number of items that passes all the tests.
var itemsPassed = 0;\nvar i, j;\n\ntop:\nfor (i = 0; i < items.length; i++) {\n for (j = 0; j < tests.length; j++) {\n if (!tests[j].pass(items[i])) {\n continue top;\n }\n }\n\n itemsPassed++;\n} break with for loopsvar i, j;\n\nloop1:\nfor (i = 0; i < 3; i++) { //The first for statement is labeled \"loop1\"\n loop2:\n for (j = 0; j < 3; j++) { //The second for statement is labeled \"loop2\"\n if (i === 1 && j === 1) {\n break loop1;\n }\n console.log('i = ' + i + ', j = ' + j);\n }\n}\n\n// Output is:\n// \"i = 0, j = 0\"\n// \"i = 0, j = 1\"\n// \"i = 0, j = 2\"\n// \"i = 1, j = 0\"\n// Notice the difference with the previous continue example break statementGiven an array of items and an array of tests, this example determines whether all items pass all tests.
var allPass = true;\nvar i, j;\n\ntop:\nfor (i = 0; items.length; i++)\n for (j = 0; j < tests.length; i++)\n if (!tests[j].pass(items[i])) {\n allPass = false;\n break top;\n } break\nYou can use labels within simple blocks, but only break statements can make use of non-loop labels.
foo: {\n console.log('face');\n break foo;\n console.log('this will not be executed');\n}\nconsole.log('swap');\n\n// this will log:\n\n// \"face\"\n// \"swap Starting with ECMAScript 2015, labeled function declarations are now standardized for non-strict code in the web compatibility annex of the specification.
L: function F() {} In strict mode code, however, this will throw a SyntaxError:
'use strict';\nL: function F() {}\n// SyntaxError: functions cannot be labelled Generator functions can neither be labeled in strict code, nor in non-strict code:
L: function* F() {}\n// SyntaxError: generator functions cannot be labelled\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2 |
| ECMAScript 5.1 (ECMA-262) The definition of 'Labelled statement' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Labelled statement' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Labelled statement' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label\n
The function* declaration (function keyword followed by an asterisk) defines a generator function, which returns a Generator object.
You can also define generator functions using the GeneratorFunction constructor, or the function expression syntax.
function* name([param[, param[, ... param]]]) {\n statements\n}\n nameparamstatementsGenerators are functions which can be exited and later re-entered. Their context (variable bindings) will be saved across re-entrances.
Generators in JavaScript -- especially when combined with Promises -- are a very powerful tool for asynchronous programming as they mitigate -- if not entirely eliminate -- the problems with callbacks, such as Callback Hell and Inversion of Control.
This pattern is what async functions are built on top of.
Calling a generator function does not execute its body immediately; an iterator object for the function is returned instead. When the iterator's next() method is called, the generator function's body is executed until the first yield expression, which specifies the value to be returned from the iterator or, with yield*, delegates to another generator function. The next() method returns an object with a value property containing the yielded value and a done property which indicates whether the generator has yielded its last value as a boolean. Calling the next() method with an argument will resume the generator function execution, replacing the yield expression where execution was paused with the argument from next().
A return statement in a generator, when executed, will make the generator finished (i.e the done property of the object returned by it will be set to true). If a value is returned, it will be set as the value property of the object returned by the generator.
Much like a return statement, an error thrown inside the generator will make the generator finished -- unless caught within the generator's body.
When a generator is finished, subsequent next calls will not execute any of that generator's code, they will just return an object of this form: {value: undefined, done: true}.
function* idMaker() {\n var index = 0;\n while (index < index+1)\n yield index++;\n}\n\nvar gen = idMaker();\n\nconsole.log(gen.next().value); // 0\nconsole.log(gen.next().value); // 1\nconsole.log(gen.next().value); // 2\nconsole.log(gen.next().value); // 3\n// ... function* anotherGenerator(i) {\n yield i + 1;\n yield i + 2;\n yield i + 3;\n}\n\nfunction* generator(i) {\n yield i;\n yield* anotherGenerator(i);\n yield i + 10;\n}\n\nvar gen = generator(10);\n\nconsole.log(gen.next().value); // 10\nconsole.log(gen.next().value); // 11\nconsole.log(gen.next().value); // 12\nconsole.log(gen.next().value); // 13\nconsole.log(gen.next().value); // 20\n function* logGenerator() {\n console.log(0);\n console.log(1, yield);\n console.log(2, yield);\n console.log(3, yield);\n}\n\nvar gen = logGenerator();\n\n// the first call of next executes from the start of the function\n// until the first yield statement\ngen.next(); // 0\ngen.next('pretzel'); // 1 pretzel\ngen.next('california'); // 2 california\ngen.next('mayonnaise'); // 3 mayonnaise\n function* yieldAndReturn() {\n yield \"Y\";\n return \"R\";\n yield \"unreachable\";\n}\n\nvar gen = yieldAndReturn()\nconsole.log(gen.next()); // { value: \"Y\", done: false }\nconsole.log(gen.next()); // { value: \"R\", done: true }\nconsole.log(gen.next()); // { value: undefined, done: true }\n function* f() {}\nvar obj = new f; // throws \"TypeError: f is not a constructor\n const foo = function* () {\n yield 10;\n yield 20;\n};\n\nconst bar = foo();\nconsole.log(bar.next()); // {value: 10, done: false} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'function*' in that specification. | Standard | Initial definition. |
| ECMAScript 2016 (ECMA-262) The definition of 'function*' in that specification. | Standard | Changed that generators should not have [[Construct]] trap and will throw when used with new. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'function*' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n39 | \n13 | \n26 | \nNo | \n26 | \n10 | \n
\nIteratorResult object instead of throwing | \n49 | \n13 | \n29 | \nNo | \nYes | \nYes | \n
Not constructable with new (ES2016) | \nYes | \n? | \n43 | \nNo | \nYes | \n10 | \n
| Trailing comma in parameters | \n? | \n? | \n52 | \n? | \nYes | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n39 | \nYes | \n26 | \nYes | \n10 | \n4.0 | \n
\nIteratorResult object instead of throwing | \nYes | \nYes | \nYes | \n29 | \nYes | \nYes | \nYes | \n
Not constructable with new (ES2016) | \nYes | \nYes | \n? | \n43 | \nYes | \n10 | \nYes | \n
| Trailing comma in parameters | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
\nIteratorResult object instead of throwing | \nYes | \n
Not constructable with new (ES2016) | \nYes | \n
| Trailing comma in parameters | \n8.0.0 | \n
Older Firefox versions implement an older version of the generators proposal. In the older version, generators were defined using a regular function keyword (without an asterisk) among other differences. See Legacy generator function for further information.
IteratorResult object returned instead of throwingStarting with Gecko 29 (Firefox 29 / Thunderbird 29 / SeaMonkey 2.26), the completed generator function no longer throws a TypeError \"generator has already finished\". Instead, it returns an IteratorResult object like { value: undefined, done: true } (bug 958951).
function* expressionGeneratorFunction objectyieldyield*Function objectfunction declarationfunction expressionFunctions and function scope\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*\n
The while statement creates a loop that executes a specified statement as long as the test condition evaluates to true. The condition is evaluated before executing the statement.
while (condition)\n statement\n
conditionstatement is executed. When condition evaluates to false, execution continues with the statement after the while loop.statement{ ... }) to group those statements.The following while loop iterates as long as n is less than three.
var n = 0;\nvar x = 0;\n\nwhile (n < 3) {\n n++;\n x += n;\n} Each iteration, the loop increments n and adds it to x. Therefore, x and n take on the following values:
n = 1 and x = 1n = 2 and x = 3n = 3 and x = 6After completing the third pass, the condition n < 3 is no longer true, so the loop terminates.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/while\n
with statement is not recommended, as it may be the source of confusing bugs and compatibility issues. See the \"Ambiguity Contra\" paragraph in the \"Description\" section below for details.The with statement extends the scope chain for a statement.
with (expression)\n statement\n
expressionstatementJavaScript looks up an unqualified name by searching a scope chain associated with the execution context of the script or function containing that unqualified name. The 'with' statement adds the given object to the head of this scope chain during the evaluation of its statement body. If an unqualified name used in the body matches a property in the scope chain, then the name is bound to the property and the object containing the property. Otherwise a ReferenceError is thrown.
with is not recommended, and is forbidden in ECMAScript 5 strict mode. The recommended alternative is to assign the object whose properties you want to access to a temporary variable.Pro: The with statement can help reduce file size by reducing the need to repeat a lengthy object reference without performance penalty. The scope chain change required by 'with' is not computationally expensive. Use of 'with' will relieve the interpreter of parsing repeated object references. Note, however, that in many cases this benefit can be achieved by using a temporary variable to store a reference to the desired object.
Contra: The with statement forces the specified object to be searched first for all name lookups. Therefore all identifiers that aren't members of the specified object will be found more slowly in a 'with' block. Where performance is important, 'with' should only be used to encompass code blocks that access members of the specified object.
Contra: The with statement makes it hard for a human reader or JavaScript compiler to decide whether an unqualified name will be found along the scope chain, and if so, in which object. So given this example:
function f(x, o) {\n with (o) {\n console.log(x);\n }\n} Only when f is called is x either found or not, and if found, either in o or (if no such property exists) in f's activation object, where x names the first formal argument. If you forget to define x in the object you pass as the second argument, or if there's some similar bug or confusion, you won't get an error -- just unexpected results.
Contra: Code using with may not be forward compatible, especially when used with something other than a plain object. Consider this example:
function f(foo, values) {\n with (foo) {\n console.log(values);\n }\n}\n If you call f([1,2,3], obj) in an ECMAScript 5 environment, then the values reference inside the with statement will resolve to obj. However, ECMAScript 6 introduces a values property on Array.prototype (so that it will be available on every array). So, in a JavaScript environment that supports ECMAScript 6, the values reference inside the with statement could resolve to [1,2,3].values. However, in this particular example, Array.prototype has been defined with values in its Symbol.unscopables object. If it were not, one can see how this would be a difficult issue to debug.
with\nThe following with statement specifies that the Math object is the default object. The statements following the with statement refer to the PI property and the cos and sin methods, without specifying an object. JavaScript assumes the Math object for these references.
var a, x, y;\nvar r = 10;\n\nwith (Math) {\n a = PI * r * r;\n x = r * cos(PI);\n y = r * sin(PI / 2);\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'with statement' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'with statement' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'with statement' in that specification. | Standard | Now forbidden in strict mode. |
| ECMAScript 3rd Edition (ECMA-262) The definition of 'with statement' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) The definition of 'with statement' in that specification. | Standard | Initial definition |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/with\n
The let statement declares a block scope local variable, optionally initializing it to a value.
let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN];
var1, var2, …, varN\nvalue1, value2, …, valueN Optional\nlet allows you to declare variables that are limited in scope to the block, statement, or expression on which it is used. This is unlike the var keyword, which defines a variable globally, or locally to an entire function regardless of block scope.
An explanation of why the name \"let\" was chosen can be found here.
Variables declared by let have their scope in the block for which they are defined, as well as in any contained sub-blocks. In this way, let works very much like var. The main difference is that the scope of a var variable is the entire enclosing function:
function varTest() {\n var x = 1;\n if (true) {\n var x = 2; // same variable!\n console.log(x); // 2\n }\n console.log(x); // 2\n}\n\nfunction letTest() {\n let x = 1;\n if (true) {\n let x = 2; // different variable\n console.log(x); // 2\n }\n console.log(x); // 1\n}\n At the top level of programs and functions, let, unlike var, does not create a property on the global object. For example:
var x = 'global';\nlet y = 'global';\nconsole.log(this.x); // \"global\"\nconsole.log(this.y); // undefined\n
In dealing with constructors it is possible to use the let bindings to share one or more private members without using closures:
var Thing;\n\n{\n let privateScope = new WeakMap();\n let counter = 0;\n\n Thing = function() {\n this.someProperty = 'foo';\n \n privateScope.set(this, {\n hidden: ++counter,\n });\n };\n\n Thing.prototype.showPublic = function() {\n return this.someProperty;\n };\n\n Thing.prototype.showPrivate = function() {\n return privateScope.get(this).hidden;\n };\n}\n\nconsole.log(typeof privateScope);\n// \"undefined\"\n\nvar thing = new Thing();\n\nconsole.log(thing);\n// Thing {someProperty: \"foo\"}\n\nthing.showPublic();\n// \"foo\"\n\nthing.showPrivate();\n// 1\n The same privacy pattern with closures over local variables can be created with var, but those need a function scope (typically an IIFE in the module pattern) instead of just a block scope like in the example above.
Redeclaring the same variable within the same function or block scope raises a SyntaxError.
if (x) {\n let foo;\n let foo; // SyntaxError thrown.\n}\n You may encounter errors in switch statements because there is only one block.
let x = 1;\nswitch(x) {\n case 0:\n let foo;\n break;\n \n case 1:\n let foo; // SyntaxError for redeclaration.\n break;\n} However, it's important to point out that a block nested inside a case clause will create a new block scoped lexical environment, which will not produce the redeclaration errors shown above.
let x = 1;\n\nswitch(x) {\n case 0: {\n let foo;\n break;\n } \n case 1: {\n let foo;\n break;\n }\n} let bindings are created at the top of the (block) scope containing the declaration, commonly referred to as \"hoisting\". Unlike variables declared with var, which will start with the value undefined, let variables are not initialized until their definition is evaluated. Accessing the variable before the initialization results in a ReferenceError. The variable is in a \"temporal dead zone\" from the start of the block until the initialization is processed.
function do_something() {\n console.log(bar); // undefined\n console.log(foo); // ReferenceError\n var bar = 1;\n let foo = 2;\n} typeof\nUnlike with simply undeclared variables and variables that hold a value of undefined, using the typeof operator to check for the type of a variable in that variable's TDZ will throw a ReferenceError:
// prints out 'undefined'\nconsole.log(typeof undeclaredVariable);\n// results in a 'ReferenceError'\nconsole.log(typeof i);\nlet i = 10;
Due to lexical scoping, the identifier \"foo\" inside the expression (foo + 55) evaluates to the if block's foo, and not the overlying variable foo with the value of 33.
In that very line, the if block's \"foo\" has already been created in the lexical environment, but has not yet reached (and terminated) its initialization (which is part of the statement itself): it's still in the temporal dead zone.
function test(){\n var foo = 33;\n if (true) {\n let foo = (foo + 55); // ReferenceError\n }\n}\ntest(); This phenomenon may confuse you in a situation like the following. The instruction let n of n.a is already inside the private scope of the for loop's block, hence the identifier \"n.a\" is resolved to the property 'a' of the 'n' object located in the first part of the instruction itself (\"let n\"), which is still in the temporal dead zone since its declaration statement has not been reached and terminated.
function go(n) {\n // n here is defined!\n console.log(n); // Object {a: [1,2,3]}\n\n for (let n of n.a) { // ReferenceError\n console.log(n);\n }\n}\n\ngo({a: [1, 2, 3]});\n When used inside a block, let limits the variable's scope to that block. Note the difference between varwhose scope is inside the function where it is declared.
var a = 1;\nvar b = 2;\n\nif (a === 1) {\n var a = 11; // the scope is global\n let b = 22; // the scope is inside the if-block\n\n console.log(a); // 11\n console.log(b); // 22\n} \n\nconsole.log(a); // 11\nconsole.log(b); // 2 | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Let and Const Declarations' in that specification. | Standard | Initial definition. Does not specify let expressions or let blocks. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Let and Const Declarations' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 49\n
| \n12 | \n 44\n
| \n11 | \n17 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n 49\n
| \n 49\n
| \n12 | \n 44\n
| \n17 | \n10 | \n4.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
varconstlet and constlet and const in Firefox 44\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let\n
The throw throws a user-defined exception. Execution of the current function will stop (the statements after throw won't be executed), and control will be passed to the first catch block in the call stack. If no catch block exists among caller functions, the program will terminate.
throw expression;
expressionUse the throw statement to throw an exception. When you throw an exception, expression specifies the value of the exception. Each of the following throws an exception:
throw 'Error2'; // generates an exception with a string value\nthrow 42; // generates an exception with the value 42\nthrow true; // generates an exception with the value true\nthrow new Error('Required'); // generates an error object with the message of Required\n Also note that the throw statement is affected by automatic semicolon insertion (ASI) as no line terminator between the throw keyword and the expression is allowed.
You can specify an object when you throw an exception. You can then reference the object's properties in the catch block. The following example creates an object of type UserException and uses it in a throw statement.
function UserException(message) {\n this.message = message;\n this.name = 'UserException';\n}\nfunction getMonthName(mo) {\n mo = mo - 1; // Adjust month number for array index (1 = Jan, 12 = Dec)\n var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',\n 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\n if (months[mo] !== undefined) {\n return months[mo];\n } else {\n throw new UserException('InvalidMonthNo');\n }\n}\n\ntry {\n // statements to try\n var myMonth = 15; // 15 is out of bound to raise the exception\n var monthName = getMonthName(myMonth);\n} catch (e) {\n monthName = 'unknown';\n console.log(e.message, e.name); // pass exception object to err handler\n}\n The following example tests an input string for a U.S. zip code. If the zip code uses an invalid format, the throw statement throws an exception by creating an object of type ZipCodeFormatException.
/*\n * Creates a ZipCode object.\n *\n * Accepted formats for a zip code are:\n * 12345\n * 12345-6789\n * 123456789\n * 12345 6789\n *\n * If the argument passed to the ZipCode constructor does not\n * conform to one of these patterns, an exception is thrown.\n */\n\nfunction ZipCode(zip) {\n zip = new String(zip);\n pattern = /[0-9]{5}([- ]?[0-9]{4})?/;\n if (pattern.test(zip)) {\n // zip code value will be the first match in the string\n this.value = zip.match(pattern)[0];\n this.valueOf = function() {\n return this.value\n };\n this.toString = function() {\n return String(this.value)\n };\n } else {\n throw new ZipCodeFormatException(zip);\n }\n}\n\nfunction ZipCodeFormatException(value) {\n this.value = value;\n this.message = 'does not conform to the expected format for a zip code';\n this.toString = function() {\n return this.value + this.message;\n };\n}\n\n/*\n * This could be in a script that validates address data\n * for US addresses.\n */\n\nconst ZIPCODE_INVALID = -1;\nconst ZIPCODE_UNKNOWN_ERROR = -2;\n\nfunction verifyZipCode(z) {\n try {\n z = new ZipCode(z);\n } catch (e) {\n if (e instanceof ZipCodeFormatException) {\n return ZIPCODE_INVALID;\n } else {\n return ZIPCODE_UNKNOWN_ERROR;\n }\n }\n return z;\n}\n\na = verifyZipCode(95060); // returns 95060\nb = verifyZipCode(9560); // returns -1\nc = verifyZipCode('a'); // returns -1\nd = verifyZipCode('95060'); // returns 95060\ne = verifyZipCode('95060 1234'); // returns 95060 1234\n You can use throw to rethrow an exception after you catch it. The following example catches an exception with a numeric value and rethrows it if the value is over 50. The rethrown exception propagates up to the enclosing function or to the top level so that the user sees it.
try {\n throw n; // throws an exception with a numeric value\n} catch (e) {\n if (e <= 50) {\n // statements to handle exceptions 1-50\n } else {\n // cannot handle this exception, so rethrow\n throw e;\n }\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.4 |
| ECMAScript 5.1 (ECMA-262) The definition of 'throw statement' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'throw statement' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'throw statement' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw\n
The return ends function execution and specifies a value to be returned to the function caller.
return [[expression]];
expressionundefined is returned instead.When a return statement is used in a function body, the execution of the function is stopped. If specified, a given value is returned to the function caller. For example, the following function returns the square of its argument, x, where x is a number.
function square(x) {\n return x * x;\n}\nvar demo = square(3);\n// demo will equal 9\n If the value is omitted, undefined is returned instead.
The following return statements all break the function execution:
return;\nreturn true;\nreturn false;\nreturn x;\nreturn x + y / 3;\n
The return statement is affected by automatic semicolon insertion (ASI). No line terminator is allowed between the return keyword and the expression.
return\na + b;\n
is transformed by ASI into:
return; \na + b;\n
The console will warn \"unreachable code after return statement\".
To avoid this problem (to prevent ASI), you could use parentheses:
return (\n a + b\n);\n
A function immediately stops at the point where return is called.
function counter() {\n for (var count = 1; ; count++) { // infinite loop\n console.log(count + 'A'); // until 5\n if (count === 5) { \n return;\n }\n console.log(count + 'B'); // until 4\n }\n console.log(count + 'C'); // never appears\n}\n\ncounter();\n\n// Output:\n// 1A\n// 1B\n// 2A\n// 2B\n// 3A\n// 3B\n// 4A\n// 4B\n// 5A\n See also the article about Closures.
function magic() {\n return function calc(x) { return x * 42; };\n}\n\nvar answer = magic();\nanswer(1337); // 56154\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Return statement' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Return statement' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Return statement' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/return\n
An arrow function expression has a shorter syntax than a function expression and does not have its own this, arguments, super, or new.target. These function expressions are best suited for non-method functions, and they cannot be used as constructors.
(param1, param2, …, paramN) => { statements } \n(param1, param2, …, paramN) => expression\n// equivalent to: => { return expression; } \n\n// Parentheses are optional when there's only one parameter name:\n(singleParam) => { statements }\nsingleParam => { statements }\n\n// The parameter list for a function with no parameters should be written with a pair of parentheses.\n() => { statements }\n // Parenthesize the body of function to return an object literal expression:\nparams => ({foo: bar}) \n\n// Rest parameters and default parameters are supported\n(param1, param2, ...rest) => { statements } \n(param1 = defaultValue1, param2, …, paramN = defaultValueN) => { \nstatements } \n\n// Destructuring within the parameter list is also supported\nvar f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;\nf(); // 6\n See also \"ES6 In Depth: Arrow functions\" on hacks.mozilla.org.
Two factors influenced the introduction of arrow functions: shorter functions and no existence of this keyword.
var elements = [\n 'Hydrogen',\n 'Helium',\n 'Lithium',\n 'Beryllium'\n];\n\nelements.map(function(element) { \n return element.length; \n}); // [8, 6, 7, 9]\n\nelements.map(element => {\n return element.length;\n}); // [8, 6, 7, 9]\n\nelements.map(element => element.length); // [8, 6, 7, 9]\n\nelements.map(({ length }) => length); // [8, 6, 7, 9]\n
this\nUntil arrow functions, every new function defined its own this value (based on how function was called, a new object in the case of a constructor, undefined in strict mode function calls, the base object if the function is called as an \"object method\", etc.). This proved to be less than ideal with an object-oriented style of programming.
function Person() {\n // The Person() constructor defines `this` as an instance of itself.\n this.age = 0;\n\n setInterval(function growUp() {\n // In non-strict mode, the growUp() function defines `this` \n // as the global object (because it's where growUp() is executed.), \n // which is different from the `this`\n // defined by the Person() constructor. \n this.age++;\n }, 1000);\n}\n\nvar p = new Person(); In ECMAScript 3/5, the this issue was fixable by assigning the value in this to a variable that could be closed over.
function Person() {\n var that = this;\n that.age = 0;\n\n setInterval(function growUp() {\n // The callback refers to the `that` variable of which\n // the value is the expected object.\n that.age++;\n }, 1000);\n} Alternatively, a bound function could be created so that a preassigned this value would be passed to the bound target function (the growUp() function in the example above).
An arrow function does not have its own this; the this value of the enclosing lexical context is used i.e. Arrow functions follow the normal variable lookup rules. So while searching for this which is not present in current scope they end up finding this from its enclosing scope . Thus, in the following code, the this within the function that is passed to setInterval has the same value as this in the lexically enclosing function:
function Person(){\n this.age = 0;\n\n setInterval(() => {\n this.age++; // |this| properly refers to the Person object\n }, 1000);\n}\n\nvar p = new Person(); Given that this comes from the surrounding lexical context, strict mode rules with regard to this are ignored.
var f = () => { 'use strict'; return this; };\nf() === window; // or the global object All other strict mode rules apply normally.
Since arrow functions do not have their own this, the methods call() or apply() can only pass in parameters. thisArg is ignored.
var adder = {\n base: 1,\n\n add: function(a) {\n var f = v => v + this.base;\n return f(a);\n },\n\n addThruCall: function(a) {\n var f = v => v + this.base;\n var b = {\n base: 2\n };\n\n return f.call(b, a);\n }\n};\n\nconsole.log(adder.add(1)); // This would log to 2\nconsole.log(adder.addThruCall(1)); // This would log to 2 still arguments\nArrow functions do not have their own arguments object. Thus, in this example, arguments is simply a reference to the arguments of the enclosing scope:
var arguments = [1, 2, 3];\nvar arr = () => arguments[0];\n\narr(); // 1\n\nfunction foo(n) {\n var f = () => arguments[0] + n; // foo's implicit arguments binding. arguments[0] is n\n return f();\n}\n\nfoo(3); // 6 In most cases, using rest parameters is a good alternative to using an arguments object.
function foo(n) { \n var f = (...args) => args[0] + n; \n return f(10); \n}\n\nfoo(1); // 11 As stated previously, arrow function expressions are best suited for non-method functions. Let's see what happens when we try to use them as methods:
'use strict';\n\nvar obj = {\n i: 10,\n b: () => console.log(this.i, this),\n c: function() {\n console.log(this.i, this);\n }\n}\n\nobj.b(); // prints undefined, Window {...} (or the global object)\nobj.c(); // prints 10, Object {...} Arrow functions do not have their own this. Another example involving Object.defineProperty():
'use strict';\n\nvar obj = {\n a: 10\n};\n\nObject.defineProperty(obj, 'b', {\n get: () => {\n console.log(this.a, typeof this.a, this); // undefined 'undefined' Window {...} (or the global object)\n return this.a + 10; // represents global object 'Window', therefore 'this.a' returns 'undefined'\n }\n});\n new operatorArrow functions cannot be used as constructors and will throw an error when used with new.
var Foo = () => {};\nvar foo = new Foo(); // TypeError: Foo is not a constructor prototype propertyArrow functions do not have a prototype property.
var Foo = () => {};\nconsole.log(Foo.prototype); // undefined\n yield keywordThe yield keyword may not be used in an arrow function's body (except when permitted within functions further nested within it). As a consequence, arrow functions cannot be used as generators.
Arrow functions can have either a \"concise body\" or the usual \"block body\".
In a concise body, only an expression is specified, which becomes the implicit return value. In a block body, you must use an explicit return statement.
var func = x => x * x; \n// concise body syntax, implied \"return\"\n\nvar func = (x, y) => { return x + y; }; \n// with block body, explicit \"return\" needed\n Keep in mind that returning object literals using the concise body syntax params => {object:literal} will not work as expected.
var func = () => { foo: 1 }; \n// Calling func() returns undefined!\n\nvar func = () => { foo: function() {} }; \n// SyntaxError: function statement requires a name This is because the code inside braces ({}) is parsed as a sequence of statements (i.e. foo is treated like a label, not a key in an object literal).
Remember to wrap the object literal in parentheses.
var func = () => ({foo: 1}); An arrow function cannot contain a line break between its parameters and its arrow.
var func = ()\n => 1; \n// SyntaxError: expected expression, got '=>'
Although the arrow in an arrow function is not an operator, arrow functions have special parsing rules that interact differently with operator precedence compared to regular functions.
let callback;\n\ncallback = callback || function() {}; // ok\n\ncallback = callback || () => {}; \n// SyntaxError: invalid arrow-function arguments\n\ncallback = callback || (() => {}); // ok\n // An empty arrow function returns undefined\nlet empty = () => {};\n\n(() => 'foobar')(); \n// Returns \"foobar\"\n// (this is an Immediately Invoked Function Expression \n// see 'IIFE' in glossary)\n\nvar simple = a => a > 15 ? 15 : a; \nsimple(16); // 15\nsimple(10); // 10\n\nlet max = (a, b) => a > b ? a : b;\n\n// Easy array filtering, mapping, ...\n\nvar arr = [5, 6, 13, 0, 1, 18, 23];\n\nvar sum = arr.reduce((a, b) => a + b); \n// 66\n\nvar even = arr.filter(v => v % 2 == 0); \n// [6, 0, 18]\n\nvar double = arr.map(v => v * 2); \n// [10, 12, 26, 0, 2, 36, 46]\n\n// More concise promise chains\npromise.then(a => {\n // ...\n}).then(b => {\n // ...\n});\n\n// Parameterless arrow functions that are visually easier to parse\nsetTimeout( () => {\n console.log('I happen sooner');\n setTimeout( () => {\n // deeper code\n console.log('I happen later');\n }, 1);\n}, 1); \n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Arrow Function Definitions' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Arrow Function Definitions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \nYes | \n 22\n
| \nNo | \n32 | \n10 | \n
| Trailing comma in parameters | \n58 | \n? | \n52 | \nNo | \n45 | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n45 | \n45 | \nYes | \n 22\n
| \n32 | \n10 | \n5.0 | \n
| Trailing comma in parameters | \n58 | \n58 | \n? | \n52 | \n45 | \n? | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Trailing comma in parameters | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions\n
The try...catch statement marks a block of statements to try, and specifies a response, should an exception be thrown.
try {\n try_statements\n}\n[catch (exception_var_1 if condition_1) { // non-standard\n catch_statements_1\n}]\n...\n[catch (exception_var_2) {\n catch_statements_2\n}]\n[finally {\n finally_statements\n}]\n try_statementscatch_statements_1, catch_statements_2\ntry block.exception_var_1, exception_var_2\ncatch clause.condition_1finally_statementstry statement completes. These statements execute regardless of whether an exception was thrown or caught.The try statement consists of a try block, which contains one or more statements. {} must always be used, also for single statements. At least one catch clause, or a finally clause, must be present. This gives us three forms for the try statement:
try...catchtry...finallytry...catch...finallyA catch clause contains statements that specify what to do if an exception is thrown in the try block. That is, you want the try block to succeed, and if it does not succeed, you want to pass control to the catch block. If any statement within the try block (or in a function called from within the try block) throws an exception, control is immediately shifted to the catch clause. If no exception is thrown in the try block, the catch clause is skipped.
The finally clause executes after the try block and catch clause(s) execute but before the statements following the try statement. It always executes, regardless of whether an exception was thrown or caught.
You can nest one or more try statements. If an inner try statement does not have a catch clause, the enclosing try statement's catch clause is entered.
You can also use the try statement to handle JavaScript exceptions. See the JavaScript Guide for more information on JavaScript exceptions.
catch clauseWhen a single, unconditional catch clause is used, the catch block is entered when any exception is thrown. For example, when the exception occurs in the following code, control transfers to the catch clause.
try {\n throw 'myException'; // generates an exception\n}\ncatch (e) {\n // statements to handle any exceptions\n logMyErrors(e); // pass exception object to error handler\n}\n The catch block specifies an identifier (e in the example above) that holds the value specified by the throw statement. The catch block is unique in that JavaScript creates this identifier when the catch block is entered and it adds it to the current scope; the identifier lasts only for the duration of the catch block; after the catch block finishes executing, the identifier is no longer available.
catch clauses Non-standard
This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.
You can also use one or more conditional catch clauses to handle specific exceptions. In this case, the appropriate catch clause is entered when the specified exception is thrown. In the following example, code in the try block can potentially throw three exceptions: TypeError, RangeError, and EvalError. When an exception occurs, control transfers to the appropriate catch clause. If the exception is not one of the specified exceptions and an unconditional catch clause is found, control transfers to that catch clause.
If you use an unconditional catch clause with one or more conditional catch clauses, the unconditional catch clause must be specified last. Otherwise, the unconditional catch clause will intercept all types of exception before they can reach the conditional ones.
Reminder: this functionality is not part of the ECMAScript specification and has been removed in Firefox 59. It's not supported in any current browser anymore.
try {\n myroutine(); // may throw three types of exceptions\n} catch (e if e instanceof TypeError) {\n // statements to handle TypeError exceptions\n} catch (e if e instanceof RangeError) {\n // statements to handle RangeError exceptions\n} catch (e if e instanceof EvalError) {\n // statements to handle EvalError exceptions\n} catch (e) {\n // statements to handle any unspecified exceptions\n logMyErrors(e); // pass exception object to error handler\n}\n Here is the same \"Conditional catch clauses\" using code that conforms to ECMAScript specification (obviously it's verbose, but works everywhere):
try {\n myroutine(); // may throw three types of exceptions\n} catch (e) {\n if (e instanceof TypeError) {\n // statements to handle TypeError exceptions\n } else if (e instanceof RangeError) {\n // statements to handle RangeError exceptions\n } else if (e instanceof EvalError) {\n // statements to handle EvalError exceptions\n } else {\n // statements to handle any unspecified exceptions\n logMyErrors(e); // pass exception object to error handler\n }\n}\n When an exception is thrown in the try block, exception_var (e.g. the e in catch (e)) holds the value specified by the throw statement. You can use this identifier to get information about the exception that was thrown. This identifier is local to the catch clause. That is, it is created when the catch clause is entered, and after the catch clause finishes executing, the identifier is no longer available.
In Firefox 58, when the exception is unused, the identifier can be omitted, as in the code below. This is also allowed in TypeScript 2.5 and later. However, at the time of this writing (August 2018), the proposal to support this has not yet been included into an ECMAScript standard, so this syntax may not work in other browsers.
function isValidJSON(text) {\n try {\n JSON.parse(text);\n return true;\n } catch {\n return false;\n }\n}\n finally clauseThe finally clause contains statements to execute after the try block and catch clause(s) execute, but before the statements following the try..catch..finally block. Note that the finally clause executes regardless of whether an exception is thrown. Also, if an exception is thrown, the statements in the finally clause execute even if no catch clause handles the exception.
You can use the finally clause to make your script fail gracefully when an exception occurs; for example, to do general cleanup, you may need to release a resource that your script has tied up.
It may seem strange to have a special exception-related clause that executes regardless of whether there is an exception, but this construct actually does serve a purpose. The important point is not that the finally-clause always executes, but rather that ordinary code following a try..catch does not.
For instance, if another exception occurs inside a try's catch-block, any remaining code in the same outer try-block enclosing that try..catch (or in the main flow, if not in an outer try-block) , will not get executed, since control is immediately transferred to the outer try's catch-block (or the internal error-generator, if not in a try-block).
Thus, any routine cleanup code done in that enclosed (or the main) section before it exits, will be skipped. However, If the try-block has a finally-block, then that finally-block code will be executed first to permit any such cleanup, and THEN the other try's catch-block (or the error-generator) will get control to handle the second exception.
Now, if that routine cleanup must be done whether or not the try..catch code succeeds, then if the finally-block only executed after an exception, the same cleanup code would have to be duplicated both inside and outside the finally-block, and therefore there is no reason not to have just the finally-block alone, and let it execute regardless of exceptions or not.
The following example opens a file and then executes statements that use the file (server-side JavaScript allows you to access files). If an exception is thrown while the file is open, the finally clause closes the file before the script fails. The code in finally also executes upon explicitly returning from try or catch block.
openMyFile();\ntry {\n // tie up a resource\n writeMyFile(theData);\n}\nfinally {\n closeMyFile(); // always close the resource\n}\n First, let's see what happens with this:
try {\n try {\n throw new Error('oops');\n }\n finally {\n console.log('finally');\n }\n}\ncatch (ex) {\n console.error('outer', ex.message);\n}\n\n// Output:\n// \"finally\"\n// \"outer\" \"oops\"\n Now, if we already caught the exception in the inner try-block by adding a catch block
try {\n try {\n throw new Error('oops');\n }\n catch (ex) {\n console.error('inner', ex.message);\n }\n finally {\n console.log('finally');\n }\n}\ncatch (ex) {\n console.error('outer', ex.message);\n}\n\n// Output:\n// \"inner\" \"oops\"\n// \"finally\"\n And now, let's re-throw the error.
try {\n try {\n throw new Error('oops');\n }\n catch (ex) {\n console.error('inner', ex.message);\n throw ex;\n }\n finally {\n console.log('finally');\n }\n}\ncatch (ex) {\n console.error('outer', ex.message);\n}\n\n// Output:\n// \"inner\" \"oops\"\n// \"finally\"\n// \"outer\" \"oops\"\n Any given exception will be caught only once by the nearest enclosing catch-block unless it is re-thrown. Of course, any new exceptions raised in the \"inner\" block (because the code in catch-block may do something that throws), will be caught by the \"outer\" block.
If the finally block returns a value, this value becomes the return value of the entire try-catch-finally production, regardless of any return statements in the try and catch blocks. This includes exceptions thrown inside of the catch block:
(function() {\n try {\n try {\n throw new Error('oops');\n }\n catch (ex) {\n console.error('inner', ex.message);\n throw ex;\n }\n finally {\n console.log('finally');\n return;\n }\n }\n catch (ex) {\n console.error('outer', ex.message);\n }\n})();\n\n// Output:\n// \"inner\" \"oops\"\n// \"finally\" The outer \"oops\" is not thrown because of the return in the finally block. The same would apply to any value returned from the catch block.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.4 |
| ECMAScript 5.1 (ECMA-262) The definition of 'try statement' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'try statement' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'try statement' in that specification. | Draft | Not part of the current ECMA-262 standard: Multiple catch clauses and conditional clauses (SpiderMonkey extension, JavaScript 1.5). |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| Conditional clauses \n | \nNo | \nNo | \n1 — 59 | \nNo | \nNo | \nNo | \n
| Optional catch binding | \n66 | \nNo | \n58 | \nNo | \n53 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Conditional clauses \n | \nNo | \nNo | \nNo | \n4 — 59 | \nNo | \nNo | \nNo | \n
| Optional catch binding | \n66 | \n66 | \nNo | \n58 | \n53 | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Conditional clauses \n | \nNo | \n
| Optional catch binding | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch\n
The rest parameter syntax allows us to represent an indefinite number of arguments as an array.
function f(a, b, ...theArgs) {\n // ...\n}\n A function's last parameter can be prefixed with ... which will cause all remaining (user supplied) arguments to be placed within a \"standard\" javascript array. Only the last parameter can be a \"rest parameter\".
function myFun(a, b, ...manyMoreArgs) {\n console.log(\"a\", a); \n console.log(\"b\", b);\n console.log(\"manyMoreArgs\", manyMoreArgs); \n}\n\nmyFun(\"one\", \"two\", \"three\", \"four\", \"five\", \"six\");\n\n// Console Output:\n// a, one\n// b, two\n// manyMoreArgs, [three, four, five, six]\n\n arguments objectThere are three main differences between rest parameters and the arguments object:
arguments object contains all arguments passed to the function;arguments object is not a real array, while rest parameters are Array instances, meaning methods like sort, map, forEach or pop can be applied on it directly;arguments object has additional functionality specific to itself (like the callee property).Rest parameters have been introduced to reduce the boilerplate code that was induced by the arguments
// Before rest parameters, \"arguments\" could be converted to a normal array using:\n\nfunction f(a, b) {\n\n var normalArray = Array.prototype.slice.call(arguments);\n // -- or --\n var normalArray = [].slice.call(arguments);\n // -- or --\n var normalArray = Array.from(arguments);\n\n var first = normalArray.shift(); // OK, gives the first argument\n var first = arguments.shift(); // ERROR (arguments is not a normal array)\n\n}\n\n// Now we can easily gain access to a normal array using a rest parameter\n\nfunction f(...args) {\n var normalArray = args;\n var first = normalArray.shift(); // OK, gives the first argument\n}\n Rest parameters can be destructured (arrays only), that means that their data can be unpacked into distinct variables. See Destructuring assignment.
function f(...[a, b, c]) {\n return a + b + c;\n}\n\nf(1) // NaN (b and c are undefined)\nf(1, 2, 3) // 6\nf(1, 2, 3, 4) // 6 (the fourth parameter is not destructured) In this example, the first argument is mapped to \"a\" and the second to \"b\", so these named arguments are used like normal. However the third argument \"manyMoreArgs\" will be an array that contains the 3rd, 4th, 5th, 6th ... nth -- as many arguments that the user includes.
function myFun(a, b, ...manyMoreArgs) {\n console.log(\"a\", a); \n console.log(\"b\", b);\n console.log(\"manyMoreArgs\", manyMoreArgs); \n}\n\nmyFun(\"one\", \"two\", \"three\", \"four\", \"five\", \"six\");\n\n// a, one\n// b, two\n// manyMoreArgs, [three, four, five, six]\n Below... even though there is just one value, the last argument still gets put into an array.
// using the same function definition from example above\n\nmyFun(\"one\", \"two\", \"three\");\n\n// a, one\n// b, two\n// manyMoreArgs, [three]
Below... the third argument wasn't provided, yet \"manyMoreArgs\" is still an array (although empty).
// using the same function definition from example above\n\nmyFun(\"one\", \"two\");\n\n// a, one\n// b, two\n// manyMoreArgs, []
Since theArgs is an array, a count of its elements is given by the length property:
function fun1(...theArgs) {\n console.log(theArgs.length);\n}\n\nfun1(); // 0\nfun1(5); // 1\nfun1(5, 6, 7); // 3\n In the next example, a rest parameter is used to collect all arguments after the first one in an array. Each one of them is then multiplied by the first parameter and the array is returned:
function multiply(multiplier, ...theArgs) {\n return theArgs.map(function(element) {\n return multiplier * element;\n });\n}\n\nvar arr = multiply(2, 1, 2, 3); \nconsole.log(arr); // [2, 4, 6]\n Array methods can be used on rest parameters, but not on the arguments object:
function sortRestArgs(...theArgs) {\n var sortedArgs = theArgs.sort();\n return sortedArgs;\n}\n\nconsole.log(sortRestArgs(5, 3, 7, 1)); // 1, 3, 5, 7\n\nfunction sortArguments() {\n var sortedArgs = arguments.sort(); \n return sortedArgs; // this will never happen\n}\n\n\nconsole.log(sortArguments(5, 3, 7, 1)); // TypeError (arguments.sort is not a function)\n To use Array methods on the arguments object, it must be converted to a real array first.
function sortArguments() {\n var args = Array.from(arguments);\n var sortedArgs = args.sort();\n return sortedArgs;\n}\nconsole.log(sortArguments(5, 3, 7, 1)); // 1, 3, 5, 7\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function Definitions' in that specification. | Standard | Initial definition |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function Definitions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n47 | \n12 | \n15 | \nNo | \n34 | \n10 | \n
| Destructuring rest parameters | \n49 | \nNo | \n52 | \nNo | \n36 | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n47 | \n47 | \n12 | \n15 | \n34 | \n10 | \n5.0 | \n
| Destructuring rest parameters | \n49 | \n49 | \nNo | \n52 | \n36 | \n? | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.0.0\n
| \n
| Destructuring rest parameters | \nYes | \n
...’)\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters\n
RangeError: Invalid code point {0} (Edge)\nRangeError: {0} is not a valid code point (Firefox)\nRangeError: Invalid code point {0} (Chrome)\n The String.fromCodePoint() method accepts valid code points only.
A code point is a value in the Unicode codespace; that is, the range of integers from 0 to 0x10FFFF.
Using NaN values, negative Integers (-1), non-Integers (3.14), or values larger than 0x10FFFF (1114111) won't work with this method.
String.fromCodePoint('_'); // RangeError\nString.fromCodePoint(Infinity); // RangeError\nString.fromCodePoint(-1); // RangeError\nString.fromCodePoint(3.14); // RangeError\nString.fromCodePoint(3e-2); // RangeError\nString.fromCodePoint(NaN); // RangeError String.fromCodePoint(42); // \"*\"\nString.fromCodePoint(65, 90); // \"AZ\"\nString.fromCodePoint(0x404); // \"\\u0404\"\nString.fromCodePoint(0x2F804); // \"\\uD87E\\uDC04\"\nString.fromCodePoint(194564); // \"\\uD87E\\uDC04\"\nString.fromCodePoint(0x1D306, 0x61, 0x1D307) // \"\\uD834\\uDF06a\\uD834\\uDF07\"\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_a_codepoint\n
Default function parameters allow named parameters to be initialized with default values if no value or undefined is passed.
function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {\n statements\n}\n In JavaScript, function parameters default to undefined
In the past, the general strategy for setting defaults was to test parameter values in the function body and assign a value if they are undefined.
In the following example, if no value is provided for b when multiply is called, b’s value would be undefined when evaluating a * b and multiply would return NaN.
function multiply(a, b) {\n return a * b;\n}\n\nmultiply(5, 2); // 10\nmultiply(5); // NaN !\n To guard against this, something like the second line would be used, where b is set to 1 if multiply is called with only one argument:
function multiply(a, b) {\n b = (typeof b !== 'undefined') ? b : 1;\n return a * b;\n}\n\nmultiply(5, 2); // 10\nmultiply(5); // 5\n With default parameters in ES2015, checks in the function body are no longer necessary. Now, you can assign 1 as the default value for b in the function head:
function multiply(a, b = 1) {\n return a * b;\n}\n\nmultiply(5, 2); // 10\nmultiply(5); // 5\n undefined vs. other falsy valuesIn the second call in this example, even if the first argument is set explicitly to undefined (though not null or other falsy values), the value of the num argument is still the default.
function test(num = 1) {\n console.log(typeof num);\n}\n\ntest(); // 'number' (num is set to 1)\ntest(undefined); // 'number' (num is set to 1 too)\n\n// test with other falsy values:\ntest(''); // 'string' (num is set to '')\ntest(null); // 'object' (num is set to null)\n The default argument is evaluated at call time, so unlike e.g. Python, a new object is created each time the function is called.
function append(value, array = []) {\n array.push(value);\n return array;\n}\n\nappend(1); //[1]\nappend(2); //[2], not [1, 2]\n This even applies to functions and variables:
function callSomething(thing = something()) {\n return thing;\n}\n\nlet numberOfTimesCalled = 0;\nfunction something() {\n numberOfTimesCalled += 1;\n return numberOfTimesCalled;\n}\n\ncallSomething(); // 1\ncallSomething(); // 2 Parameters defined beforehand (to the left) are available to later default parameters:
function greet(name, greeting, message = greeting + ' ' + name) {\n return [name, greeting, message];\n}\n\ngreet('David', 'Hi'); // [\"David\", \"Hi\", \"Hi David\"]\ngreet('David', 'Hi', 'Happy Birthday!'); // [\"David\", \"Hi\", \"Happy Birthday!\"]\n This functionality can be approximated like this, which demonstrates how many edge cases are handled:
function go() {\n return ':P';\n}\n\nfunction withDefaults(a, b = 5, c = b, d = go(), e = this, \n f = arguments, g = this.value) {\n return [a, b, c, d, e, f, g];\n}\n\nfunction withoutDefaults(a, b, c, d, e, f, g) {\n switch (arguments.length) {\n case 0:\n a;\n case 1:\n b = 5;\n case 2:\n c = b;\n case 3:\n d = go();\n case 4:\n e = this;\n case 5:\n f = arguments;\n case 6:\n g = this.value;\n default:\n }\n return [a, b, c, d, e, f, g];\n}\n\nwithDefaults.call({value: '=^_^='});\n// [undefined, 5, 5, \":P\", {value:\"=^_^=\"}, arguments, \"=^_^=\"]\n\nwithoutDefaults.call({value: '=^_^='});\n// [undefined, 5, 5, \":P\", {value:\"=^_^=\"}, arguments, \"=^_^=\"]\n Introduced in Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Functions declared in the function body cannot be referred to inside the outer function]s default parameters. If attempted, a ReferenceError is thrown. Default parameters are always executed first, so function declarations inside the function body evaluate afterwards.
// Doesn't work! Throws ReferenceError.\nfunction f(a = go()) {\n function go() { return ':P'; }\n}\n Prior to Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2), the following code resulted in a SyntaxError. This was fixed in bug 777060. Parameters are still set left-to-right, overwriting default parameters even if there are later parameters without defaults.
function f(x = 1, y) { \n return [x, y]; \n}\n\nf(); // [1, undefined]\nf(2); // [2, undefined]\n You can use default value assignment with the destructuring assignment notation:
function f([x, y] = [1, 2], {z: z} = {z: 3}) { \n return x + y + z; \n}\n\nf(); // 6 | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function Definitions' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function Definitions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n14 | \n15 | \nNo | \n36 | \n10 | \n
| Parameters without defaults after default parameters | \n49 | \n14 | \n26 | \nNo | \n36 | \n10 | \n
| Destructured parameter with default value assignment | \n49 | \n? | \n41 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \n14 | \n15 | \n36 | \n10 | \n5.0 | \n
| Parameters without defaults after default parameters | \n49 | \n49 | \n14 | \n26 | \n36 | \n10 | \n5.0 | \n
| Destructured parameter with default value assignment | \n49 | \n49 | \n? | \n41 | \n? | \n? | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
| Parameters without defaults after default parameters | \nYes | \n
| Destructured parameter with default value assignment | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters\n
The constructor method is a special method for creating and initializing an object created within a class.
constructor([arguments]) { ... } There can be only one special method with the name \"constructor\" in a class. Having more than one occurrence of a constructor method in a class will throw a SyntaxError error.
A constructor can use the super keyword to call the constructor of a parent class.
If you do not specify a constructor method, a default constructor is used.
constructor methodThis code snippet is taken from the classes sample (live demo).
class Square extends Polygon {\n constructor(length) {\n // Here, it calls the parent class' constructor with lengths\n // provided for the Polygon's width and height\n super(length, length);\n // Note: In derived classes, super() must be called before you\n // can use 'this'. Leaving this out will cause a reference error.\n this.name = 'Square';\n }\n\n get area() {\n return this.height * this.width;\n }\n\n set area(value) {\n this.area = value;\n } \n} Take a look at this code snippet
class Polygon {\n constructor() {\n this.name = \"Polygon\";\n }\n}\n\nclass Square extends Polygon {\n constructor() {\n super();\n }\n}\n\nclass Rectangle {}\n\nObject.setPrototypeOf(Square.prototype, Rectangle.prototype);\n\nconsole.log(Object.getPrototypeOf(Square.prototype) === Polygon.prototype); //false\nconsole.log(Object.getPrototypeOf(Square.prototype) === Rectangle.prototype); //true\n\nlet newInstance = new Square();\nconsole.log(newInstance.name); //Polygon Here the prototype of Square class is changed but still the constructor of the previous base class Polygon is called when a new instance of a square is being created.
As stated, if you do not specify a constructor method a default constructor is used. For base classes the default constructor is:
constructor() {}\n For derived classes, the default constructor is:
constructor(...args) {\n super(...args);\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Constructor Method' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Constructor Method' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 49\n
| \n13 | \n45 | \nNo | \n36 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \nYes | \n13 | \n45 | \n? | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/constructor\n
Error: Permission denied to access property \"x\"\n
There was attempt to access an object for which you have no permission. This is likely an <iframe> element loaded from a different domain for which you violated the same-origin policy.
<!DOCTYPE html>\n<html>\n <head>\n <iframe id=\"myframe\" src=\"http://www1.w3c-test.org/common/blank.html\"></iframe>\n <script>\n onload = function() {\n console.log(frames[0].document);\n // Error: Permission denied to access property \"document\"\n }\n </script>\n </head>\n <body></body>\n</html> \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Property_access_denied\n
RangeError: The number of fractional digits is out of range (Edge)\nRangeError: The precision is out of range (Edge)\nRangeError: precision {0} out of range (Firefox)\nRangeError: toExponential() argument must be between 0 and 20 (Chrome)\nRangeError: toFixed() digits argument must be between 0 and 20 (Chrome)\nRangeError: toPrecision() argument must be between 1 and 21 (Chrome)\n There was an out of range precision argument in one of these methods:
The allowed range for these methods is usually between 0 and 20 (or 21). However, the ECMAScript specification allows to extend this range.
| Method | Firefox (SpiderMonkey) | Chrome, Opera (V8) |
|---|---|---|
Number.prototype.toExponential() | 0 to 100 | 0 to 20 |
Number.prototype.toFixed() | -20 to 100 | 0 to 20 |
Number.prototype.toPrecision() | 1 to 100 | 1 to 21 |
77.1234.toExponential(-1); // RangeError\n77.1234.toExponential(101); // RangeError\n\n2.34.toFixed(-100); // RangeError \n2.34.toFixed(1001); // RangeError \n\n1234.5.toPrecision(-1); // RangeError\n1234.5.toPrecision(101); // RangeError\n
77.1234.toExponential(4); // 7.7123e+1\n77.1234.toExponential(2); // 7.71e+1\n\n2.34.toFixed(1); // 2.3\n2.35.toFixed(1); // 2.4 (note that it rounds up in this case)\n\n5.123456.toPrecision(5); // 5.1235\n5.123456.toPrecision(2); // 5.1\n5.123456.toPrecision(1); // 5\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Precision_range\n
The set syntax binds an object property to a function to be called when there is an attempt to set that property.
{set prop(val) { . . . }}\n{set [expression](val) { . . . }} propvalprop.\nIn JavaScript, a setter can be used to execute a function whenever a specified property is attempted to be changed. Setters are most often used in conjunction with getters to create a type of pseudo-property. It is not possible to simultaneously have a setter on a property that holds an actual value.
Note the following when working with the set syntax:
set or with a data entry for the same property.{ set x(v) { }, set x(v) { } } and { x: ..., set x(v) { } } are forbidden )A setter can be removed using the delete operator.
This will define a pseudo-property current of object language that, when assigned a value, will update log with that value:
var language = {\n set current(name) {\n this.log.push(name);\n },\n log: []\n}\n\nlanguage.current = 'EN';\nconsole.log(language.log); // ['EN']\n\nlanguage.current = 'FA';\nconsole.log(language.log); // ['EN', 'FA']\n Note that current is not defined and any attempts to access it will result in undefined.
delete operatorIf you want to remove the setter, you can just delete it:
delete o.current;\n
defineProperty\nTo append a setter to an existing object later at any time, use Object.defineProperty().
var o = {a: 0};\n\nObject.defineProperty(o, 'b', { set: function(x) { this.a = x / 2; } });\n\no.b = 10; // Runs the setter, which assigns 10 / 2 (5) to the 'a' property\nconsole.log(o.a) // 5 var expr = 'foo';\n\nvar obj = {\n baz: 'bar',\n set [expr](v) { this.baz = v; }\n};\n\nconsole.log(obj.baz); // \"bar\"\nobj.foo = 'baz'; // run the setter\nconsole.log(obj.baz); // \"baz\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object Initializer' in that specification. | Standard | Initial definition. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Method definitions' in that specification. | Standard | Added computed property names. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Method definitions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n2 | \n9 | \n9.5 | \n3 | \n
| Computed property names | \n46 | \nYes | \n34 | \nNo | \n47 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n1 | \n18 | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Computed property names | \n46 | \n46 | \nYes | \n34 | \nYes | \nNo | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Computed property names | \nYes | \n
deleteObject.defineProperty()__defineGetter____defineSetter__\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/set\n
The extends keyword is used in class declarations or class expressions to create a class which is a child of another class.
class ChildClass extends ParentClass { ... } The extends keyword can be used to subclass custom classes as well as built-in objects.
The .prototype of the extension must be an Object or null.
extends\nThe first example creates a class called Square from a class called Polygon. This example is extracted from this live demo (source).
class Square extends Polygon {\n constructor(length) {\n // Here, it calls the parent class' constructor with lengths\n // provided for the Polygon's width and height\n super(length, length);\n // Note: In derived classes, super() must be called before you\n // can use 'this'. Leaving this out will cause a reference error.\n this.name = 'Square';\n }\n\n get area() {\n return this.height * this.width;\n }\n} extends with built-in objectsThis example extends the built-in Date object. This example is extracted from this live demo (source).
class myDate extends Date {\n constructor() {\n super();\n }\n\n getFormattedDate() {\n var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\n return this.getDate() + '-' + months[this.getMonth()] + '-' + this.getFullYear();\n }\n} null\nExtending from null works like with a normal class, except that the prototype object does not inherit from Object.prototype.
class nullExtends extends null {\n constructor() {}\n}\n\nObject.getPrototypeOf(nullExtends); // Function.prototype\nObject.getPrototypeOf(nullExtends.prototype) // null\n\nnew nullExtends(); //ReferenceError: this is not defined\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'extends' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'extends' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 49\n
| \n13 | \n45 | \nNo | \n36 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \nYes | \n13 | \n45 | \n? | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/extends\n
RangeError: Array length must be a finite positive integer (Edge)\nRangeError: invalid array length (Firefox)\nRangeError: Invalid array length (Chrome)\nRangeError: Invalid array buffer length (Chrome)\n
An invalid array length might appear in these situations:
Array or an ArrayBuffer which has a length which is either negative or larger or equal to 232, orArray.length property to a value which is either negative or larger or equal to 232.Why are Array and ArrayBuffer length limited? The length property of an Array or an ArrayBuffer is represented with an unsigned 32-bit integer, that can only store values which are in the range from 0 to 232-1.
If you are creating an Array, using the constructor, you probably want to use the literal notation instead, as the first argument is interpreted as the length of the Array.
Otherwise, you might want to clamp the length before setting the length property, or using it as argument of the constructor.
new Array(Math.pow(2, 40))\nnew Array(-1)\nnew ArrayBuffer(Math.pow(2, 32))\nnew ArrayBuffer(-1)\n\nlet a = [];\na.length = a.length - 1; // set -1 to the length property\n\nlet b = new Array(Math.pow(2, 32) - 1);\nb.length = b.length + 1; // set 2^32 to the length property\n
[ Math.pow(2, 40) ] // [ 1099511627776 ]\n[ -1 ] // [ -1 ]\nnew ArrayBuffer(Math.pow(2, 32) - 1)\nnew ArrayBuffer(0)\n\nlet a = [];\na.length = Math.max(0, a.length - 1);\n\nlet b = new Array(Math.pow(2, 32) - 1);\nb.length = Math.min(0xffffffff, b.length + 1); \n\n// 0xffffffff is the hexadecimal notation for 2^32 - 1\n// which can also be written as (-1 >>> 0)\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length\n
Starting with ECMAScript 2015, a shorter syntax for method definitions on objects initializers is introduced. It is a shorthand for a function assigned to the method's name.
var obj = {\n property( parameters… ) {},\n *generator( parameters… ) {},\n async property( parameters… ) {},\n async* generator( parameters… ) {},\n\n // with computed keys:\n [property]( parameters… ) {},\n *[generator]( parameters… ) {},\n async [property]( parameters… ) {},\n\n // compare getter/setter syntax:\n get property() {},\n set property(value) {}\n};\n The shorthand syntax is similar to the getter and setter syntax introduced in ECMAScript 2015.
Given the following code:
var obj = {\n foo: function() {\n /* code */\n },\n bar: function() {\n /* code */\n }\n};\n You are now able to shorten this to:
var obj = {\n foo() {\n /* code */\n },\n bar() {\n /* code */\n }\n};\n\n Generator methods can be defined using the shorthand syntax as well. When using them,
* g(){} will work but g *(){} will not;non-generator method definitions may not contain the yield keyword. This means that legacy generator functions won't work either and will throw a SyntaxError. Always use yield in conjunction with the asterisk (*).
// Using a named property\nvar obj2 = {\n g: function* () {\n var index = 0;\n while (true)\n yield index++;\n }\n};\n\n// The same object using shorthand syntax\nvar obj2 = { \n * g() {\n var index = 0;\n while (true)\n yield index++;\n }\n};\n\nvar it = obj2.g();\nconsole.log(it.next().value); // 0\nconsole.log(it.next().value); // 1 Async methods can also be defined using the shorthand syntax.
// Using a named property\nvar obj3 = {\n f: async function () {\n await some_promise;\n }\n};\n\n// The same object using shorthand syntax\nvar obj3 = { \n async f() {\n await some_promise;\n }\n};\n Generator methods can also be async.
var obj4 = {\n f: async function* () {\n yield 1;\n yield 2;\n yield 3;\n }\n};\n\n// The same object using shorthand syntax\nvar obj4 = {\n async* f() {\n yield 1;\n yield 2;\n yield 3;\n }\n}; All method definitions are not constructors and will throw a TypeError if you try to instantiate them.
var obj = { \n method() {}\n};\nnew obj.method; // TypeError: obj.method is not a constructor\n\nvar obj = { \n * g() {} \n};\nnew obj.g; // TypeError: obj.g is not a constructor (changed in ES2016)\n var obj = {\n a: 'foo',\n b() { return this.a; }\n};\nconsole.log(obj.b()); // \"foo\"\n The shorthand syntax also supports computed property names.
var bar = {\n foo0: function() { return 0; },\n foo1() { return 1; },\n ['foo' + 2]() { return 2; }\n};\n\nconsole.log(bar.foo0()); // 0\nconsole.log(bar.foo1()); // 1\nconsole.log(bar.foo2()); // 2 | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Method definitions' in that specification. | Standard | Initial definition. |
| ECMAScript 2016 (ECMA-262) The definition of 'Method definitions' in that specification. | Standard | Changed that generator methods should also not have a [[Construct]] trap and will throw when used with new. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Method definitions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n39 | \nYes | \n34 | \nNo | \n26 | \nNo | \n
| Generator methods are not constructable (ES2016) | \n? | \n? | \n43 | \nNo | \n? | \n? | \n
| Async methods | \n? | \n? | \n52 | \nNo | \n? | \n? | \n
| Async generator methods | \n? | \n? | \n55 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n39 | \n39 | \nYes | \n34 | \n26 | \nNo | \n4.0 | \n
| Generator methods are not constructable (ES2016) | \n? | \n? | \n? | \n43 | \n? | \n? | \n? | \n
| Async methods | \n? | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| Async generator methods | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Generator methods are not constructable (ES2016) | \n? | \n
| Async methods | \n 7.6.0\n
| \n
| Async generator methods | \n 10.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions\n
The get syntax binds an object property to a function that will be called when that property is looked up.
{get prop() { ... } }\n{get [expression]() { ... } } propSometimes it is desirable to allow access to a property that returns a dynamically computed value, or you may want to reflect the status of an internal variable without requiring the use of explicit method calls. In JavaScript, this can be accomplished with the use of a getter. It is not possible to simultaneously have a getter bound to a property and have that property actually hold a value, although it is possible to use a getter and a setter in conjunction to create a type of pseudo-property.
Note the following when working with the get syntax:
get or with a data entry for the same property ({ get x() { }, get x() { } } and { x: ..., get x() { } } are forbidden).A getter can be removed using the delete operator.
This will create a pseudo-property latest for object obj, which will return the last array item in log.
var obj = {\n log: ['example','test'],\n get latest() {\n if (this.log.length == 0) return undefined;\n return this.log[this.log.length - 1];\n }\n}\nconsole.log(obj.latest); // \"test\".\n Note that attempting to assign a value to latest will not change it.
delete operatorIf you want to remove the getter, you can just delete it:
delete obj.latest;\n
defineProperty\nTo append a getter to an existing object later at any time, use Object.defineProperty().
var o = {a: 0};\n\nObject.defineProperty(o, 'b', { get: function() { return this.a + 1; } });\n\nconsole.log(o.b) // Runs the getter, which yields a + 1 (which is 1) var expr = 'foo';\n\nvar obj = {\n get [expr]() { return 'bar'; }\n};\n\nconsole.log(obj.foo); // \"bar\" Getters give you a way to define a property of an object, but they do not calculate the property's value until it is accessed. A getter defers the cost of calculating the value until the value is needed, and if it is never needed, you never pay the cost.
An additional optimization technique to lazify or delay the calculation of a property value and cache it for later access are smart or memoized getters. The value is calculated the first time the getter is called, and is then cached so subsequent accesses return the cached value without recalculating it. This is useful in the following situations:
This means that you shouldn't use a lazy getter for a property whose value you expect to change, because the getter will not recalculate the value.
In the following example, the object has a getter as its own property. On getting the property, the property is removed from the object and re-added, but implicitly as a data property this time. Finally the value gets returned.
get notifier() {\n delete this.notifier;\n return this.notifier = document.getElementById('bookmarked-notification-anchor');\n}, For Firefox code, see also the XPCOMUtils.jsm code module, which defines the defineLazyGetter() function.
get Vs. defineProperty\nWhile using the get keyword and Object.defineProperty() have similar results there is a subtle difference between the two when used on classes.
When using get the property will be defined on the prototype of the object while using Object.defineProperty() the property will be defined on the instance it is applied to.
class Example {\n get hello() {\n return 'world';\n }\n}\n\nconst obj = new Example();\nconsole.log(obj.hello);\n// \"world\"\nconsole.log(Object.getOwnPropertyDescriptor(obj, 'hello'));\n// undefined\nconsole.log(Object.getOwnPropertyDescriptor(Object.getPrototypeOf(obj), 'hello'));\n// { configurable: true, enumerable: false, get: function get hello() { return 'world'; }, set: undefined } | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object Initializer' in that specification. | Standard | Initial definition. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Method definitions' in that specification. | Standard | Added computed property names. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Method definitions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n2 | \n9 | \n9.5 | \n3 | \n
| Computed property names | \n46 | \nYes | \n34 | \nNo | \n47 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n1 | \n18 | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Computed property names | \n46 | \n46 | \nYes | \n34 | \nYes | \nNo | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Computed property names | \nYes | \n
deleteObject.defineProperty()__defineGetter____defineSetter__\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get\n
RangeError: invalid date (Edge)\nRangeError: invalid date (Firefox)\nRangeError: invalid time value (Chrome)\nRangeError: Provided date is not in valid range (Chrome)\n
A string leading to an invalid date has been provided to Date or Date.parse().
Unrecognizable strings or dates containing illegal element values in ISO formatted strings usually return NaN. However, depending on the implementation, non–conforming ISO format strings, may also throw RangeError: invalid date, like the following cases in Firefox:
new Date('foo-bar 2014');\nnew Date('2014-25-23').toISOString();\nnew Date('foo-bar 2014').toString();\n This, however, returns NaN in Firefox:
Date.parse('foo-bar 2014'); // NaN For more details, see the Date.parse() documentation.
new Date('05 October 2011 14:48 UTC'); \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_date\n
RangeError: argument out of range (Edge)\nRangeError: repeat count must be less than infinity and not overflow maximum string size (Firefox)\n\nRangeError: Invalid count value (Chrome)\n
The String.prototype.repeat() method has been used. It has a count parameter indicating the number of times to repeat the string. It must be between 0 and less than positive Infinity and cannot be a negative number. The range of allowed values can be described like this: [0, +∞).
The resulting string can also not be larger than the maximum string size, which can differ in JavaScript engines. In Firefox (SpiderMonkey) the maximum string size is 228 -1 (0xFFFFFFF).
'abc'.repeat(Infinity); // RangeError\n'a'.repeat(2**28); // RangeError\n
'abc'.repeat(0); // ''\n'abc'.repeat(1); // 'abc'\n'abc'.repeat(2); // 'abcabc'\n'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer)\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Resulting_string_too_large\n
RangeError: invalid argument (Edge)\nRangeError: radix must be an integer at least 2 and no greater than 36 (Firefox)\nRangeError: toString() radix argument must be between 2 and 36 (Chrome)\n
The optional radix parameter of the Number.prototype.toString() method was specified. Its value must be an integer (a number) between 2 and 36, specifying the base of the number system to be used for representing numeric values. For example, the decimal (base 10) number 169 is represented in hexadecimal (base 16) as A9.
Why is this parameter's value limited to 36? A radix that is larger than 10 uses alphabetical characters as digits; therefore, the radix can't be larger than 36, since the Latin alphabet (used by English and many other languages) only has 26 characters.
The most common radixes:
(42).toString(0);\n(42).toString(1);\n(42).toString(37);\n(42).toString(150);\n// You cannot use a string like this for formatting:\n(12071989).toString('MM-dd-yyyy');\n (42).toString(2); // \"101010\" (binary)\n(13).toString(8); // \"15\" (octal)\n(0x42).toString(10); // \"66\" (decimal)\n(100000).toString(16) // \"186a0\" (hexadecimal)\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Bad_radix\n
ReferenceError: \"x\" is not defined\n
There is a non-existent variable referenced somewhere. This variable needs to be declared, or you need make sure it is available in your current script or scope.
Note: When loading a library (such as jQuery), make sure it is loaded before you access library variables, such as \"$\". Put the <script> tag that loads the library before your code that uses it.
foo.substring(1); // ReferenceError: foo is not defined\n
The \"foo\" variable isn't defined anywhere. It needs to be some string, so that the String.prototype.substring() method will work.
var foo = 'bar';\nfoo.substring(1); // \"ar\"
A variable needs to be available in the current context of execution. Variables defined inside a function cannot be accessed from anywhere outside the function, because the variable is defined only in the scope of the function
function numbers() { \n var num1 = 2, \n num2 = 3;\n return num1 + num2;\n}\n\nconsole.log(num1); // ReferenceError num1 is not defined. However, a function can access all variables and functions defined inside the scope in which it is defined. In other words, a function defined in the global scope can access all variables defined in the global scope.
var num1 = 2,\n num2 = 3;\n\nfunction numbers() {\n return num1 + num2; \n}\n\nconsole.log(numbers()); // 5 \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_defined\n
Error: Out of stack space (Edge)\nInternalError: too much recursion (Firefox)\nRangeError: Maximum call stack size exceeded (Chrome)\n
A function that calls itself is called a recursive function. In some ways, recursion is analogous to a loop. Both execute the same code multiple times, and both require a condition (to avoid an infinite loop, or rather, infinite recursion in this case). When there is too much or infinite recursion, JavaScript will throw this error.
This recursive function runs 10 times, as per the exit condition.
function loop(x) {\n if (x >= 10) // \"x >= 10\" is the exit condition\n return;\n // do stuff\n loop(x + 1); // the recursive call\n}\nloop(0); Setting this condition to an extremely high value, won't work:
function loop(x) {\n if (x >= 1000000000000)\n return;\n // do stuff\n loop(x + 1);\n}\nloop(0);\n\n// InternalError: too much recursion \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Too_much_recursion\n
The static keyword defines a static method for a class. Static methods aren't called on instances of the class. Instead, they're called on the class itself. These are often utility functions, such as functions to create or clone objects.
static methodName() { ... } Static method calls are made directly on the class and are not callable on instances of the class. Static methods are often used to create utility functions.
In order to call a static method within another static method of the same class, you can use the this keyword.
class StaticMethodCall {\n static staticMethod() {\n return 'Static method has been called';\n }\n static anotherStaticMethod() {\n return this.staticMethod() + ' from another static method';\n }\n}\nStaticMethodCall.staticMethod(); \n// 'Static method has been called'\n\nStaticMethodCall.anotherStaticMethod(); \n// 'Static method has been called from another static method' Static methods are not directly accessible using the this keyword from non-static methods. You need to call them using the class name: CLASSNAME.STATIC_METHOD_NAME() or by calling the method as a property of the constructor: this.constructor.STATIC_METHOD_NAME().
class StaticMethodCall {\n constructor() {\n console.log(StaticMethodCall.staticMethod()); \n // 'static method has been called.' \n\n console.log(this.constructor.staticMethod()); \n // 'static method has been called.' \n }\n\n static staticMethod() {\n return 'static method has been called.';\n }\n} The following example demonstrates several things:
class Triple {\n static triple(n) {\n if (n === undefined) {\n n = 1;\n }\n return n * 3;\n }\n}\n\nclass BiggerTriple extends Triple {\n static triple(n) {\n return super.triple(n) * super.triple(n);\n }\n}\n\nconsole.log(Triple.triple()); // 3\nconsole.log(Triple.triple(6)); // 18\n\nvar tp = new Triple();\n\nconsole.log(BiggerTriple.triple(3));\n// 81 (not affected by parent's instantiation)\n\nconsole.log(tp.triple());\n// 'tp.triple is not a function'.\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Class definitions' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Class definitions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 49\n
| \n13 | \n45 | \nNo | \n36 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \nYes | \n13 | \n45 | \n? | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/static\n
arguments is an Array-like object accessible inside functions that contains the values of the arguments passed to that function.
Note: “Array-like” means that arguments has a length property and properties indexed from zero, but it doesn't have Array's built-in methods like forEach and map. See §Description for details.
arguments
The arguments object is a local variable available within all non-arrow functions. You can refer to a function's arguments inside that function by using its arguments object. It has entries for each argument the function was called with, with the first entry's index at 0.
For example, if a function is passed 3 arguments, you can access them as follows:
arguments[0] // first argument\narguments[1] // second argument\narguments[2] // third argument\n
Each argument can also be set or reassigned:
arguments[1] = 'new value';\n
The arguments object is not an Array. It is similar, but does not have any Array properties except length. For example, it does not have the pop method. However, it can be converted to a real Array:
var args = Array.prototype.slice.call(arguments);\n// Using an array literal is shorter than above but allocates an empty array\nvar args = [].slice.call(arguments); \n
As you can do with any Array-like object, you can use ES2015's Array.from() method or spread operator to convert arguments to a real Array:
var args = Array.from(arguments);\nvar args = [...arguments];\n
The arguments object is useful for functions called with more arguments than they are formally declared to accept. This technique is useful for functions that can be passed a variable number of arguments, such as Math.min(). This example function accepts any number of string arguments and returns the longest one:
function longestString() {\n var longest = '';\n for (var i=0; i < arguments.length; i++) {\n if (arguments[i].length > longest.length) {\n longest = arguments[i];\n }\n }\n return longest;\n}\n You can use arguments.length to count how many arguments the function was called with. If you instead want to count how many parameters a function is declared to accept, inspect that function's length property.
typeof with ArgumentsThe typeof operator returns 'object' when used with arguments
console.log(typeof arguments); // 'object'
The type of individual arguments can be determined by indexing arguments:
console.log(typeof arguments[0]); // returns the type of the first argument
arguments.calleearguments.caller \narguments.lengtharguments[@@iterator]arguments.This example defines a function that concatenates several strings. The function's only formal argument is a string containing the characters that separate the items to concatenate.
function myConcat(separator) {\n var args = Array.prototype.slice.call(arguments, 1);\n return args.join(separator);\n} You can pass as many arguments as you like to this function. It returns a string list using each argument in the list:
// returns \"red, orange, blue\"\nmyConcat(', ', 'red', 'orange', 'blue');\n\n// returns \"elephant; giraffe; lion; cheetah\"\nmyConcat('; ', 'elephant', 'giraffe', 'lion', 'cheetah');\n\n// returns \"sage. basil. oregano. pepper. parsley\"\nmyConcat('. ', 'sage', 'basil', 'oregano', 'pepper', 'parsley'); This example defines a function that creates a string containing HTML for a list. The only formal argument for the function is a string that is \"u\" if the list is to be unordered (bulleted), or \"o\" if the list is to be ordered (numbered). The function is defined as follows:
function list(type) {\n var html = '<' + type + 'l><li>';\n var args = Array.prototype.slice.call(arguments, 1);\n html += args.join('</li><li>');\n html += '</li></' + type + 'l>'; // end list\n\n return html;\n} You can pass any number of arguments to this function, and it adds each argument as a list item to a list of the type indicated. For example:
var listHTML = list('u', 'One', 'Two', 'Three');\n\n/* listHTML is:\n\"<ul><li>One</li><li>Two</li><li>Three</li></ul>\"\n*/ The arguments object can be used in conjunction with rest, default, and destructured parameters.
function foo(...args) {\n return args;\n}\nfoo(1, 2, 3); // [1,2,3]\n While the presence of rest, default, or destructured parameters does not alter the behavior of the arguments object in strict mode code, there is a subtle difference for non-strict code.
If a non-strict function does not contain rest, default, or destructured parameters, then the values in the arguments object do change in sync with the values of the argument variables. See the code below:
function func(a) { \n arguments[0] = 99; // updating arguments[0] also updates a\n console.log(a);\n}\nfunc(10); // 99\n and
function func(a) { \n a = 99; // updating a also updates arguments[0]\n console.log(arguments[0]);\n}\nfunc(10); // 99\n When a non-strict function does contain rest, default, or destructured parameters, then the values in the arguments object do not track the values of the arguments. Instead, they reflect the arguments provided when the function was called:
function func(a = 55) { \n arguments[0] = 99; // updating arguments[0] does not also update a\n console.log(a);\n}\nfunc(10); // 10 and
function func(a = 55) { \n a = 99; // updating a does not also update arguments[0]\n console.log(arguments[0]);\n}\nfunc(10); // 10\n and
// An untracked default parameter\nfunction func(a = 55) { \n console.log(arguments[0]);\n}\nfunc(); // undefined | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1 |
| ECMAScript 5.1 (ECMA-262) The definition of 'Arguments Object' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Arguments Exotic Objects' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Arguments Exotic Objects' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
callee | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
\ncaller \n | \nNo | \nNo | \nNo | \n? — 9 | \nNo | \nNo | \n
length | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
@@iterator | \n52 | \n? | \n46 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
callee | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\ncaller \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
length | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
@@iterator | \n52 | \n52 | \n? | \n46 | \nYes | \n9 | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
callee | \nYes | \n
\ncaller \n | \nNo | \n
length | \nYes | \n
@@iterator | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments\n
RangeError: argument out of range\nRangeError: repeat count must be non-negative (Firefox)\nRangeError: Invalid count value (Chrome)\n
The String.prototype.repeat() method has been used. It has a count parameter indicating the number of times to repeat the string. It must be between 0 and less than positive Infinity and cannot be a negative number. The range of allowed values can be described like this: [0, +∞).
'abc'.repeat(-1); // RangeError
'abc'.repeat(0); // ''\n'abc'.repeat(1); // 'abc'\n'abc'.repeat(2); // 'abcabc'\n'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer)\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Negative_repetition_count\n
ReferenceError: assignment to undeclared variable \"x\" (Firefox)\nReferenceError: \"x\" is not defined (Chrome)\nReferenceError: Variable undefined in strict mode (Edge)\n
ReferenceError warning in strict mode only.
A value has been assigned to an undeclared variable. In other words, there was an assignment without the var keyword. There are some differences between declared and undeclared variables, which might lead to unexpected results and that's why JavaScript presents an error in strict mode.
Three things to note about declared and undeclared variables:
For more details and examples, see the var reference page.
Errors about undeclared variable assignments occur in strict mode code only. In non-strict code, they are silently ignored.
In this case, the variable \"bar\" is an undeclared variable.
function foo() { \n 'use strict'; \n bar = true; \n} \nfoo(); // ReferenceError: assignment to undeclared variable bar\n To make \"bar\" a declared variable, you can add the var keyword in front of it.
function foo() {\n 'use strict';\n var bar = true;\n}\nfoo(); \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Undeclared_var\n
ReferenceError: invalid assignment left-hand side\n
There was an unexpected assignment somewhere. This might be due to a mismatch of a assignment operator and a comparison operator, for example. While a single \"=\" sign assigns a value to a variable, the \"==\" or \"===\" operators compare a value.
if (Math.PI = 3 || Math.PI = 4) { \n console.log('no way!');\n}\n// ReferenceError: invalid assignment left-hand side\n\nvar str = 'Hello, '\n+= 'is it me '\n+= 'you\\'re looking for?';\n// ReferenceError: invalid assignment left-hand side\n In the if statement, you want to use a comparison operator (\"==\"), and for the string concatenation, the plus (\"+\") operator is needed.
if (Math.PI == 3 || Math.PI == 4) { \n console.log('no way!'); \n}\n\nvar str = 'Hello, ' \n+ 'from the ' \n+ 'other side!';\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side\n
ReferenceError: Use before delaration (Edge)\nReferenceError: can't access lexical declaration `X' before initialization (Firefox)\nReferenceError: 'x' is not defined (Chrome)\n
A lexical variable was accessed before it was initialized. This happens within any block statement, when let or const declarations are accessed before they are defined.
In this case, the variable \"foo\" is redeclared in the block statement using let.
function test() {\n let foo = 33;\n if (true) {\n let foo = (foo + 55); \n // ReferenceError: can't access lexical \n // declaration `foo' before initialization\n }\n}\ntest();\n To change \"foo\" inside the if statement, you need to remove the let that causes the redeclaration.
function test(){\n let foo = 33;\n if (true) {\n foo = (foo + 55);\n }\n}\ntest();\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cant_access_lexical_declaration_before_init\n
SyntaxError: JSON.parse: unterminated string literal\nSyntaxError: JSON.parse: bad control character in string literal\nSyntaxError: JSON.parse: bad character in string literal\nSyntaxError: JSON.parse: bad Unicode escape\nSyntaxError: JSON.parse: bad escape character\nSyntaxError: JSON.parse: unterminated string\nSyntaxError: JSON.parse: no number after minus sign\nSyntaxError: JSON.parse: unexpected non-digit\nSyntaxError: JSON.parse: missing digits after decimal point\nSyntaxError: JSON.parse: unterminated fractional number\nSyntaxError: JSON.parse: missing digits after exponent indicator\nSyntaxError: JSON.parse: missing digits after exponent sign\nSyntaxError: JSON.parse: exponent part is missing a number\nSyntaxError: JSON.parse: unexpected end of data\nSyntaxError: JSON.parse: unexpected keyword\nSyntaxError: JSON.parse: unexpected character\nSyntaxError: JSON.parse: end of data while reading object contents\nSyntaxError: JSON.parse: expected property name or '}'\nSyntaxError: JSON.parse: end of data when ',' or ']' was expected\nSyntaxError: JSON.parse: expected ',' or ']' after array element\nSyntaxError: JSON.parse: end of data when property name was expected\nSyntaxError: JSON.parse: expected double-quoted property name\nSyntaxError: JSON.parse: end of data after property name when ':' was expected\nSyntaxError: JSON.parse: expected ':' after property name in object\nSyntaxError: JSON.parse: end of data after property value in object\nSyntaxError: JSON.parse: expected ',' or '}' after property value in object\nSyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal\nSyntaxError: JSON.parse: property names must be double-quoted strings\nSyntaxError: JSON.parse: expected property name or '}'\nSyntaxError: JSON.parse: unexpected character\nSyntaxError: JSON.parse: unexpected non-whitespace character after JSON data\nSyntaxError: JSON.parse Error: Invalid character at position {0} (Edge) JSON.parse() parses a string as JSON. This string has to be valid JSON and will throw this error if incorrect syntax was encountered.
JSON.parse() does not allow trailing commasBoth lines will throw a SyntaxError:
JSON.parse('[1, 2, 3, 4,]');\nJSON.parse('{\"foo\": 1,}');\n// SyntaxError JSON.parse: unexpected character \n// at line 1 column 14 of the JSON data\n Omit the trailing commas to parse the JSON correctly:
JSON.parse('[1, 2, 3, 4]');\nJSON.parse('{\"foo\": 1}'); You cannot use single-quotes around properties, like 'foo'.
JSON.parse(\"{'foo': 1}\");\n// SyntaxError: JSON.parse: expected property name or '}' \n// at line 1 column 2 of the JSON data Instead write \"foo\":
JSON.parse('{\"foo\": 1}'); You cannot use leading zeros, like 01, and decimal points must be followed by at least one digit.
JSON.parse('{\"foo\": 01}');\n// SyntaxError: JSON.parse: expected ',' or '}' after property value \n// in object at line 1 column 2 of the JSON data\n\nJSON.parse('{\"foo\": 1.}'); \n// SyntaxError: JSON.parse: unterminated fractional number \n// at line 1 column 2 of the JSON data\n Instead write just 1 without a zero and use at least one digit after a decimal point:
JSON.parse('{\"foo\": 1}');\nJSON.parse('{\"foo\": 1.0}');\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/JSON_bad_parse\n
TypeError: 'arguments', 'callee' and 'caller' are restricted function properties and cannot be accessed in this context (Edge)\nWarning: ReferenceError: deprecated caller usage (Firefox)\nWarning: ReferenceError: deprecated arguments usage (Firefox)\nTypeError: 'callee' and 'caller' cannot be accessed in strict mode. (Safari)\n
A strict-mode-only warning that a ReferenceError occurred. JavaScript execution won't be halted.
In strict mode, the Function.caller or Function.arguments properties are used and shouldn't be. They are deprecated, because they leak the function caller, are non-standard, hard to optimize and potentially a performance-harmful feature.
function.caller or arguments.callee.caller\nFunction.caller and arguments.callee.caller are deprecated (see the reference articles for more information).
'use strict';\n\nfunction myFunc() {\n if (myFunc.caller == null) {\n return 'The function was called from the top!';\n } else {\n return 'This function\\'s caller was ' + myFunc.caller;\n }\n}\n\nmyFunc();\n// Warning: ReferenceError: deprecated caller usage\n// \"The function was called from the top!\" Function.argumentsFunction.arguments is deprecated (see the reference article for more information).
'use strict';\n\nfunction f(n) { g(n - 1); }\n\nfunction g(n) {\n console.log('before: ' + g.arguments[0]);\n if (n > 0) { f(n); }\n console.log('after: ' + g.arguments[0]);\n}\n\nf(2);\n\nconsole.log('returned: ' + g.arguments);\n// Warning: ReferenceError: deprecated arguments usage\n Function.argumentsFunction.caller and arguments.callee.caller\n\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Deprecated_caller_or_arguments_usage\n
SyntaxError: Expected {x} (Edge)\nSyntaxError: malformed formal parameter (Firefox)\n There is a Function() constructor with at least two arguments passed in the code. The last argument is the source code for the new function you're creating. All the rest make up your new function's argument list.
The argument list is invalid somehow. Perhaps you accidentally picked a keyword like if or var as an argument name, or perhaps there's some stray punctuation in your argument list. Or maybe you accidentally passed an invalid value, like a number or object.
Admittedly the wording in the error message is slightly strange. \"Formal parameter\" is a fancy way of saying \"function argument\". And we use the word \"malformed\" because all Firefox engineers are huge fans of 19th-century Gothic horror novels.
var f = Function('x y', 'return x + y;'); \n// SyntaxError (missing a comma)\n\nvar f = Function('x,', 'return x;'); \n// SyntaxError (extraneous comma)\n\nvar f = Function(37, \"alert('OK')\");\n// SyntaxError (numbers can't be argument names)\n var f = Function('x, y', 'return x + y;'); // correctly punctuated\n\nvar f = Function('x', 'return x;');\n\n// if you can, avoid using Function - this is much faster\nvar f = function(x) { return x; };\n Function()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Malformed_formal_parameter\n
SyntaxError: for-of loop head declarations cannot have an initializer (Edge)\nSyntaxError: a declaration in the head of a for-of loop can't have an initializer (Firefox)\nSyntaxError: for-of loop variable declaration may not have an initializer. (Chrome)\n
The head of a for...of loop contains an initializer expression. That is, a variable is declared and assigned a value |for (var i = 0 of iterable)|. This is not allowed in for-of loops. You might want a for loop that does allow an initializer.
for-of looplet iterable = [10, 20, 30]; \n\nfor (let value = 50 of iterable) { \n console.log(value); \n} \n\n// SyntaxError: a declaration in the head of a for-of loop can't \n// have an initializer for-of loopYou need to remove the initializer (value = 50) in the head of the for-of loop. Maybe you intended to make 50 an offset value, in that case you could add it to the loop body, for example.
let iterable = [10, 20, 30];\n\nfor (let value of iterable) {\n value += 50;\n console.log(value);\n}\n// 60\n// 70\n// 80\n for...offor...in – disallows an initializer in strict mode as well (SyntaxError: for-in loop head declarations may not have initializers)for – allows to define an initializer when iterating.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_for-of_initializer\n
SyntaxError: Octal numeric literals and escape characters not allowed in strict mode (Edge)\nSyntaxError: \n\"0\"-prefixed octal literals and octal escape sequences are deprecated; \nfor octal literals use the \"0o\" prefix instead\n
SyntaxError in strict mode only.
Octal literals and octal escape sequences are deprecated and will throw a SyntaxError in strict mode. With ECMAScript 2015 and later, the standardized syntax uses a leading zero followed by a lowercase or uppercase Latin letter \"O\" (0o or 0O).
\"use strict\";\n\n03;\n\n// SyntaxError: \"0\"-prefixed octal literals and octal escape sequences \n// are deprecated
\"use strict\";\n\n\"\\251\";\n\n// SyntaxError: \"0\"-prefixed octal literals and octal escape sequences\n// are deprecated\n
Use a leading zero followed by the letter \"o\" or \"O\":
0o3;\n
For octal escape sequences, you can use hexadecimal escape sequences instead:
'\\xA9';
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Deprecated_octal\n
SyntaxError: Invalid character (Edge)\nSyntaxError: illegal character (Firefox)\nSyntaxError: Invalid or unexpected token (Chrome)\n
There is an invalid or unexpected token that doesn't belong at this position in the code. Use an editor that supports syntax highlighting and carefully check your code against mismatches like a minus sign ( - ) versus a dash ( – ) or simple quotes ( \" ) vs non-standard quotation marks ( “ ).
Some characters look similar, but will cause the parser to fail interpreting your code. Famous examples of this are quotes, the minus or semicolon (greek questionmark (U+37e) looks same).
“This looks like a string”; // SyntaxError: illegal character \n // “ and ” are not \" but look like this\n\n42 – 13; // SyntaxError: illegal character\n // – is not - but looks like this\n\nvar foo = 'bar'; // SyntaxError: illegal character\n // <37e> is not ; but looks like this\n
This should work:
\"This is actually a string\";\n42 - 13;\nvar foo = 'bar';\n
It's easy to forget a character here or there.
var colors = ['#000', #333', '#666'];\n// SyntaxError: illegal character\n
Add the missing quote for '#333'.
var colors = ['#000', '#333', '#666'];
When copy pasting code from external sources, there might be invalid characters. Watch out!
var foo = 'bar';\n// SyntaxError: illegal character\n
When inspecting this code in an editor like Vim, you can see that there is actually a zero-width space (ZWSP) (U+200B) character.
var foo = 'bar';<200b>
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Illegal_character\n
ReferenceError: reference to undefined property \"x\" (Firefox)\n
(Firefox only) ReferenceError warning which is reported only if javascript.options.strict preference is set to true.
The script attempted to access an object property which doesn't exist. There are two ways to access properties; see the property accessors reference page to learn more about them.
In this case, the property bar is an undefined property, so a ReferenceError will occur.
var foo = {};\nfoo.bar; // ReferenceError: reference to undefined property \"bar\"\n To avoid the error, you need to either add a definition for bar to the object or check for the existence of the bar property before trying to access it; one way to do that is to use the Object.prototype.hasOwnProperty() method), like this:
var foo = {};\n\n// Define the bar property\n\nfoo.bar = 'moon';\nconsole.log(foo.bar); // \"moon\"\n\n// Test to be sure bar exists before accessing it\n\nif (foo.hasOwnProperty('bar')) {\n console.log(foo.bar);\n} \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Undefined_prop\n
Edge:\nCannot apply strict mode on functions with non-simple parameter list\n\nFirefox:\nSyntaxError: \"use strict\" not allowed in function with default parameter\nSyntaxError: \"use strict\" not allowed in function with rest parameter\nSyntaxError: \"use strict\" not allowed in function with destructuring parameter\n\nChrome:\nSyntaxError: Illegal 'use strict' directive in function with non-simple parameter list\n
A \"use strict\" directive is written at the top of a function that has one of the following parameters:
A \"use strict\" directive is not allowed at the top of such functions per the ECMAScript specification.
In this case, the function sum has default parameters a=1 and b=2:
function sum(a = 1, b = 2) {\n // SyntaxError: \"use strict\" not allowed in function with default parameter\n 'use strict';\n return a + b;\n}\n If the function should be in strict mode, and the entire script or enclosing function is also okay to be in strict mode, you can move the \"use strict\" directive outside of the function:
'use strict';\nfunction sum(a = 1, b = 2) {\n return a + b;\n}\n A function expression can use yet another workaround:
var sum = function sum([a, b]) {\n // SyntaxError: \"use strict\" not allowed in function with destructuring parameter\n 'use strict';\n return a + b;\n};\n This can be converted to the following expression:
var sum = (function() {\n 'use strict';\n return function sum([a, b]) {\n return a + b;\n };\n})();\n If an arrow function needs to access the this variable, you can use the arrow function as the enclosing function:
var callback = (...args) => {\n // SyntaxError: \"use strict\" not allowed in function with rest parameter\n 'use strict';\n return this.run(args);\n};\n This can be converted to the following expression:
var callback = (() => {\n 'use strict';\n return (...args) => {\n return this.run(args);\n };\n})();\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Strict_Non_Simple_Params\n
SyntaxError: expected expression, got \"x\"\nSyntaxError: expected property name, got \"x\" \nSyntaxError: expected target, got \"x\"\nSyntaxError: expected rest argument name, got \"x\"\nSyntaxError: expected closing parenthesis, got \"x\"\nSyntaxError: expected '=>' after argument list, got \"x\"\n
A specific language construct was expected, but something else was provided. This might be a simple typo.
For example, when chaining expressions, trailing commas are not allowed.
for (let i = 0; i < 5,; ++i) {\n console.log(i);\n}\n// SyntaxError: expected expression, got ')'\n Correct would be omitting the comma or adding another expression:
for (let i = 0; i < 5; ++i) {\n console.log(i);\n}\n Sometimes, you leave out brackets around if statements:
function round(n, upperBound, lowerBound){\n if(n > upperBound) || (n < lowerBound){\n throw 'Number ' + String(n) + ' is more than ' + String(upperBound) + ' or less than ' + String(lowerBound);\n }else if(n < ((upperBound + lowerBound)/2)){\n return lowerBound;\n }else{\n return upperBound;\n }\n} // SyntaxError: expected expression, got '||' The brackets may look correct at first, but note how the || is outside the brackets. Correct would be putting brackets around the ||:
function round(n, upperBound, lowerBound){\n if((n > upperBound) || (n < lowerBound)){\n throw 'Number ' + String(n) + ' is more than ' + String(upperBound) + ' or less than ' + String(lowerBound);\n }else if(n < ((upperBound + lowerBound)/2)){\n return lowerBound;\n }else{\n return upperBound;\n }\n}\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Unexpected_token\n
SyntaxError: The use of a future reserved word for an identifier is invalid (Edge)\nSyntaxError: \"x\" is a reserved identifier (Firefox)\nSyntaxError: Unexpected reserved word (Chrome)
Reserved keywords will throw in if they are used as identifiers. These are reserved in strict mode and sloppy mode:
enumThe following are only reserved when they are found in strict mode code:
implementsinterfaceletpackageprivateprotectedpublicstaticThe enum identifier is generally reserved.
var enum = { RED: 0, GREEN: 1, BLUE: 2 };\n// SyntaxError: enum is a reserved identifier\n In strict mode code, more identifiers are reserved.
\"use strict\";\nvar package = [\"potatoes\", \"rice\", \"fries\"];\n// SyntaxError: package is a reserved identifier\n
You'll need to rename these variables.
var colorEnum = { RED: 0, GREEN: 1, BLUE: 2 };\nvar list = [\"potatoes\", \"rice\", \"fries\"]; If you are using an older browser that does not yet implement let or class, for example, you should update to a more recent browser version that does support these new language features.
\"use strict\"; \nclass DocArchiver {}\n\n// SyntaxError: class is a reserved identifier\n// (throws in older browsers only, e.g. Firefox 44 and older)\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Reserved_identifier\n
SyntaxError: for-in loop head declarations cannot have an initializer (Edge)\nSyntaxError: for-in loop head declarations may not have initializers (Firefox)\nSyntaxError: for-in loop variable declaration may not have an initializer. (Chrome)\n
SyntaxError in strict mode only.
The head of a for...in loop contains an initializer expression. That is, a variable is declared and assigned a value |for (var i = 0 in obj)|. In non-strict mode, this head declaration is silently ignored and behaves like |for (var i in obj)|. In strict mode, however, a SyntaxError is thrown.
This example throws a SyntaxError:
\"use strict\";\n\nvar obj = {a: 1, b: 2, c: 3 }; \n\nfor (var i = 0 in obj) { \n console.log(obj[i]);\n}\n\n// SyntaxError: for-in loop head declarations may not have initializers\n You can remove the initializer (i = 0) in the head of the for-in loop.
\"use strict\";\n\nvar obj = {a: 1, b: 2, c: 3 };\n\nfor (var i in obj) {\n console.log(obj[i]);\n}\n The for...in loop shouldn't be used for Array iteration. Did you intend to use a for loop instead of a for-in loop to iterate an Array? The for loop allows you to set an initializer then as well:
var arr = [ \"a\", \"b\", \"c\" ] \n\nfor (var i = 2; i < arr.length; i++) { \n console.log(arr[i]); \n}\n\n// \"c\" for...infor...of – also disallows an initializer in both strict and non-strict mode.for – preferred for array iteration, allows to define an initializer.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_for-in_initializer\n
Warning: SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead\n\nWarning: SyntaxError: Using //@ to indicate sourceMappingURL pragmas is deprecated. Use //# instead\n
A warning that a SyntaxError occurred. JavaScript execution won't be halted.
There is a deprecated source map syntax in a JavaScript source.
JavaScript sources are often combined and minified to make delivering them from the server more efficient. With source maps, the debugger can map the code being executed to the original source files.
The source map specification changed the syntax due to a conflict with IE whenever it was found in the page after //@cc_on was interpreted to turn on conditional compilation in the IE JScript engine. The conditional compilation comment in IE is a little known feature, but it broke source maps with jQuery and other libraries.
Syntax with the \"@\" sign is deprecated.
//@ sourceMappingURL=http://example.com/path/to/your/sourcemap.map\n
Use the \"#\" sign instead.
//# sourceMappingURL=http://example.com/path/to/your/sourcemap.map
Or, alternatively, you can set a SourceMap header to your JavaScript file to avoid having a comment at all:
SourceMap: /path/to/file.js.map
SourceMap\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Deprecated_source_map_pragma\n
Syntax Error: Expected identifier (Edge)\nSyntaxError: function statement requires a name [Firefox]\nSyntaxError: Unexpected token ( [Chrome]\n
There is a function statement in the code that requires a name. You'll need to check how functions are defined and if you need to provide a name for it, or if the function in question needs to be a function expression, an IIFE, or if the function code is placed correctly in this context at all.
A function statement (or function declaration) requires a name, this won't work:
function () {\n return 'Hello world';\n}\n// SyntaxError: function statement requires a name\n You can use a function expression (assignment) instead:
var greet = function() {\n return 'Hello world';\n}; Or, you function is maybe intended to be an IIFE (Immediately Invoked Function Expression), which is a function that runs as soon as it is defined. You will need a few more braces in this case:
(function () {\n\n})(); If you are using function labels, you will still need to provide a function name after the function keyword. This doesn't work:
function Greeter() {\n german: function () { \n return \"Moin\";\n }\n}\n// SyntaxError: function statement requires a name\n This would work, for example:
function Greeter() { \n german: function g() { \n return \"Moin\"; \n } \n} If you intended to create a method of an object, you will need to create an object. The following syntax without a name after the function keyword is valid then.
var greeter = {\n german: function () {\n return \"Moin\";\n } \n}; Also, check your syntax when using callbacks. Brackets and commas can get difficult easily.
promise.then(\n function() {\n console.log(\"success\"); \n });\n function() {\n console.log(\"error\");\n}\n// SyntaxError: function statement requires a name\n Correct would be:
promise.then(\n function() {\n console.log(\"success\");\n },\n function() {\n console.log(\"error\");\n }\n);\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Unnamed_function_statement\n
SyntaxError: Unexpected identifier after numeric literal (Edge)\nSyntaxError: identifier starts immediately after numeric literal (Firefox)\nSyntaxError: Unexpected number (Chrome)\n
The names of variables, called identifiers, conform to certain rules, which your code must adhere to!
A JavaScript identifier must start with a letter, underscore (_), or dollar sign ($). They can't start with a digit! Only subsequent characters can be digits (0-9).
Variable names can't start with numbers in JavaScript. The following fails:
var 1life = 'foo';\n// SyntaxError: identifier starts immediately after numeric literal\n\nvar foo = 1life;\n// SyntaxError: identifier starts immediately after numeric literal\n\nalert(1.foo);\n// SyntaxError: identifier starts immediately after numeric literal \n
You will need to rename your variable to avoid the leading number.
var life1 = 'foo';\nvar foo = life1;\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Identifier_after_number\n
SyntaxError: Calling delete on expression not allowed in strict mode (Edge)\nSyntaxError: applying the 'delete' operator to an unqualified name is deprecated (Firefox)\nSyntaxError: Delete of an unqualified identifier in strict mode. (Chrome)\n
SyntaxError in strict mode only.
Normal variables in JavaScript can't be deleted using the delete operator. In strict mode, an attempt to delete a variable will throw an error and is not allowed.
The delete operator can only delete properties on an object. Object properties are \"qualified\" if they are configurable.
Unlike what common belief suggests, the delete operator has nothing to do with directly freeing memory. Memory management is done indirectly via breaking references, see the memory management page and the delete operator page for more details.
This error only happens in strict mode code. In non-strict code, the operation just returns false.
Attempting to delete a plain variable, doesn't work in JavaScript and it throws an error in strict mode:
'use strict';\n\nvar x;\n\n// ...\n\ndelete x;\n\n// SyntaxError: applying the 'delete' operator to an unqualified name \n// is deprecated \n
To free the contents of a variable, you can set it to null:
'use strict';\n\nvar x;\n\n// ...\n\nx = null;\n\n// x can be garbage collected\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Delete_in_strict_mode\n
SyntaxError: Expected ')' (Edge)\nSyntaxError: missing ) after argument list (Firefox)\n
There is an error with how a function is called. This might be a typo, a missing operator, or an unescaped string, for example.
Because there is no \"+\" operator to concatenate the string, JavaScript expects the argument for the log function to be just \"PI: \". In that case, it should be terminated by a closing parenthesis.
console.log('PI: ' Math.PI);\n// SyntaxError: missing ) after argument list\n You can correct the log call by adding the \"+\" operator:
console.log('PI: ' + Math.PI);\n// \"PI: 3.141592653589793\" console.log('\"Java\" + \"Script\" = \\\"' + 'Java' + 'Script\\\");\n// SyntaxError: missing ) after argument list Here JavaScript thinks that you meant to have ); inside the string and ignores it, and it ends up not knowing that you meant the ); to end the function console.log. To fix this, we could put a' after the \"Script\" string:
console.log('\"Java\" + \"Script\" = \\\"' + 'Java' + 'Script\\\"');\n// '\"Java\" + \"Script\" = \"JavaScript\"'\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_parenthesis_after_argument_list\n
SyntaxError: Syntax error in regular expression (Edge) \nSyntaxError: invalid regular expression flag \"x\" (Firefox)\nSyntaxError: Invalid regular expression flags (Chrome)\n
There are invalid regular expression flags in the code. In a regular expression literal, which consists of a pattern enclosed between slashes, the flags are defined after the second flag. They can also be defined in the constructor function of the RegExp object (second parameter). Regular expression flags can be used separately or together in any order, but there are only five of them in ECMAScript.
To include a flag with the regular expression, use this syntax:
var re = /pattern/flags;\n
or
var re = new RegExp('pattern', 'flags'); | Flag | Description |
|---|---|
g | Global search. |
| i | Case-insensitive search. |
| m | Multi-line search. |
| u | Unicode; treat pattern as a sequence of Unicode code points |
| y | Perform a \"sticky\" search that matches starting at the current position in the target string. See sticky\n |
There are only five valid regular expression flags.
/foo/bar;\n\n// SyntaxError: invalid regular expression flag \"b\"\n
Did you intend to create a regular expression? An expression containing two slashes is interpreted as a regular expression literal.
let obj = {\n url: /docs/Web\n};\n\n// SyntaxError: invalid regular expression flag \"W\"\n Or did you mean to create a string instead? Add single or double quotes to create a string literal.
let obj = {\n url: '/docs/Web'\n}; See the table above for the five valid regular expression flags that are allowed in JavaScript.
/foo/g;\n/foo/gim;\n/foo/uy;\n
n, s, x, A)\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Bad_regexp_flag\n
SyntaxError: Expected ')' (Edge)\nSyntaxError: missing ) after condition (Firefox)\n
There is an error with how an if condition is written. In any programming language, code needs to make decisions and carry out actions accordingly depending on different inputs. The if statement executes a statement if a specified condition is truthy. In JavaScript, this condition must appear in parenthesis after the if keyword, like this:
if (condition) {\n // do something if the condition is true\n} It might just be an oversight, carefully check all you parenthesis in your code.
if (3 > Math.PI {\n console.log(\"wait what?\");\n}\n\n// SyntaxError: missing ) after condition\n To fix this code, you would need to add a parenthesis that closes the condition.
if (3 > Math.PI) {\n console.log(\"wait what?\");\n} If you are coming from another programming language, it is also easy to add keywords that don't mean the same or have no meaning at all in JavaScript.
if (done is true) {\n console.log(\"we are done!\");\n}\n\n// SyntaxError: missing ) after condition\n Instead you need to use a correct comparison operator. For example:
if (done === true) {\n console.log(\"we are done!\");\n} \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_parenthesis_after_condition\n
SyntaxError: Expected ':' (Edge)\nSyntaxError: missing : after property id (Firefox)\n
When creating objects with the object initializer syntax, a colon (:) separates keys and values for the object's properties.
var obj = { propertyKey: 'value' };\n This code fails, as the equal sign can't be used this way in this object initializer syntax.
var obj = { propertyKey = 'value' };\n// SyntaxError: missing : after property id\n Correct would be to use a colon, or to use square brackets to assign a new property after the object has been created already.
var obj = { propertyKey: 'value' };\n\n// or alternatively\n\nvar obj = { };\nobj['propertyKey'] = 'value';\n You can't create empty properties like this:
var obj = { propertyKey; };\n// SyntaxError: missing : after property id\n If you need to define a property without a value, you might use null as a value.
var obj = { propertyKey: null }; If you create a property key from an expression, you need to use square brackets. Otherwise the property name can't be computed:
var obj = { 'b'+'ar': 'foo' };\n// SyntaxError: missing : after property id\n Put the expression in brackets []:
var obj = { ['b'+'ar']: 'foo' }; \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_colon_after_property_id\n
SyntaxError: Const must be initalized (Edge)\nSyntaxError: missing = in const declaration (Firefox)\nSyntaxError: Missing initializer in const declaration (Chrome)\n
A constant is a value that cannot be altered by the program during normal execution. It cannot change through re-assignment, and it can't be redeclared. In JavaScript, constants are declared using the const keyword. An initializer for a constant is required; that is, you must specify its value in the same statement in which it's declared (which makes sense, given that it can't be changed later).
Unlike var or let, you must specify a value for a const declaration. This throws:
const COLUMNS; \n// SyntaxError: missing = in const declaration
There are multiple options to fix this error. Check what was intended to be achieved with the constant in question.
Specify the constant value in the same statement in which it's declared:
const COLUMNS = 80;
const, let or var?Do not use const if you weren't meaning to declare a constant. Maybe you meant to declare a block-scoped variable with let or global variable with var. Both don't require an initial value.
let columns;\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_initializer_in_const\n
SyntaxError: missing formal parameter (Firefox)\n
\"Formal parameter\" is a fancy way of saying \"function parameter\". Your function declaration is missing valid parameters. In the declaration of a function, the parameters must be identifiers, not any value like numbers, strings, or objects. Declaring functions and calling functions are two separate steps. Declarations require identifier as parameters, and only when calling (invoking) the function, you provide the values the function should use.
In JavaScript, identifiers can contain only alphanumeric characters (or \"$\" or \"_\"), and may not start with a digit. An identifier differs from a string in that a string is data, while an identifier is part of the code.
Function parameters must be identifiers when setting up a function. All these function declarations fail, as they are providing values for their parameters:
function square(3) {\n return number * number;\n};\n// SyntaxError: missing formal parameter\n\nfunction greet(\"Howdy\") {\n return greeting;\n};\n// SyntaxError: missing formal parameter\n\nfunction log({ obj: \"value\"}) { \n console.log(arg)\n};\n// SyntaxError: missing formal parameter\n You will need to use identifiers in function declarations:
function square(number) {\n return number * number;\n};\n\nfunction greet(greeting) {\n return greeting;\n};\n\nfunction log(arg) {\n console.log(arg)\n}; You can then call these functions with the arguments you like:
square(2); // 4\n\ngreet(\"Howdy\"); // \"Howdy\"\n\nlog({obj: \"value\"}); // Object { obj: \"value\" }\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_formal_parameter\n
SyntaxError: missing ] after element list\n
There is an error with the array initializer syntax somewhere. Likely there is a closing bracket (\"]\") or a comma (\",\") missing.
var list = [1, 2,\n\nvar instruments = [\n 'Ukulele',\n 'Guitar',\n 'Piano'\n};\n\nvar data = [{foo: 'bar'} {bar: 'foo'}];\n Correct would be:
var list = [1, 2];\n\nvar instruments = [\n 'Ukulele',\n 'Guitar',\n 'Piano'\n]; \n\nvar data = [{foo: 'bar'}, {bar: 'foo'}]; \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_bracket_after_list\n
SyntaxError: Expected '}' (Edge)\nSyntaxError: missing } after property list (Firefox)\n
There is a mistake in the object initializer syntax somewhere. Might be in fact a missing curly bracket, but could also be a missing comma, for example. Also check if any closing curly brackets or parenthesis are in the correct order. Indenting or formatting the code a bit nicer might also help you to see through the jungle.
Oftentimes, there is a missing comma in your object initializer code:
var obj = { \n a: 1, \n b: { myProp: 2 }\n c: 3\n};\n Correct would be:
var obj = {\n a: 1,\n b: { myProp: 2 },\n c: 3\n};\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_curly_after_property_list\n
SyntaxError: Expected ';' (Edge)\nSyntaxError: missing ; before statement (Firefox)\n
There is a semicolon (;) missing somewhere. JavaScript statements must be terminated with semicolons. Some of them are affected by automatic semicolon insertion (ASI), but in this case you need to provide a semicolon, so that JavaScript can parse the source code correctly.
However, oftentimes, this error is only a consequence of another error, like not escaping strings properly, or using var wrongly. You might also have too many parenthesis somewhere. Carefully check the syntax when this error is thrown.
This error can occur easily when not escaping strings properly and the JavaScript engine is expecting the end of your string already. For example:
var foo = 'Tom's bar';\n// SyntaxError: missing ; before statement
You can use double quotes, or escape the apostrophe:
var foo = \"Tom's bar\";\nvar foo = 'Tom\\'s bar';\n
You cannot declare properties of an object or array with a var declaration.
var obj = {};\nvar obj.foo = 'hi'; // SyntaxError missing ; before statement\n\nvar array = [];\nvar array[0] = 'there'; // SyntaxError missing ; before statement\n Instead, omit the var keyword:
var obj = {};\nobj.foo = 'hi';\n\nvar array = [];\narray[0] = 'there';\n If you come from another programming language, it is also common to use keywords that don't mean the same or have no meaning at all in javaScript:
def print(info){\n console.log(info);\n}; // SyntaxError missing ; before statement Instead, use function instead of def:
function print(info){\n console.log(info);\n}; \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement\n
SyntaxError: missing name after . operator\n
The dot operator (.) is used for property access. You will have to specify the name of the property that you want to access. For computed property access, you might need to change your property access from using a dot to using square brackets. These will allow you to compute an expression. Maybe you intended to do concatenation instead? A plus operator (+) is needed in that case. Please see the examples below.
Property accessors in JavaScript use either the dot (.) or square brackets ([]), but not both. Square brackets allow computed property access.
var obj = { foo: { bar: \"baz\", bar2: \"baz2\" } };\nvar i = 2;\n\nobj.[foo].[bar]\n// SyntaxError: missing name after . operator\n\nobj.foo.\"bar\"+i;\n// SyntaxError: missing name after . operator\n To fix this code, you need to access the object like this:
obj.foo.bar; // \"baz\"\n// or alternatively\nobj[\"foo\"][\"bar\"]; // \"baz\"\n\n// computed properties require square brackets\nobj.foo[\"bar\" + i]; // \"baz2\"\n
If you are coming from another programming language (like PHP), it is also easy to mix up the dot operator (.) and the concatenation operator (+).
console.log(\"Hello\" . \"world\");\n\n// SyntaxError: missing name after . operator
Instead you need to use a plus sign for concatenation:
console.log(\"Hello\" + \"World\");
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_name_after_dot_operator\n
SyntaxError: missing variable name (Firefox)\nSyntaxError: Unexpected token = (Chrome)
A variable is missing a name. This is likely due to a syntax error in your code. Probably a comma is wrong somewhere or you struggled with coming up with a name. Totally understandable! Naming things is so hard.
var = \"foo\";\n
It's tough coming up with good variable names. We all have been there.
var ohGodWhy = \"foo\";
There are a few variable names that are reserverd keywords. You can't use these. Sorry :(
var debugger = \"whoop\";\n// SyntaxError: missing variable name\n
Pay special attention to commas when declaring multiple variables. Is there an excess comma? Did you accidentally add commas instead of semicolons?
var x, y = \"foo\",\nvar x, = \"foo\"\n\nvar first = document.getElementById('one'),\nvar second = document.getElementById('two'),\n\n// SyntaxError: missing variable name\n The fixed version:
var x, y = \"foo\";\nvar x = \"foo\";\n\nvar first = document.getElementById('one');\nvar second = document.getElementById('two'); Array literals in JavaScript need square brackets around the values. This won't work:
var arr = 1,2,3,4,5;\n// SyntaxError: missing variable name\n
This would be correct:
var arr = [1,2,3,4,5];
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/No_variable_name\n
Warning: SyntaxError: test for equality (==) mistyped as assignment (=)?\n
(Firefox only) SyntaxError warning which is reported only if javascript.options.strict preference is set to true.
There was an assignment (=) when you would normally expect a test for equality (==). To help debugging, JavaScript (with strict warnings enabled) warns about this pattern.
It is advisable to not use simple assignments in a conditional expression (such as if...else), because the assignment can be confused with equality when glancing over the code. For example, do not use the following code:
if (x = y) {\n // do the right thing\n}\n If you need to use an assignment in a conditional expression, a common practice is to put additional parentheses around the assignment. For example:
if ((x = y)) {\n // do the right thing\n} Otherwise, you probably meant to use a comparison operator (e.g. == or ===):
if (x == y) {\n // do the right thing\n} \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Equal_as_assign\n
SyntaxError: 'return' statement outside of function (Edge)\nSyntaxError: return not in function (Firefox)\nSyntaxError: yield not in function (Firefox)\n
A return or yield statement is called outside of a function. Maybe there are missing curly brackets somewhere? The return and yield statements must be in a function, because they end (or pause and resume) function execution and specify a value to be returned to the function caller.
var cheer = function(score) {\n if (score === 147)\n return 'Maximum!';\n };\n if (score > 100) {\n return 'Century!';\n }\n}\n\n// SyntaxError: return not in function The curly brackets look correct at a first glance, but this code snippet is missing a { after the first if statement. Correct would be:
var cheer = function(score) {\n if (score === 147) {\n return 'Maximum!';\n }\n if (score > 100) {\n return 'Century!';\n }\n}; \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Bad_return_or_yield\n
SyntaxError: Let/Const redeclaration (Edge)\nSyntaxError: redeclaration of formal parameter \"x\" (Firefox)\nSyntaxError: Identifier \"x\" has already been declared (Chrome)\n
The same variable name occurs as a function parameter and is then redeclared using a let assignment in a function body again. Redeclaring the same variable within the same function or block scope using let is not allowed in JavaScript.
In this case, the variable \"arg\" redeclares the argument.
function f(arg) { \n let arg = 'foo'; \n}\n\n// SyntaxError: redeclaration of formal parameter \"arg\"\n If you want to change the value of \"arg\" in the function body, you can do so, but you do not need to declare the same variable again. In other words: you can omit the let keyword. If you want to create a new variable, you need to rename it as conflicts with the function parameter already.
function f(arg) {\n arg = 'foo';\n}\n\nfunction f(arg) { \n let bar = 'foo'; \n}\n TypeError (bug 1275240).letconstvar\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Redeclared_parameter\n
TypeError: Unable to get property {x} of undefined or null reference (Edge)\nTypeError: \"x\" is (not) \"y\" (Firefox)\n\nExamples:\nTypeError: \"x\" is undefined\nTypeError: \"x\" is null\nTypeError: \"undefined\" is not an object\nTypeError: \"x\" is not an object or null\nTypeError: \"x\" is not a symbol\n There was an unexpected type. This occurs oftentimes with undefined or null values.
Also, certain methods, such as Object.create() or Symbol.keyFor(), require a specific type, that must be provided.
// undefined and null cases on which the substring method won't work\nvar foo = undefined;\nfoo.substring(1); // TypeError: foo is undefined\n\nvar foo = null;\nfoo.substring(1); // TypeError: foo is null\n\n\n// Certain methods might require a specific type\nvar foo = {}\nSymbol.keyFor(foo); // TypeError: foo is not a symbol\n\nvar foo = 'bar'\nObject.create(foo); // TypeError: \"foo\" is not an object or null\n To fix null pointer to undefined values, you can use the typeof operator, for example.
if (typeof foo !== 'undefined') {\n // Now we know that foo is defined, we are good to go.\n} \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Unexpected_type\n
TypeError: Unable to get property {x} of undefined or null reference (Edge)\nTypeError: null has no properties (Firefox)\nTypeError: undefined has no properties (Firefox)\n Both, null and undefined, have no properties you could access.
null.foo;\n// TypeError: null has no properties\n\nundefined.bar;\n// TypeError: undefined has no properties\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/No_properties\n
TypeError: Object doesn't support this action (Edge)\nTypeError: \"x\" is not a constructor\n\nTypeError: Math is not a constructor\nTypeError: JSON is not a constructor\nTypeError: Symbol is not a constructor\nTypeError: Reflect is not a constructor\nTypeError: Intl is not a constructor\nTypeError: SIMD is not a constructor\nTypeError: Atomics is not a constructor\n
There was an attempt to use an object or a variable as a constructor, but that object or variable is not a constructor. See constructor or the new operator for more information on what a constructor is.
There are many global objects, like String or Array, which are constructable using new. However, some global objects are not and their properties and methods are static. The following JavaScript standard built-in objects are not a constructor: Math, JSON, Symbol, Reflect, Intl, SIMD, Atomics.
Generator functions cannot be used as constructors either.
var Car = 1;\nnew Car();\n// TypeError: Car is not a constructor\n\nnew Math();\n// TypeError: Math is not a constructor\n\nnew Symbol();\n// TypeError: Symbol is not a constructor\n\nfunction* f() {};\nvar obj = new f;\n// TypeError: f is not a constructor\n Suppose you want to create an object type for cars. You want this type of object to be called car, and you want it to have properties for make, model, and year. To do this, you would write the following function:
function Car(make, model, year) {\n this.make = make;\n this.model = model;\n this.year = year;\n}\n Now you can create an object called mycar as follows:
var mycar = new Car('Eagle', 'Talon TSi', 1993); When returning an immediately-resolved or immediately-rejected Promise, you do not need to create a new Promise(...) and act on it.
This is not legal (the Promise constructor is not being called correctly) and will throw a TypeError: this is not a constructor exception:
return new Promise.resolve(true);\n
Instead, use the Promise.resolve() or Promise.reject() static methods:
// This is legal, but unnecessarily long:\nreturn new Promise((resolve, reject) => { resolve(true); })\n\n// Instead, return the static method:\nreturn Promise.resolve(true);\nreturn Promise.reject(false);\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_a_constructor\n
SyntaxError: Expected '}' (Edge)\nSyntaxError: missing } after function body (Firefox)\n
There is a syntax mistake when creating a function somewhere. Also check if any closing curly brackets or parenthesis are in the correct order. Indenting or formatting the code a bit nicer might also help you to see through the jungle.
Oftentimes, there is a missing curly bracket in your function code:
var charge = function() {\n if (sunny) {\n useSolarCells();\n } else {\n promptBikeRide();\n};\n Correct would be:
var charge = function() {\n if (sunny) {\n useSolarCells();\n } else {\n promptBikeRide(); \n }\n}; It can be more obscure when using IIFE, Closures, or other constructs that use a lot of different parenthesis and curly brackets, for example.
(function() { if (true) { return false; } );\n Oftentimes, indenting differently or double checking indentation helps to spot these errors.
(function() {\n if (true) {\n return false;\n }\n}); \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Missing_curly_after_function_body\n
TypeError: can't access dead object\n
To improve in memory usage and to prevent memory leaks, Firefox disallows add-ons to keep strong references to DOM objects after their parent document has been destroyed. A dead object, is holding a strong (keep alive) reference to a DOM element that persists even after it was destroyed in the DOM. To avoid these issues, references to DOM nodes in foreign document should instead be stored in an object which is specific to that document, and cleaned up when the document is unloaded, or stored as weak references.
Components.utils offers a isDeadWrapper() method, which privileged code might use.
if (Components.utils.isDeadWrapper(window)) {\n // dead\n} Unprivileged code has no access to Component.utils and might just be able catch the exception.
try {\n String(window);\n}\ncatch (e) {\n console.log(\"window is likely dead\");\n} \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Dead_object\n
SyntaxError: Unterminated string constant (Edge)\nSyntaxError: unterminated string literal (Firefox)\n
There is an unterminated String somewhere. String literals must be enclosed by single (') or double (\") quotes. JavaScript makes no distinction between single-quoted strings and double-quoted strings. Escape sequences work in strings created with either single or double quotes. To fix this error, check if:
You can't split a string across multiple lines like this in JavaScript:
var longString = 'This is a very long string which needs \n to wrap across multiple lines because \n otherwise my code is unreadable.';\n// SyntaxError: unterminated string literal
Instead, use the + operator, a backslash, or template literals. The + operator variant looks like this:
var longString = 'This is a very long string which needs ' +\n 'to wrap across multiple lines because ' +\n 'otherwise my code is unreadable.';\n
Or you can use the backslash character (\"\\\") at the end of each line to indicate that the string will continue on the next line. Make sure there is no space or any other character after the backslash (except for a line break), or as an indent; otherwise it will not work. That form looks like this:
var longString = 'This is a very long string which needs \\\nto wrap across multiple lines because \\\notherwise my code is unreadable.';\n
Another possibility is to use template literals, which are supported in ECMAScript 2015 environments:
var longString = `This is a very long string which needs \n to wrap across multiple lines because\n otherwise my code is unreadable.`;
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Unterminated_string_literal\n
TypeError: Unable to get property {x} of undefined or null reference (Edge)\nTypeError: can't access property {x} of {y} (Firefox)\nTypeError: {y} is undefined, can't access property {x} of it (Firefox)\nTypeError: {y} is null, can't access property {x} of it (Firefox)\n\nExamples:\nTypeError: x is undefined, can't access property \"prop\" of it\nTypeError: x is null, can't access property \"prop\" of it\nTypeError: can't access property \"prop\" of undefined\nTypeError: can't access property \"prop\" of null\n The property access was operated on undefined or null value.
// undefined and null cases on which the substring method won't work\nvar foo = undefined;\nfoo.substring(1); // TypeError: x is undefined, can't access property \"substring\" of it\n\nvar foo = null;\nfoo.substring(1); // TypeError: x is null, can't access property \"substring\" of it\n
To fix null pointer to undefined or null values, you can use the typeof operator, for example.
if (typeof foo !== 'undefined') {\n // Now we know that foo is defined, we are good to go.\n} \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cant_access_property\n
TypeError: Cannot create property for a non-extensible object (Edge)\nTypeError: can't define property \"x\": \"obj\" is not extensible (Firefox)\nTypeError: Cannot define property: \"x\", object is not extensible. (Chrome)\n
Usually, an object is extensible and new properties can be added to it. However, in this case Object.preventExtensions() marked an object as no longer extensible, so that it will never have properties beyond the ones it had at the time it was marked as non-extensible.
In strict mode, attempting to add new properties to a non-extensible object throws a TypeError. In sloppy mode, the addition of the \"x\" property is silently ignored.
'use strict';\n\nvar obj = {};\nObject.preventExtensions(obj);\n\nobj.x = 'foo';\n// TypeError: can't define property \"x\": \"obj\" is not extensible\n In both, strict mode and sloppy mode, a call to Object.defineProperty() throws when adding a new property to a non-extensible object.
var obj = { }; \nObject.preventExtensions(obj); \n\nObject.defineProperty(obj, \n 'x', { value: \"foo\" }\n);\n// TypeError: can't define property \"x\": \"obj\" is not extensible\n To fix this error, you will either need to remove the call to Object.preventExtensions() entirely, or move it to a position so that the property is added earlier and only later the object is marked as non-extensible. Of course you can also remove the property that was attempted to be added, if you don't need it.
'use strict'; \n\nvar obj = {}; \nobj.x = 'foo'; // add property first and only then prevent extensions\n\nObject.preventExtensions(obj); \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cant_define_property_object_not_extensible\n
TypeError: argument is not an Object and is not null (Edge)\nTypeError: Object.create requires more than 0 arguments\nTypeError: Object.setPrototypeOf requires more than 1 argument\nTypeError: Object.defineProperties requires more than 0 arguments\n
There is an error with how a function is called. More arguments need to be provided.
The Object.create() method requires at least one argument and the Object.setPrototypeOf() method requires at least two arguments:
var obj = Object.create();\n// TypeError: Object.create requires more than 0 arguments\n\nvar obj = Object.setPrototypeOf({});\n// TypeError: Object.setPrototypeOf requires more than 1 argument\n You can fix this by setting null as the prototype, for example:
var obj = Object.create(null);\n\nvar obj = Object.setPrototypeOf({}, null); \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/More_arguments_needed\n
TypeError: Object doesn't support property or method {x} (Edge)\nTypeError: \"x\" is not a function\n It attempted to call a value from a function, but the value is not actually a function. Some code expects you to provide a function, but that didn't happen.
Maybe there is a typo in the function name? Maybe the object you are calling the method on does not have this function? For example, JavaScript objects have no map function, but the JavaScript Array object does.
There are many built-in functions in need of a (callback) function. You will have to provide a function in order to have these methods working properly:
Array or TypedArray objects: Map and Set objects: In this case, which happens way too often, there is a typo in the method name:
var x = document.getElementByID('foo');\n// TypeError: document.getElementByID is not a function\n The correct function name is getElementById:
var x = document.getElementById('foo');\n For certain methods, you have to provide a (callback) function and it will work on specific objects only. In this example, Array.prototype.map() is used, which will work with Array objects only.
var obj = {a: 13, b: 37, c: 42};\n\nobj.map(function(num) {\n return num * 2;\n});\n\n// TypeError: obj.map is not a function Use an array instead:
var numbers = [1, 4, 9];\n\nnumbers.map(function(num) { \n return num * 2; \n}); \n\n// Array [2, 8, 18]\n Sometimes when making a class, you may have a property and a function with the same name. Upon calling the function, the compiler thinks that the function ceases to exist.
var Dog = function () {\n this.age = 11;\n this.color = \"black\";\n this.name = \"Ralph\";\n return this;\n} \n\nDog.prototype.name = function(name) {\n this.name = name;\n return this;\n}\n\n\nvar myNewDog = new Dog();\nmyNewDog.name(\"Cassidy\"); //Uncaught TypeError: myNewDog.name is not a function\n Use a different property name instead:
var Dog = function () {\n this.age = 11;\n this.color = \"black\";\n this.dogName = \"Ralph\"; //Using this.dogName instead of .name\n return this;\n} \n\nDog.prototype.name = function(name) {\n this.dogName = name;\n return this;\n}\n\n\nvar myNewDog = new Dog();\nmyNewDog.name(\"Cassidy\"); //Dog { age: 11, color: 'black', dogName: 'Cassidy' }\n In math, you can write 2 x (3 + 5) as 2*(3 + 5) or just 2(3 + 5). Using the latter will throw an error:
var sixteen = 2(3 + 5);\nalert('2 x (3 + 5) is ' + String(sixteen));\n//Uncaught TypeError: 2 is not a function You can correct the code by adding a * operator:
var sixteen = 2 * (3 + 5);\nalert('2 x (3 + 5) is ' + String(sixteen));\n//2 x (3 + 5) is 16\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Not_a_function\n
TypeError: Invalid descriptor for property {x} (Edge)\nTypeError: \"x\" is not a non-null object (Firefox)\nTypeError: Property description must be an object: \"x\" (Chrome)\nTypeError: Invalid value used in weak set (Chrome)\n An object is expected somewhere and wasn't provided. null is not an object and won't work. You must provide a proper object in the given situation.
When methods like Object.create() or Object.defineProperty() and Object.defineProperties() are used, the optional descriptor parameter expects a property descriptor object. Providing no object (like just a number), will throw an error:
Object.defineProperty({}, 'key', 1);\n// TypeError: 1 is not a non-null object\n\nObject.defineProperty({}, 'key', null);\n// TypeError: null is not a non-null object\n A valid property descriptor object might look like this:
Object.defineProperty({}, 'key', { value: 'foo', writable: false });\n WeakMap and WeakSet objects require object keysWeakMap and WeakSet objects store object keys. You can't use other types as keys.
var ws = new WeakSet();\nws.add('foo');\n// TypeError: \"foo\" is not a non-null object Use objects instead:
ws.add({foo: 'bar'});\nws.add(window);\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/No_non-null_object\n
TypeError: 'x' is not iterable (Firefox, Chrome)\nTypeError: 'x' is not a function or its return value is not iterable (Chrome)\n
The value which is given as the right hand-side of for…of or as argument of a function such as Promise.all or TypedArray.from, is not an iterable object. An iterable can be a built-in iterable type such as Array, String or Map, a generator result, or an object implementing the iterable protocol.
In JavaScript, Objects are not iterable unless they implement the iterable protocol. Therefore, you cannot use for…of to iterate over the properties of an object.
var obj = { 'France': 'Paris', 'England': 'London' };\nfor (let p of obj) { // TypeError: obj is not iterable\n // …\n}\n Instead you have to use Object.keys or Object.entries, to iterate over the properties or entries of an object.
var obj = { 'France': 'Paris', 'England': 'London' };\n// Iterate over the property names:\nfor (let country of Object.keys(obj)) {\n var capital = obj[country];\n console.log(country, capital);\n}\n\nfor (const [country, capital] of Object.entries(obj))\n console.log(country, capital);\n\n\n Another option for this use case might be to use a Map:
var map = new Map;\nmap.set('France', 'Paris');\nmap.set('England', 'London');\n// Iterate over the property names:\nfor (let country of map.keys()) {\n let capital = map[country];\n console.log(country, capital);\n}\n\nfor (let capital of map.values())\n console.log(capital);\n\nfor (const [country, capital] of map.entries())\n console.log(country, capital);\n Generators are functions you call to produce an iterable object.
function* generate(a, b) {\n yield a;\n yield b;\n}\n\nfor (let x of generate) // TypeError: generate is not iterable\n console.log(x);\n When they are not called, the Function object corresponding to the generator is callable, but not iterable. Calling a generator produces an iterable object which will iterate over the values yielded during the execution of the generator.
function* generate(a, b) {\n yield a;\n yield b;\n}\n\nfor (let x of generate(1,2))\n console.log(x);\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/is_not_iterable\n
TypeError: can't delete non-configurable array element (Firefox)\nTypeError: Cannot delete property '2' of [object Array] (Chrome)\n
It was attempted to shorten the length of an array, but one of the array's elements is non-configurable. When shortening an array, the elements beyond the new array length will be deleted, which failed in this situation.
The configurable attribute controls whether the property can be deleted from the object and whether its attributes (other than writable) can be changed.
Usually, properties in an object created by an array initializer are configurable. However, for example, when using Object.defineProperty(), the property isn't configurable by default.
Object.defineProperty\nThe Object.defineProperty() creates non-configurable properties by default if you haven't specified them as configurable.
var arr = [];\nObject.defineProperty(arr, 0, {value: 0}); \nObject.defineProperty(arr, 1, {value: \"1\"});\n\narr.length = 1;\n// TypeError: can't delete non-configurable array element\n You will need to set the elements as configurable, if you intend to shorten the array.
var arr = [];\nObject.defineProperty(arr, 0, {value: 0, configurable: true});\nObject.defineProperty(arr, 1, {value: \"1\", configurable: true});\n\narr.length = 1;\n Seal-ed ArraysThe Object.seal() function marks all existing elements as non-configurable.
var arr = [1,2,3];\nObject.seal(arr);\n\narr.length = 1;\n// TypeError: can't delete non-configurable array element\n
You either need to remove the Object.seal() call, or make a copy of it. In case of a copy, shortening the copy of the array does not modify the original array length.
var arr = [1,2,3];\nObject.seal(arr);\n\n// Copy the initial array to shorten the copy\nvar copy = Array.from(arr);\ncopy.length = 1;\n// arr.length == 3\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Non_configurable_array_element\n
TypeError: invalid 'instanceof' operand \"x\" (Firefox) \nTypeError: \"x\" is not a function (Firefox) \nTypeError: Right-hand side of 'instanceof' is not an object (Chrome) \nTypeError: Right-hand side of 'instanceof' is not callable (Chrome)
The instanceof operator expects the right hand side operands to be a constructor object, i.e. an object which has a prototype property and is callable.
\"test\" instanceof \"\"; // TypeError: invalid 'instanceof' operand \"\"\n42 instanceof 0; // TypeError: invalid 'instanceof' operand 0\n\nfunction Foo() {}\nvar f = Foo(); // Foo() is called and returns undefined\nvar x = new Foo();\n\nx instanceof f; // TypeError: invalid 'instanceof' operand f\nx instanceof x; // TypeError: x is not a function\n To fix these errors, you will either need to replace the instanceof operator with the typeof operator, or to make sure you use the function name, instead of the result of its evaluation.
typeof \"test\" == \"string\"; // true\ntypeof 42 == \"number\" // true\n\nfunction Foo() {}\nvar f = Foo; // Do not call Foo.\nvar x = new Foo();\n\nx instanceof f; // true\nx instanceof Foo; // true\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/invalid_right_hand_side_instanceof_operand\n
TypeError: cyclic object value (Firefox)\nTypeError: Converting circular structure to JSON (Chrome and Opera)\nTypeError: Circular reference in value argument not supported (Edge)\n
The JSON format per se doesn't support object references (although an IETF draft exists), hence JSON.stringify() doesn't try to solve them and fail accordingly.
In a circular structure like the following
var circularReference = {otherData: 123};\ncircularReference.myself = circularReference;\n JSON.stringify() will fail
JSON.stringify(circularReference);\n// TypeError: cyclic object value\n
To serialize circular references you can use a library that supports them (e.g. cycle.js) or implement a solution by yourself, which will require finding and replacing (or removing) the cyclic references by serializable values.
The snippet below illustrates how to find and filter (thus causing data loss) a cyclic reference by using the replacer parameter of JSON.stringify():
const getCircularReplacer = () => {\n const seen = new WeakSet();\n return (key, value) => {\n if (typeof value === \"object\" && value !== null) {\n if (seen.has(value)) {\n return;\n }\n seen.add(value);\n }\n return value;\n };\n};\n\nJSON.stringify(circularReference, getCircularReplacer());\n// {\"otherData\":123}\n JSON.stringifyJSON.decycle and JSON.retrocycle, which makes it possible to encode and decode cyclical structures and dags into an extended and retrocompatible JSON format.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cyclic_object_value\n
TypeError: reduce of empty array with no initial value\n
In JavaScript, there are several reduce functions:
Array.prototype.reduce(), Array.prototype.reduceRight() andTypedArray.prototype.reduce(), TypedArray.prototype.reduceRight()).These functions optionally take an initialValue (which will be used as the first argument to the first call of the callback). However, if no initial value is provided, it will use the first element of the Array or TypedArray as the initial value. This error is raised when an empty array is provided because no initial value can be returned in that case.
This problem appears frequently when combined with a filter (Array.prototype.filter(), TypedArray.prototype.filter()) which will remove all elements of the list. Thus leaving none to be used as the initial value.
var ints = [0, -1, -2, -3, -4, -5];\nints.filter(x => x > 0) // removes all elements\n .reduce((x, y) => x + y) // no more elements to use for the initial value.
Similarly, the same issue can happen if there is a typo in a selector, or an unexpected number of elements in a list:
var names = document.getElementsByClassName(\"names\");\nvar name_list = Array.prototype.reduce.call(names, (acc, name) => acc + \", \" + name);\n
These problems can be solved in two different ways.
One way is to actually provide an initialValue as the neutral element of the operator, such as 0 for the addition, 1 for a multiplication, or an empty string for a concatenation.
var ints = [0, -1, -2, -3, -4, -5];\nints.filter(x => x < 0) // removes all elements\n .reduce((x, y) => x + y, 0) // the initial value is the neutral element of the addition\n
Another way would be two to handle the empty case, either before calling reduce, or in the callback after adding an unexpected dummy initial value.
var names = document.getElementsByClassName(\"names\");\n\nvar name_list1 = \"\";\nif (names1.length >= 1)\n name_list1 = Array.prototype.reduce.call(names, (acc, name) => acc + \", \" + name);\n// name_list1 == \"\" when names is empty.\n\nvar name_list2 = Array.prototype.reduce.call(names, (acc, name) => {\n if (acc == \"\") // initial value\n return name;\n return acc + \", \" + name;\n}, \"\");\n// name_list2 == \"\" when names is empty.\n Array.prototype.reduce()Array.prototype.reduceRight()TypedArray.prototype.reduce()TypedArray.prototype.reduceRight()ArrayTypedArrayArray.prototype.filter()TypedArray.prototype.filter()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Reduce_of_empty_array_with_no_initial_value\n
TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)\nTypeError: \"x\" is read-only (Firefox)\nTypeError: 0 is read-only (Firefox)\nTypeError: Cannot assign to read only property 'x' of #<Object> (Chrome)\nTypeError: Cannot assign to read only property '0' of [object Array] (Chrome)\n
The global variable or object property that was assigned to is a read-only property. (Technically, it is a non-writable data property.)
This error happens only in strict mode code. In non-strict code, the assignment is silently ignored.
Read-only properties are not super common, but they can be created using Object.defineProperty() or Object.freeze().
'use strict';\nvar obj = Object.freeze({name: 'Elsa', score: 157});\nobj.score = 0; // TypeError\n\n'use strict';\nObject.defineProperty(this, 'LUNG_COUNT', {value: 2, writable: false});\nLUNG_COUNT = 3; // TypeError\n\n'use strict';\nvar frozenArray = Object.freeze([0, 1, 2]);\nfrozenArray[0]++; // TypeError\n There are also a few read-only properties built into JavaScript. Maybe you tried to redefine a mathematical constant.
'use strict';\nMath.PI = 4; // TypeError\n
Sorry, you can't do that.
The global variable undefined is also read-only, so you can't silence the infamous \"undefined is not a function\" error by doing this:
'use strict';\nundefined = function() {}; // TypeError: \"undefined\" is read-only\n 'use strict';\nvar obj = Object.freeze({name: 'Score', points: 157});\nobj = {name: obj.name, points: 0}; // replacing it with a new object works\n\n'use strict';\nvar LUNG_COUNT = 2; // a `var` works, because it's not read-only\nLUNG_COUNT = 3; // ok (anatomically unlikely, though)\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Read-only\n
TypeError: invalid arguments (Firefox)
Typed array constructors require either
ArrayBuffer objectto create a new typed array. Other constructor arguments will not create a valid typed array.
Typed arrays, for example a Uint8Array, can't be constructed from a string. In fact, strings can't be in typed arrays at all.
var ta = new Uint8Array(\"nope\");\n// TypeError: invalid arguments\n
Different ways to create a valid Uint8Array:
// From a length\nvar uint8 = new Uint8Array(2);\nuint8[0] = 42;\nconsole.log(uint8[0]); // 42\nconsole.log(uint8.length); // 2\nconsole.log(uint8.BYTES_PER_ELEMENT); // 1\n\n// From an array\nvar arr = new Uint8Array([21,31]);\nconsole.log(arr[1]); // 31\n\n// From another TypedArray\nvar x = new Uint8Array([21, 31]);\nvar y = new Uint8Array(x);\nconsole.log(y[0]); // 21\n\n// From an ArrayBuffer\nvar buffer = new ArrayBuffer(8);\nvar z = new Uint8Array(buffer, 1, 4);\n\n// From an iterable \nvar iterable = function*(){ yield* [1,2,3]; }(); \nvar uint8 = new Uint8Array(iterable); \n// Uint8Array[1, 2, 3]\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Typed_array_invalid_arguments\n
TypeError: Invalid operand to 'in' (Edge)\nTypeError: right-hand side of 'in' should be an object, got 'x' (Firefox)\nTypeError: cannot use 'in' operator to search for 'x' in 'y' (Firefox, Chrome)\n
The in operator can only be used to check if a property is in an object. You can't search in strings, or in numbers, or other primitive types.
Unlike in other programming languages (e.g. Python), you can't search in strings using the in operator.
\"Hello\" in \"Hello World\"; \n// TypeError: cannot use 'in' operator to search for 'Hello' in 'Hello World'
Instead you will need to use String.prototype.indexOf(), for example.
\"Hello World\".indexOf(\"Hello\") !== -1; \n// true
null or undefined\nMake sure the object you are inspecting isn't actually null or undefined.
var foo = null;\n\"bar\" in foo;\n// TypeError: cannot use 'in' operator to search for 'bar' in 'foo' (Chrome)\n// TypeError: right-hand side of 'in' should be an object, got null (Firefox)\n
The in operator always expects an object.
var foo = { baz: \"bar\" };\n\"bar\" in foo; // false\n\n\"PI\" in Math; // true\n\"pi\" in Math; // false\n Be careful when using the in operator to search in Array objects. The in operator checks the index number, not the value at that index.
var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];\n3 in trees; // true\n\"oak\" in trees; // false
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/in_operator_no_object\n
TypeError: argument is not a function object (Edge)\nTypeError: invalid Array.prototype.sort argument (Firefox)\n
The argument of Array.prototype.sort() is expected to be either undefined or a function which compares its operands.
[1, 3, 2].sort(5); // TypeError\n\nvar cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };\n[1, 3, 2].sort(cmp[this.key] || 'asc'); // TypeError\n [1, 3, 2].sort(); // [1, 2, 3]\n\n\nvar cmp = { asc: (x, y) => x >= y, dsc: (x, y) => x <= y };\n[1, 3, 2].sort(cmp[this.key || 'asc']); // [1, 2, 3] \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Array_sort_argument\n
TypeError: Calling delete on 'x' is not allowed in strict mode (Edge)\nTypeError: property \"x\" is non-configurable and can't be deleted. (Firefox)\nTypeError: Cannot delete property 'x' of #<Object> (Chrome)\n
TypeError in strict mode only.
It was attempted to delete a property, but that property is non-configurable. The configurable attribute controls whether the property can be deleted from the object and whether its attributes (other than writable) can be changed.
This error happens only in strict mode code. In non-strict code, the operation returns false.
Non-configurable properties are not super common, but they can be created using Object.defineProperty() or Object.freeze().
'use strict';\nvar obj = Object.freeze({name: 'Elsa', score: 157});\ndelete obj.score; // TypeError\n\n'use strict';\nvar obj = {};\nObject.defineProperty(obj, 'foo', {value: 2, configurable: false});\ndelete obj.foo; // TypeError\n\n'use strict';\nvar frozenArray = Object.freeze([0, 1, 2]);\nfrozenArray.pop(); // TypeError\n There are also a few non-configurable properties built into JavaScript. Maybe you tried to delete a mathematical constant.
'use strict';\ndelete Math.PI; // TypeError
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cant_delete\n
TypeError: variable \"x\" redeclares argument (Firefox)\n
TypeError warning in strict mode only.
The same variable name occurs as a function parameter and is then redeclared using a var assignment in a function body again. This might be a naming conflict and thus JavaScript warns about it.
This error occurs as a warning in strict mode code only. In non-strict code, the redeclaration is silently ignored.
In this case, the variable \"arg\" redeclares the argument.
'use strict';\n\nfunction f(arg) { \n var arg = 'foo'; \n}\n To fix this warning, the var statement can just be omitted, because the variable exists already. In other cases, you might to rename either the function parameter or the variable name.
'use strict';\n\nfunction f(arg) {\n arg = 'foo';\n}\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Var_hides_argument\n
TypeError: invalid assignment to const \"x\" (Firefox)\nTypeError: Assignment to constant variable. (Chrome)\nTypeError: Assignment to const (Edge)\nTypeError: Redeclaration of const 'x' (IE)\n
A constant is a value that cannot be altered by the program during normal execution. It cannot change through re-assignment, and it can't be redeclared. In JavaScript, constants are declared using the const keyword.
Assigning a value to the same constant name in the same block-scope will throw.
const COLUMNS = 80;\n\n// ...\n\nCOLUMNS = 120; // TypeError: invalid assignment to const `COLUMNS'
There are multiple options to fix this error. Check what was intended to be achieved with the constant in question.
If you meant to declare another constant, pick another name and re-name. This constant name is already taken in this scope.
const COLUMNS = 80;\nconst WIDE_COLUMNS = 120;
const, let or var?Do not use const if you weren't meaning to declare a constant. Maybe you meant to declare a block-scoped variable with let or global variable with var.
let columns = 80;\n\n// ...\n\nlet columns = 120;\n
Check if you are in the correct scope. Should this constant appear in this scope or was it meant to appear in a function, for example?
const COLUMNS = 80;\n\nfunction setupBigScreenEnvironment() {\n const COLUMNS = 120;\n} const and immutabilityThe const declaration creates a read-only reference to a value. It does not mean the value it holds is immutable, just that the variable identifier cannot be reassigned. For instance, in case the content is an object, this means the object itself can still be altered. This means that you can't mutate the value stored in a variable:
const obj = {foo: 'bar'};\nobj = {foo: 'baz'}; // TypeError: invalid assignment to const `obj'\n But you can mutate the properties in a variable:
obj.foo = 'baz';\nobj; // Object { foo: \"baz\" } \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_const_assignment\n
A WebAssembly.Instance object is a stateful, executable instance of a WebAssembly.Module. Instance objects contain all the Exported WebAssembly functions that allow calling into WebAssembly code from JavaScript.
The WebAssembly.Instance() constructor function can be called to synchronously instantiate a given WebAssembly.Module object. However, the primary way to get an Instance is through the asynchronous WebAssembly.instantiateStreaming() function.
Important: Since instantiation for large modules can be expensive, developers should only use the Instance() constructor when synchronous instantiation is absolutely required; the asynchronous WebAssembly.instantiateStreaming() method should be used at all other times.
var myInstance = new WebAssembly.Instance(module, importObject);
WebAssembly.Module object to be instantiated.Instance, such as functions or WebAssembly.Memory objects. There must be one matching property for each declared import of module or else a WebAssembly.LinkError is thrown.Instance instancesAll Instance instances inherit from the Instance() constructor's prototype object — this can be modified to affect all Instance instances.
Instance.prototype.constructorWebAssembly.Instance() constructor.Instance.prototype.exports Read only \nNone.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'Instance' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
exports | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
prototype | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
exports | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
prototype | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
exports | \n8.0.0 | \n
prototype | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance\n
URIError: The URI to be encoded contains invalid character (Edge)\nURIError: malformed URI sequence (Firefox)\nURIError: URI malformed (Chrome)\n
URI encoding or decoding wasn't successful. An argument given to either the decodeURI, encodeURI, encodeURIComponent, or decodeURIComponent function was not valid, so that the function was unable encode or decode properly.
Encoding replaces each instance of certain characters by one, two, three, or four escape sequences representing the UTF-8 encoding of the character. An URIError will be thrown if there is an attempt to encode a surrogate which is not part of a high-low pair, for example:
encodeURI('\\uD800');\n// \"URIError: malformed URI sequence\"\n\nencodeURI('\\uDFFF');\n// \"URIError: malformed URI sequence\"\n A high-low pair is ok. For example:
encodeURI('\\uD800\\uDFFF');\n// \"%F0%90%8F%BF\" Decoding replaces each escape sequence in the encoded URI component with the character that it represents. If there isn't such a character, an error will be thrown:
decodeURIComponent('%E0%A4%A');\n// \"URIError: malformed URI sequence\"\n With proper input, this should usually look like something like this:
decodeURIComponent('JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B');\n// \"JavaScript_шеллы\" \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Malformed_URI\n
Warning: SyntaxError: 08 is not a legal ECMA-262 octal constant.\nWarning: SyntaxError: 09 is not a legal ECMA-262 octal constant.\n
Warning. JavaScript execution won't be halted.
Decimal literals can start with a zero (0) followed by another decimal digit, but If all digits after the leading 0 are smaller than 8, the number is interpreted as an octal number. Because this is not the case with 08 and 09, JavaScript warns about it.
Note that octal literals and octal escape sequences are deprecated and will present an additional deprecation warning. With ECMAScript 6 and later, the syntax uses a leading zero followed by a lowercase or uppercase Latin letter \"O\" (0o or 0O). See the page about lexical grammar for more information.
08;\n09;\n// SyntaxError: 08 is not a legal ECMA-262 octal constant\n// SyntaxError: \"0\"-prefixed octal literals and octal escape sequences\n// are deprecated
Use a leading zero followed by the letter \"o\";
0O755;\n0o644;\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Bad_octal\n
Warning: Date.prototype.toLocaleFormat is deprecated; consider using Intl.DateTimeFormat instead\n
Warning. JavaScript execution won't be halted.
The non-standard Date.prototype.toLocaleFormat method is deprecated and shouldn't be used anymore. It uses a format string in the same format expected by the strftime() function in C. The function is no longer available in Firefox 58+.
The Date.prototype.toLocaleFormat method is deprecated and will be removed (no cross-browser support, available in Firefox only).
var today = new Date(); \nvar date = today.toLocaleFormat('%A, %e. %B %Y');\n\nconsole.log(date);\n// In German locale\n// \"Freitag, 10. März 2017\" The ECMA-402 (ECMAScript Intl API) standard specifies standard objects and methods that enable language sensitive date and time formatting (available in Chrome 24+, Firefox 29+, IE11+, Safari10+).
You can now either use the Date.prototype.toLocaleDateString method if you just want to format one date.
var today = new Date();\nvar options = { weekday: 'long', year: 'numeric',\n month: 'long', day: 'numeric' };\nvar date = today.toLocaleDateString('de-DE', options);\n\nconsole.log(date);\n// \"Freitag, 10. März 2017\"\n Or, you can make use of the Intl.DateTimeFormat object, which allows you to cache an object with most of the computations done so that formatting is fast. This is useful if you have a loop of dates to format.
var options = { weekday: 'long', year: 'numeric', \n month: 'long', day: 'numeric' }; \nvar dateFormatter = new Intl.DateTimeFormat('de-DE', options)\n\nvar dates = [Date.UTC(2012, 11, 20, 3, 0, 0), \n Date.UTC(2014, 04, 12, 8, 0, 0)]; \n\ndates.forEach(date => console.log(dateFormatter.format(date)));\n\n// \"Donnerstag, 20. Dezember 2012\"\n// \"Montag, 12. Mai 2014\"\n The Date object offers several methods to build a custom date string.
(new Date()).toLocaleFormat(\"%Y%m%d\");\n// \"20170310\"\n
Can be converted to:
let now = new Date();\nlet date = now.getFullYear() * 10000 + \n (now.getMonth() + 1) * 100 + now.getDate();\n\nconsole.log(date);\n// \"20170310\"
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Deprecated_toLocaleFormat\n
TypeError: Cannot modify non-writable property {x} (Edge)\nTypeError: can't redefine non-configurable property \"x\" (Firefox)\nTypeError: Cannot redefine property: \"x\" (Chrome)\n It was attempted to redefine a property, but that property is non-configurable. The configurable attribute controls whether the property can be deleted from the object and whether its attributes (other than writable) can be changed. Usually, properties in an object created by an object initializer are configurable. However, for example, when using Object.defineProperty(), the property isn't configurable by default.
Object.defineProperty\nThe Object.defineProperty() creates non-configurable properties if you haven't specified them as configurable.
var obj = Object.create({});\nObject.defineProperty(obj, \"foo\", {value: \"bar\"}); \n\nObject.defineProperty(obj, \"foo\", {value: \"baz\"});\n// TypeError: can't redefine non-configurable property \"foo\"\n You will need to set the \"foo\" property to configurable, if you intend to redefine it later in the code.
var obj = Object.create({});\nObject.defineProperty(obj, \"foo\", {value: \"bar\", configurable: true});\nObject.defineProperty(obj, \"foo\", {value: \"baz\", configurable: true}); \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cant_redefine_property\n
Warning: JavaScript 1.6's for-each-in loops are deprecated; consider using ES6 for-of instead\n
Warning
JavaScript 1.6's for each (variable in obj) statement is deprecated, and will be removed in the near future.
for each...in has been used to iterate over the specified object values.
var object = { a: 10, b: 20 };\n\nfor each (var x in object) {\n console.log(x); // 10\n // 20\n}\n You can now use the standard for...in loop to iterate over specified object keys, and get each value inside the loop:
var object = { a: 10, b: 20 };\n\nfor (var key in object) {\n var x = object[key];\n console.log(x); // 10\n // 20\n}\n Or, using for...of (ES2015) and Object.values (ES2017), you can get an array of the specified object values and iterate over the array like this:
var object = { a: 10, b: 20 };\n\nfor (var x of Object.values(object)) {\n console.log(x); // 10\n // 20\n}\n for each...in has been used to iterate over specified array elements.
var array = [10, 20, 30];\n\nfor each (var x in array) {\n console.log(x); // 10\n // 20\n // 30\n}\n This is now possible with for...of (ES2015) loops as well.
var array = [10, 20, 30];\n\nfor (var x of array) {\n console.log(x); // 10\n // 20\n // 30\n}\n for each...in does nothing if the specified value is null or undefined, but for...of will throw an exception in these cases.
function func(array) {\n for each (var x in array) {\n console.log(x);\n }\n}\nfunc([10, 20]); // 10\n // 20\nfunc(null); // prints nothing\nfunc(undefined); // prints nothing\n To rewrite for each...in statements so that values can be null or undefined with for...of as well, you need to guard around for...of.
function func(array) {\n if (array) {\n for (var x of array) {\n console.log(x);\n }\n }\n}\nfunc([10, 20]); // 10\n // 20\nfunc(null); // prints nothing\nfunc(undefined); // prints nothing\n There's a deprecated idiom to iterate over the specified object's key-value pairs using for each...in and the deprecated Iterator object.
var object = { a: 10, b: 20 };\n\nfor each (var [key, value] in Iterator(object)) {\n console.log(key, value); // \"a\", 10\n // \"b\", 20\n}\n You can now use the standard for...in loop to iterate over specified object keys, and get each value inside the loop:
var object = { a: 10, b: 20 };\n\nfor (var key in object) {\n var value = object[key];\n console.log(key, value); // \"a\", 10\n // \"b\", 20\n}\n Or, using for...of (ES2015) and Object.entries (ES2017), you can get an array of the specified object values and iterate over the array like this:
var object = { a: 10, b: 20 };\n\nfor (var [key, value] of Object.entries(object)) {\n console.log(key, value); // \"a\", 10\n // \"b\", 20\n}\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated\n
The WebAssembly.Memory() constructor creates a new Memory object which is a resizable ArrayBuffer that holds the raw bytes of memory accessed by a WebAssembly Instance.
A memory created by JavaScript or in WebAssembly code will be accessible and mutable from both JavaScript and WebAssembly.
var myMemory = new WebAssembly.Memory(memoryDescriptor);
maximum parameter acts as a hint to the engine to reserve memory up front. However, the engine may ignore or clamp this reservation request. In general, most WebAssembly modules shouldn't need to set a maximum.Note: A WebAssembly page has a constant size of 65,536 bytes, i.e., 64KiB.
memoryDescriptor is not of type object, a TypeError is thrown.maximum is specified and is smaller than initial, a RangeError is thrown.Memory instancesAll Memory instances inherit from the Memory() constructor's prototype object — this can be modified to affect all Memory instances.
Memory.prototype.constructorWebAssembly.Memory() constructor.Memory.prototype.bufferMemory.prototype.grow()There are two ways to get a WebAssembly.Memory object. The first way is to construct it from JavaScript. The following example creates a new WebAssembly Memory instance with an initial size of 10 pages (640KiB), and a maximum size of 100 pages (6.4MiB).
var memory = new WebAssembly.Memory({initial:10, maximum:100}); The second way to get a WebAssembly.Memory object is to have it exported by a WebAssembly module. The following example (see memory.html on GitHub, and view it live also) fetches and instantiates the loaded memory.wasm byte code using the WebAssembly.instantiateStreaming() method, while importing the memory created in the line above. It then stores some values in that memory, then exports a function and uses it to sum some values.
WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })\n.then(obj => {\n var i32 = new Uint32Array(memory.buffer);\n for (var i = 0; i < 10; i++) {\n i32[i] = i;\n }\n var sum = obj.instance.exports.accumulate(0, 10);\n console.log(sum);\n}); | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'Memory' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
buffer | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
grow | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
prototype | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
buffer | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
grow | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
prototype | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
buffer | \n8.0.0 | \n
grow | \n8.0.0 | \n
prototype | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory\n
The WebAssembly.RuntimeError() constructor creates a new WebAssembly RuntimeError object — the type that is thrown whenever WebAssembly specifies a trap.
new WebAssembly.RuntimeError(message, fileName, lineNumber)
message Optional\nfileName Optional\nlineNumber Optional\nThe RuntimeError constructor contains no unique properties of its own, however, it does inherit some properties through the prototype chain.
WebAssembly.RuntimeError.prototype.constructorWebAssembly.RuntimeError.prototype.messageURIError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.WebAssembly.RuntimeError.prototype.nameError.WebAssembly.RuntimeError.prototype.fileNameError.WebAssembly.RuntimeError.prototype.lineNumberError.WebAssembly.RuntimeError.prototype.columnNumberError.WebAssembly.RuntimeError.prototype.stackError.The RuntimeError constructor contains no methods of its own, however, it does inherit some methods through the prototype chain.
WebAssembly.RuntimeError.prototype.toSource()Error.WebAssembly.RuntimeError.prototype.toString()Error object.. Inherited from Error.The following snippet creates a new RuntimeError instance, and logs its details to the console:
try {\n throw new WebAssembly.RuntimeError('Hello', 'someFile', 10);\n} catch (e) {\n console.log(e instanceof RuntimeError); // true\n console.log(e.message); // \"Hello\"\n console.log(e.name); // \"RuntimeError\"\n console.log(e.fileName); // \"someFile\"\n console.log(e.lineNumber); // 10\n console.log(e.columnNumber); // 0\n console.log(e.stack); // returns the location where the code was run\n} | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly constructors' in that specification. | Working Draft | Initial WebAssembly draft definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NativeError' in that specification. | Draft | Definition of standard NativeError types. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError\n
TypeError: Assignment to read-only properties is not allowed in strict mode (Edge)\nTypeError: setting getter-only property \"x\" (Firefox)\nTypeError: Cannot set property \"prop\" of #<Object> which has only a getter (Chrome)\n
TypeError in strict mode only.
There is an attempt to set a new value to a property for which only a getter is specified. While this will be silently ignored in non-strict mode, it will throw a TypeError in strict mode.
The example below shows how to set getter for a property. It doesn't specify a setter, so a TypeError will be thrown upon trying to set the temperature property to 30. For more details see also the Object.defineProperty() page.
\"use strict\";\n\nfunction Archiver() { \n var temperature = null; \n Object.defineProperty(this, 'temperature', { \n get: function() { \n console.log('get!'); \n return temperature; \n }\n });\n}\n\nvar arc = new Archiver(); \narc.temperature; // 'get!'\n\narc.temperature = 30;\n// TypeError: setting getter-only property \"temperature\" To fix this error, you will either need to remove line 16, where there is an attempt to set the temperature property, or you will need to implement a setter for it, for example like this:
\"use strict\";\n\nfunction Archiver() {\n var temperature = null;\n var archive = [];\n\n Object.defineProperty(this, 'temperature', {\n get: function() {\n console.log('get!');\n return temperature;\n },\n set: function(value) {\n temperature = value;\n archive.push({ val: temperature });\n }\n });\n\n this.getArchive = function() { return archive; };\n}\n\nvar arc = new Archiver();\narc.temperature; // 'get!'\narc.temperature = 11;\narc.temperature = 13;\narc.getArchive(); // [{ val: 11 }, { val: 13 }] \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Getter_only\n
The WebAssembly.LinkError() constructor creates a new WebAssembly LinkError object, which indicates an error during module instantiation (besides traps from the start function).
new WebAssembly.LinkError(message, fileName, lineNumber)
message Optional\nfileName Optional\nlineNumber Optional\nThe LinkError constructor contains no unique properties of its own, however, it does inherit some properties through the prototype chain.
WebAssembly.LinkError.prototype.constructorWebAssembly.LinkError.prototype.messageURIError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.WebAssembly.LinkError.prototype.nameError.WebAssembly.LinkError.prototype.fileNameError.WebAssembly.LinkError.prototype.lineNumberError.WebAssembly.LinkError.prototype.columnNumberError.WebAssembly.LinkError.prototype.stackError.The LinkError constructor contains no methods of its own, however, it does inherit some methods through the prototype chain.
WebAssembly.LinkError.prototype.toSource()Error.WebAssembly.LinkError.prototype.toString()Error object.. Inherited from Error.The following snippet creates a new LinkError instance, and logs its details to the console:
try {\n throw new WebAssembly.LinkError('Hello', 'someFile', 10);\n} catch (e) {\n console.log(e instanceof LinkError); // true\n console.log(e.message); // \"Hello\"\n console.log(e.name); // \"LinkError\"\n console.log(e.fileName); // \"someFile\"\n console.log(e.lineNumber); // 10\n console.log(e.columnNumber); // 0\n console.log(e.stack); // returns the location where the code was run\n} | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly constructors' in that specification. | Working Draft | Initial WebAssembly draft definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NativeError' in that specification. | Draft | Definition of standard NativeError types. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The function.arguments property refers to an an array-like object corresponding to the arguments passed to a function. Use the simple variable arguments instead. This property is forbidden in strict model due to tail call optimization.
The syntax function.arguments is deprecated. The recommended way to access the arguments object available within functions is simply to refer to the variable arguments.
In the case of recursion, i.e. if function f appears several times on the call stack, the value of f.arguments represents the arguments corresponding to the most recent invocation of the function.
The value of the arguments property is normally null if there is no outstanding invocation of the function in progress (that is, the function has been called but has not yet returned.
function f(n) { g(n - 1); }\n\nfunction g(n) {\n console.log('before: ' + g.arguments[0]);\n if (n > 0) { f(n); }\n console.log('after: ' + g.arguments[0]);\n}\n\nf(2);\n\nconsole.log('returned: ' + g.arguments);\n\n// Output\n\n// before: 1\n// before: 0\n// after: 0\n// after: 1\n// returned: null\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. Deprecated in favor of arguments in ES3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'arguments object' in that specification. | Standard | \narguments object |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'arguments object' in that specification. | Standard | \narguments object |
| ECMAScript Latest Draft (ECMA-262) The definition of 'arguments object' in that specification. | Draft | \narguments object |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
arguments object\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/arguments\n
TypeError: 'this' is not a Set object (EdgE)\nTypeError: Function.prototype.toString called on incompatible object (Firefox)\nTypeError: Function.prototype.bind called on incompatible target (Firefox)\nTypeError: Method Set.prototype.add called on incompatible receiver undefined (Chrome)\nTypeError: Bind must be called on a function (Chrome)\n
When this error is thrown, a function (on a given object), is called with a this not corresponding to the type expected by the function.
This issue can arise when using the Function.prototype.call() or Function.prototype.apply() methods, and providing a this argument which does not have the expected type.
This issue can also happen when providing a function (stored in an object) as an argument to another function. In this case, the object won't the this target of the function. To work-around this issue, you will either need to provide a lambda which is making the call, or use the Function.prototype.bind() function to force the this argument to the expected object.
var mySet = new Set;\n['bar', 'baz'].forEach(mySet.add);\n// mySet.add is a function, but \"mySet\" is not captured as this.\n\nvar myFun = function () {\n console.log(this);\n};\n['bar', 'baz'].forEach(myFun.bind);\n// myFun.bind is a function, but \"myFun\" is not captured as this.\n\n var mySet = new Set;\n['bar', 'baz'].forEach(mySet.add.bind(mySet));\n// This works due to binding \"mySet\" as this.\n\nvar myFun = function () {\n console.log(this);\n};\n['bar', 'baz'].forEach(x => myFun.bind(x));\n// This works using the \"bind\" function. It creates a lambda forwarding the argument.\n\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Called_on_incompatible_type\n
WebAssembly.Module object contains stateless WebAssembly code that has already been compiled by the browser and can be efficiently shared with Workers, and instantiated multiple times. To instantiate the module, call the secondary overload of WebAssembly.instantiate(). The WebAssembly.Module() constructor function can be called to synchronously compile given WebAssembly binary code. However, the primary way to get a Module is through an asynchronous compilation function like WebAssembly.compile(). Important: Since compilation for large modules can be expensive, developers should only use the Module() constructor when synchronous compilation is absolutely required; the asynchronous WebAssembly.compileStreaming() method should be used at all other times.
var myModule = new WebAssembly.Module(bufferSource);
Module ConstructorWebAssembly.Module.customSections()Module and string, returns a copy of the contents of all custom sections in the module with the given string name.WebAssembly.Module.exports()Module, returns an array containing descriptions of all the declared exports.WebAssembly.Module.imports()Module, returns an array containing descriptions of all the declared imports.Module instancesAll Module instances inherit from the Module() constructor's prototype object — this can be modified to affect all Module instances.
Module.prototype.constructorWebAssembly.Module() constructor.Module.prototype[@@toStringTag]Module instances have no default methods of their own.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly.Module()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
customSections | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
exports | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
imports | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
prototype | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
customSections | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
exports | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
imports | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
prototype | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
customSections | \n8.0.0 | \n
exports | \n8.0.0 | \n
imports | \n8.0.0 | \n
prototype | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module\n
The WebAssembly.CompileError() constructor creates a new WebAssembly CompileError object, which indicates an error during WebAssembly decoding or validation.
new WebAssembly.CompileError(message, fileName, lineNumber)
message Optional\nfileName Optional\nlineNumber Optional\nThe CompileError constructor contains no unique properties of its own, however, it does inherit some properties through the prototype chain.
WebAssembly.CompileError.prototype.constructorWebAssembly.CompileError.prototype.messageURIError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.WebAssembly.CompileError.prototype.nameError.WebAssembly.CompileError.prototype.fileNameError.WebAssembly.CompileError.prototype.lineNumberError.WebAssembly.CompileError.prototype.columnNumberError.WebAssembly.CompileError.prototype.stackError.The CompileError constructor contains no methods of its own, however, it does inherit some methods through the prototype chain.
WebAssembly.CompileError.prototype.toSource()Error.WebAssembly.CompileError.prototype.toString()Error object.. Inherited from Error.The following snippet creates a new CompileError instance, and logs its details to the console:
try {\n throw new WebAssembly.CompileError('Hello', 'someFile', 10);\n} catch (e) {\n console.log(e instanceof CompileError); // true\n console.log(e.message); // \"Hello\"\n console.log(e.name); // \"CompileError\"\n console.log(e.fileName); // \"someFile\"\n console.log(e.lineNumber); // 10\n console.log(e.columnNumber); // 0\n console.log(e.stack); // returns the location where the code was run\n} | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly constructors' in that specification. | Working Draft | Initial WebAssembly draft definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NativeError' in that specification. | Draft | Definition of standard NativeError types. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError\n
The AsyncFunction.prototype property represents the AsyncFunction prototype object.
AsyncFunction objects inherit from AsyncFunction.prototype. AsyncFunction.prototype cannot be modified.
AsyncFunction.constructorAsyncFunction.AsyncFunction.prototype[@@toStringTag]| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'AsyncFunction.prototype' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n55 | \n? | \n52 | \nNo | \n42 | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n55 | \n? | \n52 | \n42 | \n? | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 7.6.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype\n
Warning: String.charAt is deprecated; use String.prototype.charAt instead\nWarning: String.charCodeAt is deprecated; use String.prototype.charCodeAt instead\nWarning: String.concat is deprecated; use String.prototype.concat instead\nWarning: String.contains is deprecated; use String.prototype.contains instead\nWarning: String.endsWith is deprecated; use String.prototype.endsWith instead\nWarning: String.includes is deprecated; use String.prototype.includes instead\nWarning: String.indexOf is deprecated; use String.prototype.indexOf instead\nWarning: String.lastIndexOf is deprecated; use String.prototype.lastIndexOf instead\nWarning: String.localeCompare is deprecated; use String.prototype.localeCompare instead\nWarning: String.match is deprecated; use String.prototype.match instead\nWarning: String.normalize is deprecated; use String.prototype.normalize instead\nWarning: String.replace is deprecated; use String.prototype.replace instead\nWarning: String.search is deprecated; use String.prototype.search instead\nWarning: String.slice is deprecated; use String.prototype.slice instead\nWarning: String.split is deprecated; use String.prototype.split instead\nWarning: String.startsWith is deprecated; use String.prototype.startsWith instead\nWarning: String.substr is deprecated; use String.prototype.substr instead\nWarning: String.substring is deprecated; use String.prototype.substring instead\nWarning: String.toLocaleLowerCase is deprecated; use String.prototype.toLocaleLowerCase instead\nWarning: String.toLocaleUpperCase is deprecated; use String.prototype.toLocaleUpperCase instead\nWarning: String.toLowerCase is deprecated; use String.prototype.toLowerCase instead\nWarning: String.toUpperCase is deprecated; use String.prototype.toUpperCase instead\nWarning: String.trim is deprecated; use String.prototype.trim instead\nWarning: String.trimLeft is deprecated; use String.prototype.trimLeft instead\nWarning: String.trimRight is deprecated; use String.prototype.trimRight instead\n
Warning. JavaScript execution won't be halted.
The non-standard generic String methods are deprecated and will be removed in the future (no cross-browser support, available in Firefox only). String generics provide String instance methods on the String object allowing String methods to be applied to any object.
Firefox bug 1222552 tracks the removal of String generic methods.
var num = 15; \nString.replace(num, /5/, '2');
var num = 15;\nString(num).replace(/5/, '2');\n
The following is a shim to provide support to non-supporting browsers:
/*globals define*/\n// Assumes all supplied String instance methods already present\n// (one may use shims for these if not available)\n(function() {\n 'use strict';\n\n var i,\n // We could also build the array of methods with the following, but the\n // getOwnPropertyNames() method is non-shimable:\n // Object.getOwnPropertyNames(String).filter(function(methodName) {\n // return typeof String[methodName] === 'function';\n // });\n methods = [\n 'contains', 'substring', 'toLowerCase', 'toUpperCase', 'charAt',\n 'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith',\n 'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase', 'normalize',\n 'toLocaleUpperCase', 'localeCompare', 'match', 'search', 'slice',\n 'replace', 'split', 'substr', 'concat', 'localeCompare'\n ],\n methodCount = methods.length,\n assignStringGeneric = function(methodName) {\n var method = String.prototype[methodName];\n String[methodName] = function(arg1) {\n return method.apply(arg1, Array.prototype.slice.call(arguments, 1));\n };\n };\n\n for (i = 0; i < methodCount; i++) {\n assignStringGeneric(methods[i]);\n }\n}()); \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Deprecated_String_generics\n
Warning: unreachable code after return statement (Firefox)\n
Warning
Unreachable code after a return statement might occur in these situations:
return statement, orWhen an expression exists after a valid return statement, a warning is given to indicate that the code after the return statement is unreachable, meaning it can never be run.
Why should I have semicolons after return statements? In the case of semicolon-less return statements, it can be unclear whether the developer intended to return the statement on the following line, or to stop execution and return. The warning indicates that there is ambiguity in the way the return statement is written.
Warnings will not be shown for semicolon-less returns if these statements follow it:
function f() {\n var x = 3;\n x += 4;\n return x; // return exits the function immediately\n x -= 3; // so this line will never run; it is unreachable\n}\n\nfunction f() {\n return // this is treated like `return;`\n 3 + 4; // so the function returns, and this line is never reached\n}\n function f() {\n var x = 3;\n x += 4;\n x -= 3;\n return x; // OK: return after all other statements\n}\n\nfunction f() {\n return 3 + 4 // OK: semicolon-less return with expression on the same line\n}\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Stmt_after_return\n
The length property indicates the number of Parameters expected by the function.
Property attributes of Function.length\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
length is a property of a function object, and indicates how many arguments the function expects, i.e. the number of formal parameters. This number excludes the rest parameter and only includes parameters before the first one with a default value. By contrast, arguments.length is local to a function and provides the number of arguments actually passed to the function.
Function constructorThe Function constructor is itself a Function object. Its length data property has a value of 1. The property attributes are: Writable: false, Enumerable: false, Configurable: true.
Function prototype objectThe length property of the Function prototype object has a value of 0.
console.log(Function.length); /* 1 */\n\nconsole.log((function() {}).length); /* 0 */\nconsole.log((function(a) {}).length); /* 1 */\nconsole.log((function(a, b) {}).length); /* 2 etc. */\n\nconsole.log((function(...args) {}).length); \n// 0, rest parameter is not counted\n\nconsole.log((function(a, b = 1, c) {}).length);\n// 1, only parameters before the first one with \n// a default value is counted | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Function.length' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function.length' in that specification. | Standard | The configurable attribute of this property is now true. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function.length' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Configurable: true | \n? | \n? | \n37 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Configurable: true | \n? | \n? | \n? | \n37 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Configurable: true | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/length\n
The call() method calls a function with a given this value and arguments provided individually.
Note: While the syntax of this function is almost identical to that of apply(), the fundamental difference is that call() accepts an argument list, while apply() accepts a single array of arguments.
function.call(thisArg, arg1, arg2, ...)
thisArgthis provided for the call to a function. Note that this may not be the actual value seen by the method: if the method is a function in non-strict mode, null and undefined will be replaced with the global object and primitive values will be converted to objects.arg1, arg2, ...The result of calling the function with the specified this value and arguments.
The call() allows for a function/method belonging to one object to be assigned and called for a different object.
call() provides a new value of this to the function/method. With call, you can write a method once and then inherit it in another object, without having to rewrite the method for the new object.
call to chain constructors for an objectYou can use call to chain constructors for an object, similar to Java. In the following example, the constructor for the Product object is defined with two parameters, name and price. Two other functions Food and Toy invoke Product passing this and name and price. Product initializes the properties name and price, both specialized functions define the category.
function Product(name, price) {\n this.name = name;\n this.price = price;\n}\n\nfunction Food(name, price) {\n Product.call(this, name, price);\n this.category = 'food';\n}\n\nfunction Toy(name, price) {\n Product.call(this, name, price);\n this.category = 'toy';\n}\n\nvar cheese = new Food('feta', 5);\nvar fun = new Toy('robot', 40);\n call to invoke an anonymous functionIn this example, we create an anonymous function and use call to invoke it on every object in an array. The main purpose of the anonymous function here is to add a print function to every object, which is able to print the right index of the object in the array. Passing the object as this value was not strictly necessary, but is done for explanatory purpose.
var animals = [\n { species: 'Lion', name: 'King' },\n { species: 'Whale', name: 'Fail' }\n];\n\nfor (var i = 0; i < animals.length; i++) {\n (function(i) {\n this.print = function() {\n console.log('#' + i + ' ' + this.species\n + ': ' + this.name);\n }\n this.print();\n }).call(animals[i], i);\n}\n call to invoke a function and specifying the context for 'this'In the example below, when we call greet, the value of this will be bound to object obj.
function greet() {\n var reply = [this.animal, 'typically sleep between', this.sleepDuration].join(' ');\n console.log(reply);\n}\n\nvar obj = {\n animal: 'cats', sleepDuration: '12 and 16 hours'\n};\n\ngreet.call(obj); // cats typically sleep between 12 and 16 hours\n call to invoke a function and without specifying the first argumentIn the example below, we invoke the display function without passing the first argument. If the first argument is not passed, the value of this is bound to the global object.
var sData = 'Wisen';\n\nfunction display() {\n console.log('sData value is %s ', this.sData);\n}\n\ndisplay.call(); // sData value is Wisen Note: The value of this will be undefined in strict mode. See below.
'use strict';\n\nvar sData = 'Wisen';\n\nfunction display() {\n console.log('sData value is %s ', this.sData);\n}\n\ndisplay.call(); // Cannot read the property of 'sData' of undefined | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Function.prototype.call' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function.prototype.call' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function.prototype.call' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call\n
Warning: expression closures are deprecated\n
Warning. JavaScript execution won't be halted.
The non-standard expression closure syntax (shorthand function syntax) is deprecated and shouldn't be used anymore. This syntax will be removed entirely in bug 1083458 and scripts using it will throw a SyntaxError then.
Expression closures omit curly braces or return statements from function declarations or from method definitions in objects.
var x = function() 1;\n\nvar obj = { \n count: function() 1\n};\n To convert the non-standard expression closures syntax to standard ECMAScript syntax, you can add curly braces and return statements.
var x = function() { return 1; }\n\nvar obj = {\n count: function() { return 1; }\n};\n Alternatively, you can use arrow functions:
var x = () => 1;
Expression closures can also be found with getter and setter, like this:
var obj = {\n get x() 1,\n set x(v) this.v = v\n};\n With ES2015 method definitions, this can be converted to:
var obj = { \n get x() { return 1 }, \n set x(v) { this.v = v } \n};\n \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Deprecated_expression_closures\n
The Function.prototype property represents the Function prototype object.
Function objects inherit from Function.prototype. Function.prototype cannot be modified.
Function.prototype.arguments \nFunction. Use the arguments object available within the function instead.Function.arity length property instead.Function.prototype.caller \nFunction.prototype.lengthFunction.prototype.nameFunction.displayName \nFunction.prototype.constructorObject.prototype.constructor for more details.Function.prototype.apply()Array object.Function.prototype.bind()Function.prototype.call()Function.prototype.isGenerator() \ntrue if the function is a generator; otherwise returns false.Function.prototype.toSource() \nObject.prototype.toSource method.Function.prototype.toString()Object.prototype.toString method.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1 |
| ECMAScript 5.1 (ECMA-262) The definition of 'Function.prototype' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function.prototype' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype\n
ECMAScript 5 introduced strict mode which is now implemented in all major browsers (including IE10). While making web browsers interpret code as strict is easy (just add 'use strict'; at the top of your source code), transitioning an existing code base to strict mode requires a bit more work.
This article aims at providing guidance for developers.
Strict mode has been designed so that the transition to it can be made gradually. It is possible to change each file individually and even to transition code to strict mode down to the function granularity.
When adding 'use strict';, the following cases will throw a SyntaxError before the script is executing:
var n = 023;\nwith statementdelete on a variable name delete myVariable;eval or arguments as variable or function argument nameimplements, interface, let, package, private, protected, public, static, and yield\nif (a < b) { function f() {} }\n{a: 1, b: 3, a: 7} This is no longer the case in ECMAScript 2015 (bug 1041128).function f(a, b, b) {}\nThese errors are good, because they reveal plain errors or bad practices. They occur before the code is running.
JavaScript used to silently fail in contexts where what was done was an error. Strict mode throws in such cases. If your code base contains such cases, testing will be necessary to be sure nothing is broken. Once again, it can happen at the function granularity level.
function f(x) {\n 'use strict';\n var a = 12;\n b = a + x * 35; // error!\n}\nf(42);\n This used to change a value on the global object which is rarely the expected effect. If you really want to set a value to the global object, pass it as an argument and explicitly assign it as a property:
var global = this; // in the top-level context, \"this\" always\n // refers to the global object\nfunction f(x) {\n 'use strict';\n var a = 12;\n global.b = a + x * 35;\n}\nf(42);\n 'use strict';\ndelete Object.prototype; // error!\n
In non-strict, this would silently fail, in contradiction with the user expectation.
Accessing arguments.callee, arguments.caller, anyFunction.caller, or anyFunction.arguments throws an error in strict mode. The only legitimate use case would be to reuse a function as in:
// example taken from vanillajs: http://vanilla-js.com/\nvar s = document.getElementById('thing').style;\ns.opacity = 1;\n(function() { \n if ((s.opacity-=.1) < 0)\n s.display = 'none';\n else\n setTimeout(arguments.callee, 40);\n})(); which can be rewritten as:
'use strict';\nvar s = document.getElementById('thing').style;\ns.opacity = 1;\n(function fadeOut() { // name the function\n if((s.opacity-=.1) < 0)\n s.display = 'none';\n else\n setTimeout(fadeOut, 40); // use the name of the function\n})(); These differences are very subtle differences. It's possible that a test suite doesn't catch this kind of subtle difference. Careful review of your code base will probably be necessary to be sure these differences don't affect the semantics of your code. Fortunately, this careful review can be done gradually down the function granularity.
this in function callsIn function calls like f(), the this value was the global object. In strict mode, it is now undefined. When a function was called with call or apply, if the value was a primitive value, this one was boxed into an object (or the global object for undefined and null). In strict mode, the value is passed directly without conversion or replacement.
arguments doesn't alias named function argumentsIn non-strict mode, modifying a value in the arguments object modifies the corresponding named argument. This made optimizations complicated for JavaScript engine and made code harder to read/understand. In strict mode, the arguments object is created and initialized with the same values than the named arguments, but changes to either the arguments object or the named arguments aren't reflected in one another.
eval\nIn strict mode code, eval doesn't create a new variable in the scope from which it was called. Also, of course, in strict mode, the string is evaluated with strict mode rules. Thorough testing will need to be performed to make sure nothing breaks. Not using eval if you don't really need it may be another pragmatic solution.
A potential \"downside\" of moving strict code to strict mode is that the semantics may be different in legacy browsers which do not implement strict mode. In some rare occasions (like bad concatenation or minification), your code also may not run in the mode you wrote and tested it in. Here are the rules to make your code strictness-neutral:
eval: use it only if you know what you're doingarguments: always access function arguments via their name or perform a copy of the arguments object using:var args = Array.prototype.slice.call(arguments)this: only use this when it refers to an object you created.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode/Transitioning_to_strict_mode\n
The WebAssembly.Table() constructor creates a new Table object of the given size and element type.
This is a JavaScript wrapper object — an array-like structure representing a WebAssembly Table, which stores function references. A table created by JavaScript or in WebAssembly code will be accessible and mutable from both JavaScript and WebAssembly.
Note: Tables can currently only store function references, but this will likely be expanded in the future.
var myTable = new WebAssembly.Table(tableDescriptor);
\"anyfunc\" (functions).tableDescriptor is not of type object, a TypeError is thrown.maximum is specified and is smaller than initial, a RangeError is thrown.Table instancesAll Table instances inherit from the Table() constructor's prototype object — this can be modified to affect all Table instances.
Table.prototype.constructorWebAssembly.Table() constructor.Table.prototype.lengthTable.prototype.get()Table.prototype.grow()Table.prototype.set()The following example (see table2.html source code and live version) creates a new WebAssembly Table instance with an initial size of 2 elements. We then print out the table length and contents of the two indexes (retrieved via Table.prototype.get() to show that the length is two and both elements are null.
var tbl = new WebAssembly.Table({initial:2, element:\"anyfunc\"});\nconsole.log(tbl.length); // \"2\"\nconsole.log(tbl.get(0)); // \"null\"\nconsole.log(tbl.get(1)); // \"null\" We then create an import object that contains the table:
var importObj = {\n js: {\n tbl:tbl\n }\n}; Finally, we load and instantiate a wasm module (table2.wasm) using the WebAssembly.instantiateStreaming() method. The table2.wasm module contains two functions (one that returns 42 and another that returns 83) and stores both into elements 0 and 1 of the imported table (see text representation). So after instantiation, the table still has length 2, but the elements now contain callable Exported WebAssembly Functions which we can call from JS.
WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)\n.then(function(obj) {\n console.log(tbl.length);\n console.log(tbl.get(0)());\n console.log(tbl.get(1)());\n}); Note how you've got to include a second function invocation operator at the end of the accessor to actually invoke the referenced function and log the value stored inside it (e.g. get(0)() rather than get(0)) .
This example shows that we're creating and accessing the table from JavaScript, but the same table is visible and callable inside the wasm instance too.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'Table' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
get | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
grow | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
length | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
prototype | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
set | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
get | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
grow | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
length | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
prototype | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
set | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
get | \n8.0.0 | \n
grow | \n8.0.0 | \n
length | \n8.0.0 | \n
prototype | \n8.0.0 | \n
set | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table\n
The bind() method creates a new function that, when called, has its this keyword set to the provided value, with a given sequence of arguments preceding any provided when the new function is called.
function.bind(thisArg[, arg1[, arg2[, ...]]])
thisArgthis parameter to the target function when the bound function is called. The value is ignored if the bound function is constructed using the new operator. When using bind to create a function(supplied as a callback) inside a setTimeout, any primitive value passed as thisArg is converted to object. If no arguments are provided to bind, the this of the executing scope is treated as the thisArg for the new function.arg1, arg2, ...A copy of the given function with the specified this value and initial arguments.
The bind() function creates a new bound function (BF). A BF is an exotic function object (a term from ECMAScript 2015) that wraps the original function object. Calling a BF generally results in the execution of its wrapped function.
A BF has the following internal properties:
When bound function is called, it calls internal method [[Call]] on [[BoundTargetFunction]], with following arguments Call(boundThis, args). Where, boundThis is [[BoundThis]], args is [[BoundArguments]] followed by the arguments passed by the function call.
A bound function may also be constructed using the new operator: doing so acts as though the target function had instead been constructed. The provided this value is ignored, while prepended arguments are provided to the emulated function.
The simplest use of bind() is to make a function that, no matter how it is called, is called with a particular this value. A common mistake for new JavaScript programmers is to extract a method from an object, then to later call that function and expect it to use the original object as its this (e.g. by using that method in callback-based code). Without special care, however, the original object is usually lost. Creating a bound function from the function, using the original object, neatly solves this problem:
this.x = 9; // this refers to global \"window\" object here in the browser\nvar module = {\n x: 81,\n getX: function() { return this.x; }\n};\n\nmodule.getX(); // 81\n\nvar retrieveX = module.getX;\nretrieveX(); \n// returns 9 - The function gets invoked at the global scope\n\n// Create a new function with 'this' bound to module\n// New programmers might confuse the\n// global var x with module's property x\nvar boundGetX = retrieveX.bind(module);\nboundGetX(); // 81\n The next simplest use of bind() is to make a function with pre-specified initial arguments. These arguments (if any) follow the provided this value and are then inserted at the start of the arguments passed to the target function, followed by the arguments passed to the bound function, whenever the bound function is called.
function list() {\n return Array.prototype.slice.call(arguments);\n}\n\nfunction addArguments(arg1, arg2) {\n return arg1 + arg2\n}\n\nvar list1 = list(1, 2, 3); // [1, 2, 3]\n\nvar result1 = addArguments(1, 2); // 3\n\n// Create a function with a preset leading argument\nvar leadingThirtysevenList = list.bind(null, 37);\n\n// Create a function with a preset first argument.\nvar addThirtySeven = addArguments.bind(null, 37); \n\nvar list2 = leadingThirtysevenList(); \n// [37]\n\nvar list3 = leadingThirtysevenList(1, 2, 3); \n// [37, 1, 2, 3]\n\nvar result2 = addThirtySeven(5); \n// 37 + 5 = 42 \n\nvar result3 = addThirtySeven(5, 10);\n// 37 + 5 = 42 , second argument is ignored\n\n setTimeout\nBy default within window.setTimeout(), the this keyword will be set to the window (or global) object. When working with class methods that require this to refer to class instances, you may explicitly bind this to the callback function, in order to maintain the instance.
function LateBloomer() {\n this.petalCount = Math.floor(Math.random() * 12) + 1;\n}\n\n// Declare bloom after a delay of 1 second\nLateBloomer.prototype.bloom = function() {\n window.setTimeout(this.declare.bind(this), 1000);\n};\n\nLateBloomer.prototype.declare = function() {\n console.log('I am a beautiful flower with ' +\n this.petalCount + ' petals!');\n};\n\nvar flower = new LateBloomer();\nflower.bloom(); \n// after 1 second, triggers the 'declare' method Warning: This section demonstrates JavaScript capabilities and documents some edge cases of the bind() method. The methods shown below are not the best way to do things and probably should not be used in any production environment.
Bound functions are automatically suitable for use with the new operator to construct new instances created by the target function. When a bound function is used to construct a value, the provided this is ignored. However, provided arguments are still prepended to the constructor call:
function Point(x, y) {\n this.x = x;\n this.y = y;\n}\n\nPoint.prototype.toString = function() { \n return this.x + ',' + this.y; \n};\n\nvar p = new Point(1, 2);\np.toString(); // '1,2'\n\n// not supported in the polyfill below,\n\n// works fine with native bind:\n\nvar YAxisPoint = Point.bind(null, 0/*x*/);\n\n\nvar emptyObj = {};\nvar YAxisPoint = Point.bind(emptyObj, 0/*x*/);\n\nvar axisPoint = new YAxisPoint(5);\naxisPoint.toString(); // '0,5'\n\naxisPoint instanceof Point; // true\naxisPoint instanceof YAxisPoint; // true\nnew Point(17, 42) instanceof YAxisPoint; // true\n Note that you need do nothing special to create a bound function for use with new. The corollary is that you need do nothing special to create a bound function to be called plainly, even if you would rather require the bound function to only be called using new.
// Example can be run directly in your JavaScript console\n// ...continuing from above\n\n// Can still be called as a normal function \n// (although usually this is undesired)\nYAxisPoint(13);\n\nemptyObj.x + ',' + emptyObj.y;\n// > '0,13'\n
If you wish to support the use of a bound function only using new, or only by calling it, the target function must enforce that restriction.
bind() is also helpful in cases where you want to create a shortcut to a function which requires a specific this value.
Take Array.prototype.slice, for example, which you want to use for converting an array-like object to a real array. You could create a shortcut like this:
var slice = Array.prototype.slice;\n\n// ...\n\nslice.apply(arguments);\n
With bind(), this can be simplified. In the following piece of code, slice is a bound function to the apply() function of Function.prototype, with the this value set to the slice() function of Array.prototype. This means that additional apply() calls can be eliminated:
// same as \"slice\" in the previous example\nvar unboundSlice = Array.prototype.slice;\nvar slice = Function.prototype.apply.bind(unboundSlice);\n\n// ...\n\nslice(arguments);\n
You can partially work around this by inserting the following code at the beginning of your scripts, allowing use of much of the functionality of bind() in implementations that do not natively support it.
if (!Function.prototype.bind) {\n Function.prototype.bind = function(oThis) {\n if (typeof this !== 'function') {\n // closest thing possible to the ECMAScript 5\n // internal IsCallable function\n throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');\n }\n\n var aArgs = Array.prototype.slice.call(arguments, 1),\n fToBind = this,\n fNOP = function() {},\n fBound = function() {\n return fToBind.apply(this instanceof fNOP\n ? this\n : oThis,\n aArgs.concat(Array.prototype.slice.call(arguments)));\n };\n\n if (this.prototype) {\n // Function.prototype doesn't have a prototype property\n fNOP.prototype = this.prototype; \n }\n fBound.prototype = new fNOP();\n\n return fBound;\n };\n}\n Some of the many differences (there may well be others, as this list does not seriously attempt to be exhaustive) between this algorithm and the specified algorithm are:
Array.prototype.slice(), Array.prototype.concat(), Function.prototype.call() and Function.prototype.apply(), built-in methods to have their original values.caller and arguments properties that throw a TypeError upon get, set, or deletion. (This could be added if the implementation supports Object.defineProperty, or partially implemented [without throw-on-delete behavior] if the implementation supports the __defineGetter__ and __defineSetter__ extensions.)prototype property. (Proper bound functions have none.)length property does not agree with that mandated by ECMA-262: it creates functions with length 0, while a full implementation, depending on the length of the target function and the number of pre-specified arguments, may return a non-zero length.If you choose to use this partial implementation, you must not rely on those cases where behavior deviates from ECMA-262, 5th edition! With some care, however (and perhaps with additional modification to suit specific needs), this partial implementation may be a reasonable bridge to the time when bind() is widely implemented according to the specification.
Please check https://github.com/Raynos/function-bind for a more thorough solution!
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Function.prototype.bind' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function.prototype.bind' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function.prototype.bind' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n9 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \n18 | \nYes | \n4 | \n11.5 | \n6 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind\n
Template literals are string literals allowing embedded expressions. You can use multi-line strings and string interpolation features with them. They were called \"template strings\" in prior editions of the ES2015 specification.
`string text`\n\n`string text line 1\n string text line 2`\n\n`string text ${expression} string text`\n\ntag `string text ${expression} string text`\n Template literals are enclosed by the back-tick (` `) (grave accent) character instead of double or single quotes. Template literals can contain placeholders. These are indicated by the dollar sign and curly braces (${expression}). The expressions in the placeholders and the text between them get passed to a function. The default function just concatenates the parts into a single string. If there is an expression preceding the template literal (tag here), this is called a \"tagged template\". In that case, the tag expression (usually a function) gets called with the processed template literal, which you can then manipulate before outputting. To escape a back-tick in a template literal, put a backslash \\ before the back-tick.
`\\`` === '`' // --> true
Any newline characters inserted in the source are part of the template literal. Using normal strings, you would have to use the following syntax in order to get multi-line strings:
console.log('string text line 1\\n' +\n'string text line 2');\n// \"string text line 1\n// string text line 2\" To get the same effect using template literals, you can now write:
console.log(`string text line 1\nstring text line 2`);\n// \"string text line 1\n// string text line 2\"
In order to embed expressions within normal strings, you would use the following syntax:
var a = 5;\nvar b = 10;\nconsole.log('Fifteen is ' + (a + b) + ' and\\nnot ' + (2 * a + b) + '.');\n// \"Fifteen is 15 and\n// not 20.\" Now, with template literals, you are able to make use of the syntactic sugar making substitutions like this more readable:
var a = 5;\nvar b = 10;\nconsole.log(`Fifteen is ${a + b} and\nnot ${2 * a + b}.`);\n// \"Fifteen is 15 and\n// not 20.\" In certain times, nesting a template is the easiest and perhaps more readable way to have configurable strings. Within a backticked template it is simple to allow inner backticks simply by using them inside a placeholder ${ } within the template. For instance, if condition a is true: then return this templated literal.
In ES5:
var classes = 'header'\nclasses += (isLargeScreen() ?\n '' : item.isCollapsed ?\n ' icon-expander' : ' icon-collapser');\n
In ES2015 with template literals and without nesting:
const classes = `header ${ isLargeScreen() ? '' :\n (item.isCollapsed ? 'icon-expander' : 'icon-collapser') }`; In ES2015 with nested template literals:
const classes = `header ${ isLargeScreen() ? '' :\n `icon-${item.isCollapsed ? 'expander' : 'collapser'}`}`; A more advanced form of template literals are tagged templates. Tags allow you to parse template literals with a function. The first argument of a tag function contains an array of string values. The remaining arguments are related to the expressions. In the end, your function can return your manipulated string (or it can return something completely different as described in the next example). The name of the function used for the tag can be whatever you want.
var person = 'Mike';\nvar age = 28;\n\nfunction myTag(strings, personExp, ageExp) {\n var str0 = strings[0]; // \"That \"\n var str1 = strings[1]; // \" is a \"\n\n // There is technically a string after\n // the final expression (in our example),\n // but it is empty (\"\"), so disregard.\n // var str2 = strings[2];\n\n var ageStr;\n if (ageExp > 99){\n ageStr = 'centenarian';\n } else {\n ageStr = 'youngster';\n }\n\n // We can even return a string built using a template literal\n return `${str0}${personExp}${str1}${ageStr}`;\n}\n\nvar output = myTag`That ${ person } is a ${ age }`;\n\nconsole.log(output);\n// That Mike is a youngster Tag functions don't need to return a string, as shown in the following example.
function template(strings, ...keys) {\n return (function(...values) {\n var dict = values[values.length - 1] || {};\n var result = [strings[0]];\n keys.forEach(function(key, i) {\n var value = Number.isInteger(key) ? values[key] : dict[key];\n result.push(value, strings[i + 1]);\n });\n return result.join('');\n });\n}\n\nvar t1Closure = template`${0}${1}${0}!`;\nt1Closure('Y', 'A'); // \"YAY!\"\nvar t2Closure = template`${0} ${'foo'}!`;\nt2Closure('Hello', {foo: 'World'}); // \"Hello World!\"\n The special raw property, available on the first function argument of tagged templates, allows you to access the raw strings as they were entered, without processing escape sequences.
function tag(strings) {\n console.log(strings.raw[0]);\n}\n\ntag`string text line 1 \\n string text line 2`;\n// logs \"string text line 1 \\n string text line 2\" ,\n// including the two characters '\\' and 'n'\n In addition, the String.raw() method exists to create raw strings just like the default template function and string concatenation would create.
var str = String.raw`Hi\\n${2+3}!`;\n// \"Hi\\n5!\"\n\nstr.length;\n// 6\n\nstr.split('').join(',');\n// \"H,i,\\,n,5,!\"\n As of ECMAScript 2016, tagged templates conform to the rules of the following escape sequences:
\\u00A9\n\\u{2F804}\n\\xA9\n\\251\nThis means that a tagged template like the following is problematic, because, per ECMAScript grammar, a parser looks for valid Unicode escape sequences, but finds malformed syntax:
latex`\\unicode`\n// Throws in older ECMAScript versions (ES2016 and earlier)\n// SyntaxError: malformed Unicode character escape sequence
Tagged templates should allow the embedding of languages (for example DSLs, or LaTeX), where other escapes sequences are common. The ECMAScript proposal Template Literal Revision (stage 4, to be integrated in the ECMAScript 2018 standard) removes the syntax restriction of ECMAScript escape sequences from tagged templates.
However, illegal escape sequences must still be represented in the “cooked” representation. They will show up as undefined element in the “cooked” array:
function latex(str) { \n return { \"cooked\": str[0], \"raw\": str.raw[0] }\n} \n\nlatex`\\unicode`\n\n// { cooked: undefined, raw: \"\\\\unicode\" } Note that the escape sequence restriction is only dropped from tagged templates and not from untagged template literals:
let bad = `bad escape sequence: \\unicode`;
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Template Literals' in that specification. | Standard | Initial definition. Defined in several section of the specification: Template Literals, Tagged Templates\n |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Template Literals' in that specification. | Draft | Defined in several section of the specification: Template Literals, Tagged Templates\n |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n41 | \n12 | \n34 | \nNo | \n28 | \n9 | \n
| Escape sequences allowed in tagged template literals \n | \n62 | \nNo | \n53 | \nNo | \n49 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n41 | \n41 | \n12 | \n34 | \n28 | \n? | \n4.0 | \n
| Escape sequences allowed in tagged template literals \n | \n62 | \n62 | \nNo | \n53 | \n49 | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
| Escape sequences allowed in tagged template literals \n | \nNo | \n
StringString.raw()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals\n
The toString() method returns a string representing the source code of the function.
function.toString()
A string representing the source code of the function.
The Function object overrides the toString method inherited from Object; it does not inherit Object.prototype.toString. For user-defined Function objects, the toString method returns a string containing the source text segment which was used to define the function.
JavaScript calls the toString method automatically when a Function is to be represented as a text value, e.g. when a function is concatenated with a string.
The toString() method will throw a TypeError exception (\"Function.prototype.toString called on incompatible object\"), if its this value object is not a Function object. It will also throw for Proxy objects, for example.
Function.prototype.toString.call('foo'); // TypeError\n\nvar proxy = new Proxy(function() {}, {});\nFunction.prototype.toString.call(proxy); // TypeError\n If the toString() method is called on built-in function objects or a function created by Function.prototype.bind, toString() returns a native function string which looks like
\"function () {\\n [native code]\\n}\"\n If the toString() method is called on a function created by the Function constructor, toString() returns the source code of a synthesized function declaration named \"anonymous\" using the provided parameters and function body.
| Function | Function.prototype.toString result |
|---|---|
\nfunction f(){} | \n\"function f(){}\" |
\nclass A { a(){} } | \n\"class A { a(){} }\" |
\nfunction* g(){} | \n\"function* g(){}\" |
\na => a | \n\"a => a\" |
\n({ a(){} }.a) | \n\"a(){}\" |
\n({ *a(){} }.a) | \n\"*a(){}\" |
\n({ [0](){} }[0]) | \n\"[0](){}\" |
\nObject.getOwnPropertyDescriptor({\n get a(){}\n}, \"a\").get | \n\"get a(){}\" |
\nObject.getOwnPropertyDescriptor({\n set a(x){}\n}, \"a\").set | \n\"set a(x){}\" |
\nFunction.prototype.toString | \n\"function toString() { [native code] }\" |
\n(function f(){}.bind(0)) | \n\"function () { [native code] }\" |
\nFunction(\"a\", \"b\") | \n\"function anonymous(a\\n) {\\nb\\n}\" |
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function.prototype.toString' in that specification. | Standard | Added more specific requirements for the string representation. |
Function.prototype.toString revisions proposal | Draft | Standardizes native function string, line endings. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n5 | \nYes | \nYes | \n
| Support of toString revision\n | \nNo | \nNo | \n54 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Support of toString revision\n | \nNo | \nNo | \nNo | \n54 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Support of toString revision\n | \nNo | \n
Function.prototype.toString() has been implemented by saving the function's source. The decompiler was removed, so that the indentation parameter is not needed any more. See bug 761723 for more details.Function.prototype.toString() throws for Proxy objects (bug 1100936).\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString\n
This feature is deprecated in favor of defining setters using the object initializer syntax or the Object.defineProperty() API.
However, as it is widely implemented and used on the Web, it is very unlikely that browsers will stop implementing it.
The __defineSetter__ method binds an object's property to a function to be called when an attempt is made to set that property.
obj.__defineSetter__(prop, fun)
propfunfunction(val) { . . . } valprop.The __defineSetter__ method allows a setter to be defined on a pre-existing object.
// Non-standard and deprecated way\n\nvar o = {};\no.__defineSetter__('value', function(val) { this.anotherValue = val; });\no.value = 5;\nconsole.log(o.value); // undefined\nconsole.log(o.anotherValue); // 5\n\n\n// Standard-compliant ways\n\n// Using the set operator\nvar o = { set value(val) { this.anotherValue = val; } };\no.value = 5;\nconsole.log(o.value); // undefined\nconsole.log(o.anotherValue); // 5\n\n// Using Object.defineProperty\nvar o = {};\nObject.defineProperty(o, 'value', {\n set: function(val) {\n this.anotherValue = val;\n }\n});\no.value = 5;\nconsole.log(o.value); // undefined\nconsole.log(o.anotherValue); // 5\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.prototype.__defineSetter__()' in that specification. | Draft | Included in the (normative) annex for additional ECMAScript legacy features for Web browsers (note that the specification codifies what is already in implementations). |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n 1\n
| \n11 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
Object.prototype.__defineGetter__()set operatorObject.defineProperty()Object.prototype.__lookupGetter__()Object.prototype.__lookupSetter__()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/__defineSetter__\n
This feature is deprecated in favor of defining getters using the object initializer syntax or the Object.defineProperty() API. While this feature is widely implemented, it is only described in the ECMAScript specification because of legacy usage. This method should not be used since better alternatives exist.
The __defineGetter__ method binds an object's property to a function to be called when that property is looked up.
obj.__defineGetter__(prop, func)
propfuncThe __defineGetter__ allows a getter to be defined on a pre-existing object.
// Non-standard and deprecated way\n\nvar o = {};\no.__defineGetter__('gimmeFive', function() { return 5; });\nconsole.log(o.gimmeFive); // 5\n\n\n// Standard-compliant ways\n\n// Using the get operator\nvar o = { get gimmeFive() { return 5; } };\nconsole.log(o.gimmeFive); // 5\n\n// Using Object.defineProperty\nvar o = {};\nObject.defineProperty(o, 'gimmeFive', {\n get: function() {\n return 5;\n }\n});\nconsole.log(o.gimmeFive); // 5\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.prototype.__defineGetter__()' in that specification. | Draft | Included in the (normative) annex for additional ECMAScript legacy features for Web browsers (note that the specification codifies what is already in implementations). |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n 1\n
| \n11 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
Object.prototype.__defineSetter__()get operatorObject.defineProperty()Object.prototype.__lookupGetter__()Object.prototype.__lookupSetter__()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__\n
Warning: -file- is being assigned a //# sourceMappingURL, but already has one.
A warning. JavaScript execution won't be halted.
A source map has been specified more than once for a given JavaScript source.
JavaScript sources are often combined and minified to make delivering them from the server more efficient. With source maps, the debugger can map the code being executed to the original source files. There are two ways to assign a source map, either by using a comment or by setting a header to the JavaScript file.
Setting a source map by using a comment in the file:
//# sourceMappingURL=http://example.com/path/to/your/sourcemap.map
Or, alternatively, you can set a header to your JavaScript file:
X-SourceMap: /path/to/file.js.map
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Already_has_pragma\n
A couple of additions to ECMAScript 2015 aren't new built-ins or syntax, but protocols. These protocols can be implemented by any object respecting some conventions.
There are two protocols: The iterable protocol and the iterator protocol.
The iterable protocol allows JavaScript objects to define or customize their iteration behavior, such as what values are looped over in a for..of construct. Some built-in types are built-in iterables with a default iteration behavior, such as Array or Map, while other types (such as Object) are not.
In order to be iterable, an object must implement the @@iterator method, meaning that the object (or one of the objects up its prototype chain) must have a property with a @@iterator key which is available via constant Symbol.iterator
| Property | Value |
|---|---|
[Symbol.iterator] | A zero arguments function that returns an object, conforming to the iterator protocol. |
Whenever an object needs to be iterated (such as at the beginning of a for..of loop), its @@iterator method is called with no arguments, and the returned iterator is used to obtain the values to be iterated.
The iterator protocol defines a standard way to produce a sequence of values (either finite or infinite), and potentially a return value when all values have been generated.
An object is an iterator when it implements a next() method with the following semantics:
| Property | Value |
|---|---|
next | A zero arguments function that returns an object with at least the following two properties:
The |
It is not possible to know reflectively whether a particular object implements the iterator protocol, however it is easy to create an object that satisfies both the iterator and iterable protocols (as shown in the example below). Doing so allows an iterator to be consumed by the various syntaxes expecting iterables. Thus it is rarely desireable to implement the iterator protocol without also implementing iterable.
var myIterator = {\n next: function() {\n // ...\n },\n [Symbol.iterator]: function() { return this }\n};\n A String is an example of a built-in iterable object:
var someString = 'hi';\ntypeof someString[Symbol.iterator]; // \"function\"\n
String's default iterator returns the string's code points one by one:
var iterator = someString[Symbol.iterator]();\niterator + ''; // \"[object String Iterator]\"\n \niterator.next(); // { value: \"h\", done: false }\niterator.next(); // { value: \"i\", done: false }\niterator.next(); // { value: undefined, done: true } Some built-in constructs, such as the spread syntax, use the same iteration protocol under the hood:
[...someString] // [\"h\", \"i\"]
We can redefine the iteration behavior by supplying our own @@iterator:
var someString = new String('hi'); // need to construct a String object explicitly to avoid auto-boxing\n\nsomeString[Symbol.iterator] = function() {\n return { // this is the iterator object, returning a single element, the string \"bye\"\n next: function() {\n if (this._first) {\n this._first = false;\n return { value: 'bye', done: false };\n } else {\n return { done: true };\n }\n },\n _first: true\n };\n};\n Notice how redefining @@iterator affects the behavior of built-in constructs that use the iteration protocol:
[...someString]; // [\"bye\"]\nsomeString + ''; // \"hi\"\n
String, Array, TypedArray, Map and Set are all built-in iterables, because each of their prototype objects implements an @@iterator method.
We can make our own iterables like this:
var myIterable = {};\nmyIterable[Symbol.iterator] = function* () {\n yield 1;\n yield 2;\n yield 3;\n};\n[...myIterable]; // [1, 2, 3]\n There are many APIs that accept iterables, for example: Map([iterable]), WeakMap([iterable]), Set([iterable]) and WeakSet([iterable]):
var myObj = {};\nnew Map([[1, 'a'], [2, 'b'], [3, 'c']]).get(2); // \"b\"\nnew WeakMap([[{}, 'a'], [myObj, 'b'], [{}, 'c']]).get(myObj); // \"b\"\nnew Set([1, 2, 3]).has(3); // true\nnew Set('123').has('2'); // true\nnew WeakSet(function* () {\n yield {};\n yield myObj;\n yield {};\n}()).has(myObj); // true\n Also see Promise.all(iterable), Promise.race(iterable), and Array.from().
Some statements and expressions expect iterables, for example the for-of loops, spread syntax, yield*, and destructuring assignment:
for(let value of ['a', 'b', 'c']){\n console.log(value);\n}\n// \"a\"\n// \"b\"\n// \"c\"\n\n[...'abc']; // [\"a\", \"b\", \"c\"]\n\nfunction* gen() {\n yield* ['a', 'b', 'c'];\n}\n\ngen().next(); // { value:\"a\", done:false }\n\n[a, b, c] = new Set(['a', 'b', 'c']);\na // \"a\"\n\n If an iterable's @@iterator method doesn't return an iterator object, then it's a non-well-formed iterable. Using it as such is likely to result in runtime exceptions or buggy behavior:
var nonWellFormedIterable = {}\nnonWellFormedIterable[Symbol.iterator] = () => 1\n[...nonWellFormedIterable] // TypeError: [] is not a function\n function makeIterator(array) {\n var nextIndex = 0;\n \n return {\n next: function() {\n return nextIndex < array.length ?\n {value: array[nextIndex++], done: false} :\n {done: true};\n }\n };\n}\n\nvar it = makeIterator(['yo', 'ya']);\n\nconsole.log(it.next().value); // 'yo'\nconsole.log(it.next().value); // 'ya'\nconsole.log(it.next().done); // true\n function idMaker() {\n var index = 0;\n \n return {\n next: function(){\n return {value: index++, done: false};\n }\n };\n}\n\nvar it = idMaker();\n\nconsole.log(it.next().value); // '0'\nconsole.log(it.next().value); // '1'\nconsole.log(it.next().value); // '2'\n// ...\n function* makeSimpleGenerator(array) {\n var nextIndex = 0;\n \n while (nextIndex < array.length) {\n yield array[nextIndex++];\n }\n}\n\nvar gen = makeSimpleGenerator(['yo', 'ya']);\n\nconsole.log(gen.next().value); // 'yo'\nconsole.log(gen.next().value); // 'ya'\nconsole.log(gen.next().done); // true\n\n\n\nfunction* idMaker() {\n var index = 0;\n while (true)\n yield index++;\n}\n\nvar gen = idMaker();\n\nconsole.log(gen.next().value); // '0'\nconsole.log(gen.next().value); // '1'\nconsole.log(gen.next().value); // '2'\n// ...\n class SimpleClass {\n constructor(data) {\n this.index = 0;\n this.data = data;\n }\n\n [Symbol.iterator]() {\n return {\n next: () => {\n if (this.index < this.data.length) {\n return {value: this.data[this.index++], done: false};\n } else {\n this.index = 0; //If we would like to iterate over this again without forcing manual update of the index\n return {done: true};\n }\n }\n };\n }\n}\n\nconst simple = new SimpleClass([1,2,3,4,5]);\n\nfor (const val of simple) {\n console.log(val); //'0' '1' '2' '3' '4' '5' \n}\n A generator object is both, iterator and iterable:
var aGeneratorObject = function* () {\n yield 1;\n yield 2;\n yield 3;\n}();\ntypeof aGeneratorObject.next;\n// \"function\", because it has a next method, so it's an iterator\ntypeof aGeneratorObject[Symbol.iterator];\n// \"function\", because it has an @@iterator method, so it's an iterable\naGeneratorObject[Symbol.iterator]() === aGeneratorObject;\n// true, because its @@iterator method returns itself (an iterator), so it's an well-formed iterable\n[...aGeneratorObject];\n// [1, 2, 3]\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Iteration' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Iteration' in that specification. | Draft |
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols\n
A Function object's read-only name property indicates the function's name as specified when it was created, or \"anonymous\" for functions created anonymously.
Property attributes of Function.prototype.name\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
Note that in non-standard, pre-ES2015 implementations the configurable attribute was false as well.
The name property returns the name of a function statement.
function doSomething() {}\ndoSomething.name; // \"doSomething\"\n Functions created with the syntax new Function(...) or just Function(...) create Function objects and their name is \"anonymous\".
(new Function).name; // \"anonymous\"
Variables and methods can infer the name of an anonymous function from its syntactic position (new in ECMAScript 2015).
let f = function() {};\nlet object = {\n someMethod: function() {}\n};\n\nconsole.log(f.name); // \"f\"\nconsole.log(object.someMethod.name); // \"someMethod\"\n You can define a function with a name in a function expression:
let object = {\n someMethod: function object_someMethod() {}\n};\nconsole.log(object.someMethod.name); // logs \"object_someMethod\"\n\ntry { object_someMethod } catch(e) { console.log(e); }\n// ReferenceError: object_someMethod is not defined\n You cannot change the name of a function, this property is read-only:
let object = {\n // anonymous\n someMethod: function() {}\n};\n\nobject.someMethod.name = 'otherMethod';\nconsole.log(object.someMethod.name); // someMethod\n To change it, you could use Object.defineProperty() though.
var o = {\n foo(){}\n};\no.foo.name; // \"foo\"; Function.bind() produces a function whose name is \"bound \" plus the function name.
function foo() {}; \nfoo.bind({}).name; // \"bound foo\"\n When using get and set accessor properties, \"get\" or \"set\" will appear in the function name.
let o = { \n get foo(){}, \n set foo(x){} \n}; \n\nvar descriptor = Object.getOwnPropertyDescriptor(o, \"foo\"); \ndescriptor.get.name; // \"get foo\" \ndescriptor.set.name; // \"set foo\"; You can use obj.constructor.name to check the \"class\" of an object (but be sure to read the warnings below):
function Foo() {} // ES2015 Syntax: class Foo {}\n\nvar fooInstance = new Foo();\nconsole.log(fooInstance.constructor.name); // logs \"Foo\"\n Warning: The script interpreter will set the built-in Function.name property only if a function does not have an own property called name (see section 9.2.11 of the ECMAScript2015 Language Specification). However, ES2015 specifies the static keyword such that static methods will be set as OwnProperty of the class constructor function (ECMAScript2015, 14.5.14.21.b + 12.2.6.9).
Therefore we can't obtain the class name for virtually any class with a static method property name():
class Foo {\n constructor() {}\n static name() {}\n}\n With a static name() method Foo.name no longer holds the actual class name but a reference to the name() function object. Above class definition in ES2015 syntax will behave in Chrome or Firefox similar to the following snippet in ES5 syntax:
function Foo() {}\nObject.defineProperty(Foo, 'name', { writable: true });\nFoo.name = function() {};\n Trying to obtain the class of fooInstance via fooInstance.constructor.name won't give us the class name at all but a reference to the static class method. Example:
let fooInstance = new Foo();\nconsole.log(fooInstance.constructor.name); // logs function name()\n
You may also see from the ES5 syntax example that in Chrome or Firefox our static definition of Foo.name becomes writable. The built-in definition in the absence of a custom static definition is read-only:
Foo.name = 'Hello';\nconsole.log(Foo.name); // logs \"Hello\" if class Foo has a static name() property but \"Foo\" if not.\n
Therefore you may not rely on the built-in Function.name property to always hold a class's name.
If a Symbol is used a function name and the symbol has a description, the method's name is the description in square brackets.
let sym1 = Symbol(\"foo\"); \nlet sym2 = Symbol(); \nlet o = { \n [sym1]: function(){}, \n [sym2]: function(){} \n}; \n\no[sym1].name; // \"[foo]\"\no[sym2].name; // \"\" Warning: Be careful when using Function.name and source code transformations, such as those carried out by JavaScript compressors (minifiers) or obfuscators. These tools are often used as part of a JavaScript build pipeline to reduce the size of a program prior to deploying it to production. Such transformations often change a function's name at build-time.
Source code such as:
function Foo() {};\nlet foo = new Foo();\n\nif (foo.constructor.name === 'Foo') {\n console.log(\"'foo' is an instance of 'Foo'\");\n} else {\n console.log('Oops!');\n}\n may be compressed to:
function a() {};\nlet b = new a();\nif (b.constructor.name === 'Foo') {\n console.log(\"'foo' is an instance of 'Foo'\");\n} else {\n console.log('Oops!');\n}\n In the uncompressed version, the program runs into the truthy-branch and logs 'foo' is an instance of 'Foo'. Whereas, in the compressed version it behaves differently, and runs into the else-branch. If you rely on Function.name, like in the example above, make sure your build pipeline doesn't change function names, or don't assume a function to have a particular name.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'name' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'name' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n15 | \n14 | \n1 | \nNo | \nYes | \nYes | \n
| Configurable: true | \n43 | \n? | \n38 | \n? | \n? | \n? | \n
| Inferred names on anonymous functions | \n51 | \n? | \n53 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Configurable: true | \n? | \n43 | \n? | \n38 | \n? | \n? | \n4.0 | \n
| Inferred names on anonymous functions | \n? | \n51 | \n? | \n53 | \n? | \n? | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Configurable: true | \n? | \n
| Inferred names on anonymous functions | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name\n
The apply() method calls a function with a given this value, and arguments provided as an array (or an array-like object).
Note: While the syntax of this function is almost identical to that of call(), the fundamental difference is that call() accepts an argument list, while apply() accepts a single array of arguments.
function.apply(thisArg, [argsArray])
thisArgthis provided for the call to func. Note that this may not be the actual value seen by the method: if the method is a function in non-strict mode code, null and undefined will be replaced with the global object, and primitive values will be boxed.argsArrayfunc should be called, or null or undefined if no arguments should be provided to the function. Starting with ECMAScript 5 these arguments can be a generic array-like object instead of an array. See below for browser compatibility information.The result of calling the function with the specified this value and arguments.
You can assign a different this object when calling an existing function. this refers to the current object, the calling object. With apply, you can write a method once and then inherit it in another object, without having to rewrite the method for the new object.
apply is very similar to call(), except for the type of arguments it supports. You use an arguments array instead of a list of arguments (parameters). With apply, you can also use an array literal, for example, func.apply(this, ['eat', 'bananas']), or an Array object, for example, func.apply(this, new Array('eat', 'bananas')).
You can also use arguments for the argsArray parameter. arguments is a local variable of a function. It can be used for all unspecified arguments of the called object. Thus, you do not have to know the arguments of the called object when you use the apply method. You can use arguments to pass all the arguments to the called object. The called object is then responsible for handling the arguments.
Since ECMAScript 5th Edition you can also use any kind of object which is array-like, so in practice, this means it's going to have a property length and integer properties in the range (0..length-1). As an example you can now use a NodeList or a custom object like { 'length': 2, '0': 'eat', '1': 'bananas' }.
Most browsers, including Chrome 14 and Internet Explorer 9, still do not accept array-like objects and will throw an exception.
apply to append an array to anotherWe can use push to append an element to an array. And, because push accepts a variable number of arguments, we can also push multiple elements at once. But, if we pass an array to push, it will actually add that array as a single element, instead of adding the elements individually, so we end up with an array inside an array. What if that is not what we want? concat does have the behaviour we want in this case, but it does not actually append to the existing array but creates and returns a new array. But we wanted to append to our existing array... So what now? Write a loop? Surely not?
apply to the rescue!
var array = ['a', 'b'];\nvar elements = [0, 1, 2];\narray.push.apply(array, elements);\nconsole.info(array); // [\"a\", \"b\", 0, 1, 2]\n
apply and built-in functionsClever usage of apply allows you to use built-in functions for some tasks, that otherwise probably would have been written by looping over the array values. As an example here we are going to use Math.max/Math.min, to find out the maximum/minimum value in an array.
// min/max number in an array\nvar numbers = [5, 6, 2, 3, 7];\n\n// using Math.min/Math.max apply\nvar max = Math.max.apply(null, numbers); \n// This about equal to Math.max(numbers[0], ...)\n// or Math.max(5, 6, ...)\n\nvar min = Math.min.apply(null, numbers);\n\n// vs. simple loop based algorithm\nmax = -Infinity, min = +Infinity;\n\nfor (var i = 0; i < numbers.length; i++) {\n if (numbers[i] > max) {\n max = numbers[i];\n }\n if (numbers[i] < min) {\n min = numbers[i];\n }\n}\n But beware: in using apply this way, you run the risk of exceeding the JavaScript engine's argument length limit. The consequences of applying a function with too many arguments (think more than tens of thousands of arguments) vary across engines (JavaScriptCore has hard-coded argument limit of 65536), because the limit (indeed even the nature of any excessively-large-stack behavior) is unspecified. Some engines will throw an exception. More perniciously, others will arbitrarily limit the number of arguments actually passed to the applied function. To illustrate this latter case: if such an engine had a limit of four arguments (actual limits are of course significantly higher), it would be as if the arguments 5, 6, 2, 3 had been passed to apply in the examples above, rather than the full array.
If your value array might grow into the tens of thousands, use a hybrid strategy: apply your function to chunks of the array at a time:
function minOfArray(arr) {\n var min = Infinity;\n var QUANTUM = 32768;\n\n for (var i = 0, len = arr.length; i < len; i += QUANTUM) {\n var submin = Math.min.apply(null, \n arr.slice(i, Math.min(i+QUANTUM, len)));\n min = Math.min(submin, min);\n }\n\n return min;\n}\n\nvar min = minOfArray([5, 6, 2, 3, 7]);\n apply to chain constructorsYou can use apply to chain constructors for an object, similar to Java. In the following example we will create a global Function method called construct, which will enable you to use an array-like object with a constructor instead of an arguments list.
Function.prototype.construct = function(aArgs) {\n var oNew = Object.create(this.prototype);\n this.apply(oNew, aArgs);\n return oNew;\n};\n Note: The Object.create() method used above is relatively new. For alternative methods, please consider one of the following approaches:
Using Object.__proto__:
Function.prototype.construct = function (aArgs) {\n var oNew = {};\n oNew.__proto__ = this.prototype;\n this.apply(oNew, aArgs);\n return oNew;\n};\n Using closures:
Function.prototype.construct = function(aArgs) {\n var fConstructor = this, fNewConstr = function() { \n fConstructor.apply(this, aArgs); \n };\n fNewConstr.prototype = fConstructor.prototype;\n return new fNewConstr();\n}; Using the Function constructor:
Function.prototype.construct = function (aArgs) {\n var fNewConstr = new Function(\"\");\n fNewConstr.prototype = this.prototype;\n var oNew = new fNewConstr();\n this.apply(oNew, aArgs);\n return oNew;\n};\n Example usage:
function MyConstructor() {\n for (var nProp = 0; nProp < arguments.length; nProp++) {\n this['property' + nProp] = arguments[nProp];\n }\n}\n\nvar myArray = [4, 'Hello world!', false];\nvar myInstance = MyConstructor.construct(myArray);\n\nconsole.log(myInstance.property1); // logs 'Hello world!'\nconsole.log(myInstance instanceof MyConstructor); // logs 'true'\nconsole.log(myInstance.constructor); // logs 'MyConstructor'\n Note: This non-native Function.construct method will not work with some native constructors; like Date, for example. In these cases you have to use the Function.prototype.bind method. For example, imagine having an array like the following, to be used with Date constructor: [2012, 11, 4]; in this case you have to write something like: new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))(). This is not the best way to do things, and probably not to be used in any production environment.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Function.prototype.apply' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function.prototype.apply' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function.prototype.apply' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
ES 5.1: generic array-like object as arguments\n | \nYes | \n? | \n4 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
ES 5.1: generic array-like object as arguments\n | \n? | \nYes | \n? | \n4 | \n? | \n? | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
ES 5.1: generic array-like object as arguments\n | \n? | \n
arguments objectFunction.prototype.bind()Function.prototype.call()Reflect.apply()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
Warning: Changing the [[Prototype]] of an object is, by the nature of how modern JavaScript engines optimize property accesses, a very slow operation, in every browser and JavaScript engine. The effects on performance of altering inheritance are subtle and far-flung, and are not limited to simply the time spent in obj.__proto__ = ... statement, but may extend to any code that has access to any object whose [[Prototype]] has been altered. If you care about performance you should avoid setting the [[Prototype]] of an object. Instead, create a new object with the desired [[Prototype]] using Object.create().
Warning: While Object.prototype.__proto__ is supported today in most browsers, its existence and exact behavior has only been standardized in the ECMAScript 2015 specification as a legacy feature to ensure compatibility for web browsers. For better support, it is recommended that only Object.getPrototypeOf() be used instead.
The __proto__ property of Object.prototype is an accessor property (a getter function and a setter function) that exposes the internal [[Prototype]] (either an object or null) of the object through which it is accessed.
The use of __proto__ is controversial, and has been discouraged. It was never originally included in the EcmaScript language spec, but modern browsers decided to implement it anyway. Only recently, the __proto__ property has been standardized in the ECMAScript 2015 language specification for web browsers to ensure compatibility, so will be supported into the future. It is deprecated in favor of Object.getPrototypeOf/Reflect.getPrototypeOf and Object.setPrototypeOf/Reflect.setPrototypeOf (though still, setting the [[Prototype]] of an object is a slow operation that should be avoided if performance is a concern).
The __proto__ property can also be used in an object literal definition to set the object [[Prototype]] on creation, as an alternative to Object.create(). See: object initializer / literal syntax.
var Circle = function () {};\nvar shape = {};\nvar circle = new Circle();\n\n// Set the object prototype.\n// DEPRECATED. This is for example purposes only. DO NOT DO THIS in real code.\nshape.__proto__ = circle;\n\n// Get the object prototype\nconsole.log(shape.__proto__ === circle); // true\n var shape = function () {};\nvar p = {\n a: function () {\n console.log('aaa');\n }\n};\nshape.prototype.__proto__ = p;\n\nvar circle = new shape();\ncircle.a(); // aaa\nconsole.log(shape.prototype === circle.__proto__); // true\n\n// or\nvar shape = function () {};\nvar p = {\n a: function () {\n console.log('a');\n }\n};\n\nvar circle = new shape();\ncircle.__proto__ = p;\ncircle.a(); // a\nconsole.log(shape.prototype === circle.__proto__); // false\n\n// or\nfunction test() {};\ntest.prototype.myname = function () {\n console.log('myname');\n};\n\nvar a = new test();\nconsole.log(a.__proto__ === test.prototype); // true\na.myname(); // myname\n\n\n// or\nvar fn = function () {};\nfn.prototype.myname = function () {\n console.log('myname');\n};\n\nvar obj = {\n __proto__: fn.prototype\n};\n\nobj.myname(); // myname\n Note: that is two underscores, followed by the five characters \"proto\", followed by two more underscores.
The __proto__ getter function exposes the value of the internal [[Prototype]] of an object. For objects created using an object literal, this value is Object.prototype. For objects created using array literals, this value is Array.prototype. For functions, this value is Function.prototype. For objects created using new fun, where fun is one of the built-in constructor functions provided by JavaScript (Array, Boolean, Date, Number, Object, String, and so on — including new constructors added as JavaScript evolves), this value is always fun.prototype. For objects created using new fun, where fun is a function defined in a script, this value is the value of fun.prototype. (That is, if the constructor didn't return an other object explicitly, or the fun.prototype has been reassigned since the instance was created).
The __proto__ setter allows the [[Prototype]] of an object to be mutated. The object must be extensible according to Object.isExtensible(): if it is not, a TypeError is thrown. The value provided must be an object or null. Providing any other value will do nothing.
To understand how prototypes are used for inheritance, see guide article Inheritance and the prototype chain.
The __proto__ property is a simple accessor property on Object.prototype consisting of a getter and setter function. A property access for __proto__ that eventually consults Object.prototype will find this property, but an access that does not consult Object.prototype will not find it. If some other __proto__ property is found before Object.prototype is consulted, that property will hide the one found on Object.prototype.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.prototype.__proto__' in that specification. | Standard | Included in the (normative) annex for additional ECMAScript legacy features for Web browsers (note that the specification codifies what is already in implementations). |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.prototype.__proto__' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \n11 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
While the ECMAScript 2015 specification dictates that support for __proto__ is required only for web browsers (although being normative), other environments may support it as well for legacy usage.
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto\n
The propertyIsEnumerable() method returns a Boolean indicating whether the specified property is enumerable.
obj.propertyIsEnumerable(prop)
propA Boolean indicating whether the specified property is enumerable.
Every object has a propertyIsEnumerable method. This method can determine whether the specified property in an object can be enumerated by a for...in loop, with the exception of properties inherited through the prototype chain. If the object does not have the specified property, this method returns false.
propertyIsEnumerable\nThe following example shows the use of propertyIsEnumerable on objects and arrays:
var o = {};\nvar a = [];\no.prop = 'is enumerable';\na[0] = 'is enumerable';\n\no.propertyIsEnumerable('prop'); // returns true\na.propertyIsEnumerable(0); // returns true\n The following example demonstrates the enumerability of user-defined vs. built-in properties:
var a = ['is enumerable'];\n\na.propertyIsEnumerable(0); // returns true\na.propertyIsEnumerable('length'); // returns false\n\nMath.propertyIsEnumerable('random'); // returns false\nthis.propertyIsEnumerable('Math'); // returns false\n var a = [];\na.propertyIsEnumerable('constructor'); // returns false\n\nfunction firstConstructor() {\n this.property = 'is not enumerable';\n}\n\nfirstConstructor.prototype.firstMethod = function() {};\n\nfunction secondConstructor() {\n this.method = function method() { return 'is enumerable'; };\n}\n\nsecondConstructor.prototype = new firstConstructor;\nsecondConstructor.prototype.constructor = secondConstructor;\n\nvar o = new secondConstructor();\no.arbitraryProperty = 'is enumerable';\n\no.propertyIsEnumerable('arbitraryProperty'); // returns true\no.propertyIsEnumerable('method'); // returns true\no.propertyIsEnumerable('property'); // returns false\n\no.property = 'is enumerable';\n\no.propertyIsEnumerable('property'); // returns true\n\n// These return false as they are on the prototype which \n// propertyIsEnumerable does not consider (even though the last two\n// are iteratable with for-in)\no.propertyIsEnumerable('prototype'); // returns false (as of JS 1.8.1/FF3.6)\no.propertyIsEnumerable('constructor'); // returns false\no.propertyIsEnumerable('firstMethod'); // returns false\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable\n
The constructor property returns a reference to the Object constructor function that created the instance object. Note that the value of this property is a reference to the function itself, not a string containing the function's name. The value is only read-only for primitive values such as 1, true and \"test\".
All objects (with the exception of objects created with Object.create(null)) will have a constructor property. Objects created without the explicit use of a constructor function (i.e. the object and array literals) will have a constructor property that points to the Fundamental Object constructor type for that object.
var o = {};\no.constructor === Object; // true\n\nvar o = new Object;\no.constructor === Object; // true\n\nvar a = [];\na.constructor === Array; // true\n\nvar a = new Array;\na.constructor === Array; // true\n\nvar n = new Number(3);\nn.constructor === Number; // true\n The following example creates a prototype, Tree, and an object of that type, theTree. The example then displays the constructor property for the object theTree.
function Tree(name) {\n this.name = name;\n}\n\nvar theTree = new Tree('Redwood');\nconsole.log('theTree.constructor is ' + theTree.constructor);\n This example displays the following output:
theTree.constructor is function Tree(name) {\n this.name = name;\n}\n The following example shows how to modify constructor value of generic objects. Only true, 1 and \"test\" will not be affected as they have read-only native constructors. This example shows that it is not always safe to rely on the constructor property of an object.
function Type () {}\n\nvar types = [\n new Array(),\n [],\n new Boolean(),\n true, // remains unchanged\n new Date(),\n new Error(),\n new Function(),\n function () {},\n Math,\n new Number(),\n 1, // remains unchanged\n new Object(),\n {},\n new RegExp(),\n /(?:)/,\n new String(),\n 'test' // remains unchanged\n];\n\nfor (var i = 0; i < types.length; i++) {\n types[i].constructor = Type;\n types[i] = [types[i].constructor, types[i] instanceof Type, types[i].toString()];\n}\n\nconsole.log(types.join('\\n'));\n This example displays the following output (comments added for reference):
function Type() {},false, // new Array()\nfunction Type() {},false, // []\nfunction Type() {},false,false // new Boolean()\nfunction Boolean() {\n [native code]\n},false,true // true\nfunction Type() {},false,Mon Sep 01 2014 16:03:49 GMT+0600 // new Date()\nfunction Type() {},false,Error // new Error()\nfunction Type() {},false,function anonymous() {\n\n} // new Function()\nfunction Type() {},false,function () {} // function () {}\nfunction Type() {},false,[object Math] // Math\nfunction Type() {},false,0 // new Number()\nfunction Number() {\n [native code]\n},false,1 // 1\nfunction Type() {},false,[object Object] // new Object()\nfunction Type() {},false,[object Object] // {} \nfunction Type() {},false,/(?:)/ // new Regexp()\nfunction Type() {},false,/(?:)/ // /(?:)/ \nfunction Type() {},false, // new String()\nfunction String() {\n [native code]\n},false,test // 'test'\n Mostly this property is used for defining a function as a function-constructor with further calling it with new and prototype-inherits chain.
function Parent() {}\nParent.prototype.parentMethod = function parentMethod() {};\n\nfunction Child() {}\nChild.prototype = Object.create(Parent.prototype); // re-define child prototype to Parent prototype\n\nChild.prototype.constructor = Child; // return original constructor to Child But when do we need to perform last line here? Unfortunately the answer is - it depends.
Let's try to define the cases in which re-assignment of the original constructor will play a major role and when it will be one extra unused line of code.
Take the following case: the object has create method to create itself.
function Parent() {};\nfunction CreatedConstructor() {}\n\nCreatedConstructor.prototype = Object.create(Parent.prototype);\n\nCreatedConstructor.prototype.create = function create() {\n return new this.constructor();\n}\n\nnew CreatedConstructor().create().create(); // TypeError undefined is not a function since constructor === Parent In the example above the exception will be shown since constructor links to Parent.
To avoid this just assign necessary constructor which you are going to use.
function Parent() {}; \nfunction CreatedConstructor() {} \n\nCreatedConstructor.prototype = Object.create(Parent.prototype); \nCreatedConstructor.prototype.constructor = CreatedConstructor; // set right constructor for further using\n\nCreatedConstructor.prototype.create = function create() { \n return new this.constructor();\n} \n\nnew CreatedConstructor().create().create(); // it's pretty fine Ok, now it's pretty clear why changing of the constructor can be useful.
Let's consider one more case.
function ParentWithStatic() {}\n\nParentWithStatic.startPosition = { x: 0, y:0 };\nParentWithStatic.getStartPosition = function getStartPosition() {\n return this.startPosition;\n} \n\nfunction Child(x, y) {\n this.position = {\n x: x,\n y: y\n };\n}\n\nChild.prototype = Object.create(ParentWithStatic.prototype); \nChild.prototype.constructor = Child;\n\nChild.prototype.getOffsetByInitialPosition = function getOffsetByInitialPosition() {\n var position = this.position;\n var startPosition = this.constructor.getStartPosition(); // error undefined is not a function, since the constructor is Child\n\n return {\n offsetX: startPosition.x - position.x,\n offsetY: startPosition.y - position.y\n }\n}; For this example we need to stay parent constructor to continue to work properly.
Summary: manually updating or setting the constructor can lead to differrent and sometimes confusing consequences. To prevent this just define the role of constructor in each specific case. In most cases constructor is not used and reassignment of it is not necessary.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.prototype.constructor' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.prototype.constructor' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.prototype.constructor' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor\n
The Error.prototype property represents the prototype for the Error constructor.
Property attributes of Error.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All Error instances and instances of non-generic errors inherit from Error.prototype. As with all constructor functions, you can use the prototype of the constructor to add properties or methods to all instances created with that constructor.
Error.prototype.constructorError.prototype.messageError.prototype.name Non-standard
This feature is non-standard and is not on a standards track. Do not use it on production sites facing the Web: it will not work for every user. There may also be large incompatibilities between implementations and the behavior may change in the future.
Error.prototype.descriptionmessage.Error.prototype.numberError.prototype.fileNameError.prototype.lineNumberError.prototype.columnNumberError.prototype.stackError.prototype.toSource() \nError object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.Error.prototype.toString()Object.prototype.toString() method.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Error' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Error' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Error' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/prototype\n
The JavaScript reference serves as a repository of facts about the JavaScript language. The entire language is described here in detail. As you write JavaScript code, you'll refer to these pages often (thus the title \"JavaScript reference\"). If you're learning JavaScript, or need help understanding some of its capabilities or features, check out the JavaScript guide.
The JavaScript language is intended to be used within some larger environment, be it a browser, server-side scripts, or similar. For the most part, this reference attempts to be environment-agnostic and does not target a web browser environment.
JavaScript documentation of core language features (pure ECMAScript, for the most part) includes the following:
If you are new to JavaScript, start with the guide. Once you have a firm grasp of the fundamentals, you can use the reference to get more details on individual objects and language constructs.
In the JavaScript reference you can find the following chapters:
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/About\n
The isPrototypeOf() method checks if an object exists in another object's prototype chain.
isPrototypeOf() differs from the instanceof operator. In the expression \"object instanceof AFunction\", the object prototype chain is checked against AFunction.prototype, not against AFunction itself.
prototypeObj.isPrototypeOf(object)
objectA Boolean indicating whether the calling object lies in the prototype chain of the specified object.
The isPrototypeOf() method allows you to check whether or not an object exists within another object's prototype chain.
This example demonstrates that Baz.prototype, Bar.prototype, Foo.prototype and Object.prototype exist in the prototype chain for object baz:
function Foo() {}\nfunction Bar() {}\nfunction Baz() {}\n\nBar.prototype = Object.create(Foo.prototype);\nBaz.prototype = Object.create(Bar.prototype);\n\nvar baz = new Baz();\n\nconsole.log(Baz.prototype.isPrototypeOf(baz)); // true\nconsole.log(Bar.prototype.isPrototypeOf(baz)); // true\nconsole.log(Foo.prototype.isPrototypeOf(baz)); // true\nconsole.log(Object.prototype.isPrototypeOf(baz)); // true\n isPrototypeOf() method, along with the instanceof operator particularly comes in handy if you have code that can only function when dealing with objects descended from a specific prototype chain, e.g., to guarantee that certain methods or properties will be present on that object.
For example, check if baz object descends from Foo.prototype:
if (Foo.prototype.isPrototypeOf(baz)) {\n // do something safe\n}\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf\n
The toLocaleString() method returns a string representing the object. This method is meant to be overridden by derived objects for locale-specific purposes.
obj.toLocaleString()
A string representing the object.
Object's toLocaleString returns the result of calling toString().
This function is provided to give objects a generic toLocaleString method, even though not all may use it. See the list below.
toLocaleString\nArray: Array.prototype.toLocaleString()\nNumber: Number.prototype.toLocaleString()\nDate: Date.prototype.toLocaleString()\n| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toLocaleString\n
The toString() method returns a string representing the object.
obj.toString()
A string representing the object.
Every object has a toString() method that is automatically called when the object is to be represented as a text value or when an object is referred to in a manner in which a string is expected. By default, the toString() method is inherited by every object descended from Object. If this method is not overridden in a custom object, toString() returns \"[object type]\", where type is the object type. The following code illustrates this:
var o = new Object();\no.toString(); // returns [object Object]\n
Note: Starting in JavaScript 1.8.5 toString() called on null returns [object Null], and undefined returns [object Undefined], as defined in the 5th Edition of ECMAScript and a subsequent Errata. See Using_toString()_to_detect_object_class.
toString methodYou can create a function to be called in place of the default toString() method. The toString() method takes no arguments and should return a string. The toString() method you create can be any value you want, but it will be most useful if it carries information about the object.
The following code defines the Dog object type and creates theDog, an object of type Dog:
function Dog(name, breed, color, sex) {\n this.name = name;\n this.breed = breed;\n this.color = color;\n this.sex = sex;\n}\n\ntheDog = new Dog('Gabby', 'Lab', 'chocolate', 'female');\n If you call the toString() method on this custom object, it returns the default value inherited from Object:
theDog.toString(); // returns [object Object]\n
The following code creates and assigns dogToString() to override the default toString() method. This function generates a string containing the name, breed, color, and sex of the object, in the form \"property = value;\".
Dog.prototype.toString = function dogToString() {\n var ret = 'Dog ' + this.name + ' is a ' + this.sex + ' ' + this.color + ' ' + this.breed;\n return ret;\n}\n With the preceding code in place, any time theDog is used in a string context, JavaScript automatically calls the dogToString() function, which returns the following string:
\"Dog Gabby is a female chocolate Lab\"\n
toString() to detect object classtoString() can be used with every object and allows you to get its class. To use the Object.prototype.toString() with every object, you need to call Function.prototype.call() or Function.prototype.apply() on it, passing the object you want to inspect as the first parameter called thisArg.
var toString = Object.prototype.toString;\n\ntoString.call(new Date); // [object Date]\ntoString.call(new String); // [object String]\ntoString.call(Math); // [object Math]\n\n// Since JavaScript 1.8.5\ntoString.call(undefined); // [object Undefined]\ntoString.call(null); // [object Null]\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.prototype.toString' in that specification. | Standard | Call on null returns [object Null], and undefined returns [object Undefined]\n |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.prototype.toString' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Object.prototype.toSource()Object.prototype.valueOf()Number.prototype.toString()Symbol.toPrimitive\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString\n
Deprecation warning: Do not use unwatch() and watch()! These two methods were implemented only in Firefox prior to version 58, they're deprecated and removed in Firefox 58+. In addition, using watchpoints has a serious negative impact on performance, which is especially true when used on global objects, such as window. You can usually use setters and getters or proxies instead.
The unwatch() method removes a watchpoint set with the watch() method.
obj.unwatch(prop)
propThe JavaScript debugger has functionality similar to that provided by this method, as well as other debugging options. For information on the debugger, see Venkman.
By default, this method is inherited by every object descended from Object.
Note: The reason for unwatch() to take the property name prop as its only parameter is due to the \"single handler allowing\" behavior of the watch() method.
See watch().
Not part of any specifications. Implemented in JavaScript 1.2.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nNo | \nNo | \n1 — 58 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nNo | \nNo | \nNo | \n4 — 58 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
unwatch() on the Document object throws a TypeError since Firefox 23 (bug 903332). This regression has been fixed with Firefox 27.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/unwatch\n
The valueOf() method returns the primitive value of the specified object.
object.valueOf()
The primitive value of the specified object.
JavaScript calls the valueOf method to convert an object to a primitive value. You rarely need to invoke the valueOf method yourself; JavaScript automatically invokes it when encountering an object where a primitive value is expected.
By default, the valueOf method is inherited by every object descended from Object. Every built-in core object overrides this method to return an appropriate value. If an object has no primitive value, valueOf returns the object itself.
You can use valueOf within your own code to convert a built-in object into a primitive value. When you create a custom object, you can override Object.prototype.valueOf() to call a custom method instead of the default Object method.
You can create a function to be called in place of the default valueOf method. Your function must take no arguments.
Suppose you have an object type MyNumberType and you want to create a valueOf method for it. The following code assigns a user-defined function to the object's valueOf method:
MyNumberType.prototype.valueOf = function() { return customPrimitiveValue; }; With the preceding code in place, any time an object of type MyNumberType is used in a context where it is to be represented as a primitive value, JavaScript automatically calls the function defined in the preceding code.
An object's valueOf method is usually invoked by JavaScript, but you can invoke it yourself as follows:
myNumberType.valueOf()
Note: Objects in string contexts convert via the toString() method, which is different from String objects converting to string primitives using valueOf. All objects have a string conversion, if only \"[object type]\". But many objects do not convert to number, boolean, or function.
function MyNumberType(n) {\n this.number = n;\n}\n\nMyNumberType.prototype.valueOf = function() {\n return this.number;\n};\n\nvar myObj = new MyNumberType(4);\nmyObj + 3; // 7\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.prototype.valueOf' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.prototype.valueOf' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.prototype.valueOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf\n
The name property represents a name for the type of error. The initial value is \"Error\".
By default, Error instances are given the name \"Error\". The name property, in addition to the message property, is used by the Error.prototype.toString() method to create a string representation of the error.
var e = new Error('Malformed input'); // e.name is 'Error'\n\ne.name = 'ParseError';\nthrow e;\n// e.toString() would return 'ParseError: Malformed input'\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Error.prototype.name' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Error.prototype.name' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Error.prototype.name' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/name\n
The ArrayBuffer.prototype property represents the prototype for the ArrayBuffer object.
Property attributes of ArrayBuffer.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
ArrayBuffer instances inherit from ArrayBuffer.prototype. As with all constructors, you can change the constructor's prototype object to make changes to all ArrayBuffer instances.
ArrayBuffer constructor.ArrayBuffer.prototype.byteLength Read only \nArrayBuffer.prototype.slice()ArrayBuffer whose contents are a copy of this ArrayBuffer's bytes from begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'ArrayBuffer.prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'ArrayBuffer.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype\n
Deprecation warning: Do not use watch() and unwatch()! These two methods were implemented only in Firefox prior to version 58, they're deprecated and removed in Firefox 58+. In addition, using watchpoints has a serious negative impact on performance, which is especially true when used on global objects, such as window. You can usually use setters and getters or proxies instead.
The watch() method watches for a property to be assigned a value and runs a function when that occurs.
obj.watch(prop, handler)
prophandlerWatches for assignment to a property named prop in this object, calling handler(prop, oldval, newval) whenever prop is set and storing the return value in that property. A watchpoint can filter (or nullify) the value assignment, by returning a modified newval (or by returning oldval).
If you delete a property for which a watchpoint has been set, that watchpoint does not disappear. If you later recreate the property, the watchpoint is still in effect.
To remove a watchpoint, use the unwatch() method. By default, the watch method is inherited by every object descended from Object.
The JavaScript debugger has functionality similar to that provided by this method, as well as other debugging options. For information on the debugger, see Venkman.
In Firefox, handler is only called from assignments in script, not from native code. For example, window.watch('location', myHandler) will not call myHandler if the user clicks a link to an anchor within the current document. However, window.location += '#myAnchor' will call myHandler.
Note: Calling watch() on an object for a specific property overrides any previous handler attached for that property.
watch and unwatch\nvar o = { p: 1 };\n\no.watch('p', function (id, oldval, newval) {\n console.log('o.' + id + ' changed from ' + oldval + ' to ' + newval);\n return newval;\n});\n\no.p = 2;\no.p = 3;\ndelete o.p;\no.p = 4;\n\no.unwatch('p');\no.p = 5;\n This script displays the following:
o.p changed from 1 to 2\no.p changed from 2 to 3\no.p changed from undefined to 4\n
watch to validate an object's propertiesYou can use watch to test any assignment to an object's properties. This example ensures that every Person always has a valid name and an age between 0 and 200.
Person = function(name, age) {\n this.watch('age', Person.prototype._isValidAssignment);\n this.watch('name', Person.prototype._isValidAssignment);\n this.name = name;\n this.age = age;\n};\n\nPerson.prototype.toString = function() {\n return this.name + ', ' + this.age;\n};\n\nPerson.prototype._isValidAssignment = function(id, oldval, newval) {\n if (id === 'name' && (!newval || newval.length > 30)) {\n throw new RangeError('invalid name for ' + this);\n }\n if (id === 'age' && (newval < 0 || newval > 200)) {\n throw new RangeError('invalid age for ' + this);\n }\n return newval;\n}\n\nwill = new Person('Will', 29);\nconsole.log(will); // Will, 29\n\ntry {\n will.name = '';\n} catch (e) {\n console.log(e);\n}\n\ntry {\n will.age = -4;\n} catch (e) {\n console.log(e);\n}\n This script displays the following:
Will, 29\nRangeError: invalid name for Will, 29\nRangeError: invalid age for Will, 29\n
Not part of any specifications. Implemented in JavaScript 1.2.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nNo | \nNo | \n1 — 58 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nNo | \nNo | \nNo | \n4 — 58 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
watch to all ES5 compatible browsers.Proxy enables you do even deeper changes to how property assignments work.watch() on the Document object throws a TypeError since Firefox 23 (bug 903332). This regression has been fixed with Firefox 27.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/watch\n
The toString() method returns a string representing the specified Error object.
e.toString()
A string representing the specified Error object.
The Error object overrides the Object.prototype.toString() method inherited by all objects. Its semantics are as follows (assuming Object and String have their original values):
Error.prototype.toString = function() {\n 'use strict';\n\n var obj = Object(this);\n if (obj !== this) {\n throw new TypeError();\n }\n\n var name = this.name;\n name = (name === undefined) ? 'Error' : String(name);\n\n var msg = this.message;\n msg = (msg === undefined) ? '' : String(msg);\n\n if (name === '') {\n return msg;\n }\n if (msg === '') {\n return name;\n }\n\n return name + ': ' + msg;\n};\n var e = new Error('fatal error');\nconsole.log(e.toString()); // 'Error: fatal error'\n\ne.name = undefined;\nconsole.log(e.toString()); // 'Error: fatal error'\n\ne.name = '';\nconsole.log(e.toString()); // 'fatal error'\n\ne.message = undefined;\nconsole.log(e.toString()); // 'Error'\n\ne.name = 'hello';\nconsole.log(e.toString()); // 'hello'\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Error.prototype.toString' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Error.prototype.toString' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Error.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/toString\n
The EvalError.prototype property represents the prototype of the EvalError constructor.
Property attributes of EvalError.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All EvalError instances inherit from EvalError.prototype. You can use the prototype to add properties or methods to all instances.
EvalError.prototype.constructorEvalError.prototype.messageEvalError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.EvalError.prototype.nameError.EvalError.prototype.fileNameError.EvalError.prototype.lineNumberError.EvalError.prototype.columnNumberError.EvalError.prototype.stackError.Although the EvalError prototype object does not contain any methods of its own, EvalError instances do inherit some methods through the prototype chain.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Draft | Defined as NativeError.prototype. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/prototype\n
The return() method returns the given value and finishes the generator.
gen.return(value)
valueThe value that is given as an argument.
return()\nThe following example shows a simple generator and the return method.
function* gen() { \n yield 1;\n yield 2;\n yield 3;\n}\n\nvar g = gen();\n\ng.next(); // { value: 1, done: false }\ng.return('foo'); // { value: \"foo\", done: true }\ng.next(); // { value: undefined, done: true }\n If return(value) is called on a generator that is already in \"completed\" state, the generator will remain in \"completed\" state. If no argument is provided, the return object is the same as if .next(). If an argument is provided, it will be set to the value of the value property of the returned object.
function* gen() {\n yield 1;\n yield 2;\n yield 3;\n}\n\nvar g = gen();\ng.next(); // { value: 1, done: false }\ng.next(); // { value: 2, done: false }\ng.next(); // { value: 3, done: false }\ng.next(); // { value: undefined, done: true }\ng.return(); // { value: undefined, done: true }\ng.return(1); // { value: 1, done: true }\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Generator.prototype.return' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Generator.prototype.return' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n50 | \n13 | \n38 | \nNo | \n37 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n50 | \n13 | \n38 | \nYes | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator/return\n
The GeneratorFunction.prototype property represents the GeneratorFunction prototype object.
GeneratorFunction objects inherit from GeneratorFunction.prototype. GeneratorFunction.prototype cannot be modified.
GeneratorFunction.constructorGeneratorFunction.GeneratorFunction.prototype.prototype%GeneratorPrototype%.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'GeneratorFunction.prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'GeneratorFunction.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n26 | \nNo | \nYes | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n? | \n26 | \n? | \n? | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/GeneratorFunction/prototype\n
The throw() method resumes the execution of a generator by throwing an error into it and returns an object with two properties done and value.
gen.throw(exception)
exceptioninstanceof Error.An Object with two properties:
done (boolean) true if the iterator is past the end of the iterated sequence. In this case value optionally specifies the return value of the iterator.false if the iterator was able to produce the next value in the sequence. This is equivalent of not specifying the done property altogether.value - any JavaScript value returned by the iterator. Can be omitted when done is true.throw()\nThe following example shows a simple generator and an error that is thrown using the throw method. An error can be caught by a try...catch block as usual.
function* gen() {\n while(true) {\n try {\n yield 42;\n } catch(e) {\n console.log('Error caught!');\n }\n }\n}\n\nvar g = gen();\ng.next();\n// { value: 42, done: false }\ng.throw(new Error('Something went wrong'));\n// \"Error caught!\"\n// { value: 42, done: false }\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Generator.prototype.throw' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Generator.prototype.throw' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n39 | \n13 | \n26 | \nNo | \nYes | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n13 | \n26 | \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator/throw\n
The Boolean.prototype property represents the prototype for the Boolean constructor.
Property attributes of Boolean.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Boolean instances inherit from Boolean.prototype. You can use the constructor's prototype object to add properties or methods to all Boolean instances.
Boolean.prototype.constructorBoolean function by default.Boolean.prototype.toSource() \nBoolean object; you can use this string to create an equivalent object. Overrides the Object.prototype.toSource() method.Boolean.prototype.toString()\"true\" or \"false\" depending upon the value of the object. Overrides the Object.prototype.toString() method.Boolean.prototype.valueOf()Boolean object. Overrides the Object.prototype.valueOf() method.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Boolean.prototype' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Boolean.prototype' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Boolean.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype\n
The toString() method returns a string representing the specified Boolean object.
bool.toString()
A string representing the specified Boolean object.
The Boolean object overrides the toString method of the Object object; it does not inherit Object.prototype.toString(). For Boolean objects, the toString method returns a string representation of the object.
JavaScript calls the toString method automatically when a Boolean is to be represented as a text value or when a Boolean is referred to in a string concatenation.
For Boolean objects and values, the built-in toString method returns the string \"true\" or \"false\" depending on the value of the boolean object.
toString\nIn the following code, flag.toString() returns \"true\":
var flag = new Boolean(true);\nvar myVar = flag.toString();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Boolean.prototype.toString' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Boolean.prototype.toString' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Boolean.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/toString\n
The Object.setPrototypeOf() method sets the prototype (i.e., the internal [[Prototype]] property) of a specified object to another object or null.
Warning: Changing the [[Prototype]] of an object is, by the nature of how modern JavaScript engines optimize property accesses, a very slow operation, in every browser and JavaScript engine. The effects on performance of altering inheritance are subtle and far-flung, and are not limited to simply the time spent in the Object.setPrototypeOf(...) statement, but may extend to any code that has access to any object whose [[Prototype]] has been altered. If you care about performance you should avoid setting the [[Prototype]] of an object. Instead, create a new object with the desired [[Prototype]] using Object.create().
However, if a feature is part of the language, the burden of implementing that feature performantly is on the engine developers (ideally).
Object.setPrototypeOf(obj, prototype)
objprototypenull).The specified object.
Throws a TypeError exception if the object whose [[Prototype]] is to be modified is non-extensible according to Object.isExtensible(). Does nothing if the prototype parameter isn't an object or null (i.e., number, string, boolean, or undefined). Otherwise, this method changes the [[Prototype]] of obj to the new value.
Object.setPrototypeOf() is in the ECMAScript 2015 specification. It is generally considered the proper way to set the prototype of an object, vs. the more controversial Object.prototype.__proto__ property.
var dict = Object.setPrototypeOf({}, null);\n Using the older Object.prototype.__proto__ property, we can easily define Object.setPrototypeOf if it isn't available already:
// Only works in Chrome and FireFox, does not work in IE:\nObject.setPrototypeOf = Object.setPrototypeOf || function(obj, proto) {\n obj.__proto__ = proto;\n return obj; \n}\n A combination of Object.getPrototypeOf() and Object.prototype.__proto__ permits appending a whole prototype chain to a new prototype object:
/**\n*** Object.appendChain(@object, @prototype)\n*\n* Appends the first non-native prototype of a chain to a new prototype.\n* Returns @object (if it was a primitive value it will transformed into an object).\n*\n*** Object.appendChain(@object [, \"@arg_name_1\", \"@arg_name_2\", \"@arg_name_3\", \"...\"], \"@function_body\")\n*** Object.appendChain(@object [, \"@arg_name_1, @arg_name_2, @arg_name_3, ...\"], \"@function_body\")\n*\n* Appends the first non-native prototype of a chain to the native Function.prototype object, then appends a\n* new Function([\"@arg\"(s)], \"@function_body\") to that chain.\n* Returns the function.\n*\n**/\n\nObject.appendChain = function(oChain, oProto) {\n if (arguments.length < 2) { \n throw new TypeError('Object.appendChain - Not enough arguments');\n }\n if (typeof oProto !== 'object' && typeof oProto !== 'string') {\n throw new TypeError('second argument to Object.appendChain must be an object or a string');\n }\n\n var oNewProto = oProto,\n oReturn = o2nd = oLast = oChain instanceof this ? oChain : new oChain.constructor(oChain);\n\n for (var o1st = this.getPrototypeOf(o2nd);\n o1st !== Object.prototype && o1st !== Function.prototype;\n o1st = this.getPrototypeOf(o2nd)\n ) {\n o2nd = o1st;\n }\n\n if (oProto.constructor === String) {\n oNewProto = Function.prototype;\n oReturn = Function.apply(null, Array.prototype.slice.call(arguments, 1));\n this.setPrototypeOf(oReturn, oLast);\n }\n\n this.setPrototypeOf(o2nd, oNewProto);\n return oReturn;\n}\n function Mammal() {\n this.isMammal = 'yes';\n}\n\nfunction MammalSpecies(sMammalSpecies) {\n this.species = sMammalSpecies;\n}\n\nMammalSpecies.prototype = new Mammal();\nMammalSpecies.prototype.constructor = MammalSpecies;\n\nvar oCat = new MammalSpecies('Felis');\n\nconsole.log(oCat.isMammal); // 'yes'\n\nfunction Animal() {\n this.breathing = 'yes';\n}\n\nObject.appendChain(oCat, new Animal());\n\nconsole.log(oCat.breathing); // 'yes'\n function MySymbol() {\n this.isSymbol = 'yes';\n}\n\nvar nPrime = 17;\n\nconsole.log(typeof nPrime); // 'number'\n\nvar oPrime = Object.appendChain(nPrime, new MySymbol());\n\nconsole.log(oPrime); // '17'\nconsole.log(oPrime.isSymbol); // 'yes'\nconsole.log(typeof oPrime); // 'object'\n function Person(sName) {\n this.identity = sName;\n}\n\nvar george = Object.appendChain(new Person('George'),\n 'console.log(\"Hello guys!!\");');\n\nconsole.log(george.identity); // 'George'\ngeorge(); // 'Hello guys!!'\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.setPrototypeOf' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.setPrototypeOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n34 | \nYes | \n31 | \n11 | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n31 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Reflect.setPrototypeOf()Object.prototype.isPrototypeOf()Object.getPrototypeOf()Object.prototype.__proto__\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf\n
The next() method returns an object with two properties done and value. You can also provide a parameter to the next method to send a value to the generator.
gen.next(value)
valueAn Object with two properties:
done (boolean) true if the iterator is past the end of the iterated sequence. In this case value optionally specifies the return value of the iterator.false if the iterator was able to produce the next value in the sequence. This is equivalent of not specifying the done property altogether.value - any JavaScript value returned by the iterator. Can be omitted when done is true.next()\nThe following example shows a simple generator and the object that the next method returns:
function* gen() { \n yield 1;\n yield 2;\n yield 3;\n}\n\nvar g = gen(); // \"Generator { }\"\ng.next(); // \"Object { value: 1, done: false }\"\ng.next(); // \"Object { value: 2, done: false }\"\ng.next(); // \"Object { value: 3, done: false }\"\ng.next(); // \"Object { value: undefined, done: true }\"\n In this example, next is called with a value. Note that the first call did not log anything, because the generator was not yielding anything initially.
function* gen() {\n while(true) {\n var value = yield null;\n console.log(value);\n }\n}\n\nvar g = gen();\ng.next(1); \n// \"{ value: null, done: false }\"\ng.next(2); \n// 2\n// \"{ value: null, done: false }\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Generator.prototype.next' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Generator.prototype.next' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n39 | \n13 | \n26 | \nNo | \nYes | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n13 | \n26 | \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator/next\n
The byteLength accessor property represents the length of an ArrayBuffer in bytes.
arraybuffer.byteLength
The byteLength property is an accessor property whose set accessor function is undefined, meaning that you can only read this property. The value is established when the array is constructed and cannot be changed. This property returns 0 if this ArrayBuffer has been detached.
var buffer = new ArrayBuffer(8);\nbuffer.byteLength; // 8\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'ArrayBuffer.prototype.byteLength' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'ArrayBuffer.prototype.byteLength' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/byteLength\n
The hasOwnProperty() method returns a boolean indicating whether the object has the specified property as its own property (as opposed to inheriting it).
obj.hasOwnProperty(prop)
A Boolean indicating whether or not the object has the specified property as own property.
Every object descended from Object inherits the hasOwnProperty method. This method can be used to determine whether an object has the specified property as a direct property of that object; unlike the in operator, this method does not check down the object's prototype chain.
hasOwnProperty returns true even if the value of the property is null or undefined.
o = new Object();\no.propOne = null;\no.hasOwnProperty('propOne'); // returns true\no.propTwo = undefined; \no.hasOwnProperty('propTwo'); // returns true\n hasOwnProperty to test for a property's existenceThe following example determines whether the o object contains a property named prop:
o = new Object();\no.hasOwnProperty('prop'); // returns false\no.prop = 'exists'; \no.hasOwnProperty('prop'); // returns true\n The following example differentiates between direct properties and properties inherited through the prototype chain:
o = new Object();\no.prop = 'exists';\no.hasOwnProperty('prop'); // returns true\no.hasOwnProperty('toString'); // returns false\no.hasOwnProperty('hasOwnProperty'); // returns false\n The following example shows how to iterate over the properties of an object without executing on inherited properties. Note that the for...in loop is already only iterating enumerable items, so one should not assume based on the lack of non-enumerable properties shown in the loop that hasOwnProperty itself is confined strictly to enumerable items (as with Object.getOwnPropertyNames()).
var buz = {\n fog: 'stack'\n};\n\nfor (var name in buz) {\n if (buz.hasOwnProperty(name)) {\n console.log('this is fog (' + \n name + ') for sure. Value: ' + buz[name]);\n }\n else {\n console.log(name); // toString or something else\n }\n}\n hasOwnProperty as a property nameJavaScript does not protect the property name hasOwnProperty; thus, if the possibility exists that an object might have a property with this name, it is necessary to use an external hasOwnProperty to get correct results:
var foo = {\n hasOwnProperty: function() {\n return false;\n },\n bar: 'Here be dragons'\n};\n\nfoo.hasOwnProperty('bar'); // always returns false\n\n// Use another Object's hasOwnProperty\n// and call it with 'this' set to foo\n({}).hasOwnProperty.call(foo, 'bar'); // true\n\n// It's also possible to use the hasOwnProperty property\n// from the Object prototype for this purpose\nObject.prototype.hasOwnProperty.call(foo, 'bar'); // true\n Note that in the last case there are no newly created objects.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.5. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.prototype.hasOwnProperty' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.prototype.hasOwnProperty' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.prototype.hasOwnProperty' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
//github FabioVergani / js-Polyfill_Object-hasOwnProperty\n\n//#Polyfill\n\n/*\nsimple:\nObject.prototype.hasOwnProperty||(Object.prototype.hasOwnProperty=function(x){var o,e=this,p=String(x);return p in e && (o=e.__proto__||e.constructor.prototype,(p in o ===false)||e[p]!== o[p])});\n*/\n\n//Advanced:\n(function(w){\n var isFunction=w.isFunction||(w.isFunction=function(x){return typeof(x)==='function'}),\n has=w.has||(w.has=function(o,p){var e=p in o;return {value:e && (e=o[p]) && true,refer:e,valueOf:function(){return this.value}}}),\n Polyfill=w.PolyfillMethod||(w.PolyfillMethod=function(o,p,x){var e=has(o,p);if(e && (e=isFunction(e.refer))===false){o[p]=x};return e}),\n theProto=w.Object.prototype;\n\n Polyfill(theProto,'hasOwnProperty',function(x){var o,e=this,p=String(x);return p in e && (o=e.__proto__||e.constructor.prototype,(p in o ===false)||e[p]!== o[p])});\n\n})(window);\n\n\n\n\n/*\nvar obj1={a:1,b:false}, obj2=Object.create(obj1);\nobj2.a=2;\nobj2.c='yeah';\n//Polyfilled & Native:\nconsole.dir([\nobj1.hasOwnProperty('a'),//true\nobj1.hasOwnProperty('b'),//true\nobj1.hasOwnProperty('c'),//false\nobj2.hasOwnProperty('a'),//true\nobj2.hasOwnProperty('b'),//false\nobj2.hasOwnProperty('c')//true\n]);\nObject.prototype.hasOwnProperty.call(Object.create(null),'a')//false\n*/\n Object.getOwnPropertyNames()for...inin\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty\n
The message property is a human-readable description of the error.
This property contains a brief description of the error if one is available or has been set. SpiderMonkey makes extensive use of the message property for exceptions. The message property combined with the name property is used by the Error.prototype.toString() method to create a string representation of the Error.
By default, the message property is an empty string, but this behavior can be overridden for an instance by specifying a message as the first argument to the Error constructor.
var e = new Error('Could not parse input'); \n// e.message is 'Could not parse input'\nthrow e;\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Error.prototype.message' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Error.prototype.message' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Error.prototype.message' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/message\n
The valueOf() method returns the primitive value of a Boolean object.
bool.valueOf()
The primitive value of the given Boolean object
The valueOf method of Boolean returns the primitive value of a Boolean object or literal Boolean as a Boolean data type.
This method is usually called internally by JavaScript and not explicitly in code.
valueOf\nx = new Boolean();\nmyVar = x.valueOf(); // assigns false to myVar\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Boolean.prototype.valueOf' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Boolean.prototype.valueOf' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Boolean.prototype.valueOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/valueOf\n
The ArrayBuffer.isView() method returns true if arg is one of the ArrayBuffer views, such as typed array objects or a DataView; false otherwise.
ArrayBuffer.isView(arg)
argtrue if the given argument is one of the ArrayBuffer views; otherwise, false.
ArrayBuffer.isView(); // false \nArrayBuffer.isView([]); // false\nArrayBuffer.isView({}); // false\nArrayBuffer.isView(null); // false\nArrayBuffer.isView(undefined); // false\nArrayBuffer.isView(new ArrayBuffer(10)); // false\n \nArrayBuffer.isView(new Uint8Array()); // true\nArrayBuffer.isView(new Float32Array()); // true\nArrayBuffer.isView(new Int8Array(10).subarray(0, 3)); // true\n\nvar buffer = new ArrayBuffer(2);\nvar dv = new DataView(buffer);\nArrayBuffer.isView(dv); // true\n | Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'ArrayBuffer.isView' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'ArrayBuffer.isView' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n29 | \n11 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n29 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView\n
The ArrayBuffer[@@species] accessor property returns the ArrayBuffer constructor.
ArrayBuffer[Symbol.species]\n
The species accessor property returns the default constructor for ArrayBuffer objects. Subclass constructors may over-ride it to change the constructor assignment.
The species property returns the default constructor function, which is the ArrayBuffer constructor for ArrayBuffer objects:
ArrayBuffer[Symbol.species]; // function ArrayBuffer()
In a derived collection object (e.g. your custom array buffer MyArrayBuffer), the MyArrayBuffer species is the MyArrayBuffer constructor. However, you might want to overwrite this, in order to return parent ArrayBuffer objects in your derived class methods:
class MyArrayBuffer extends ArrayBuffer {\n // Overwrite MyArrayBuffer species to the parent ArrayBuffer constructor\n static get [Symbol.species]() { return ArrayBuffer; }\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'get ArrayBuffer [ @@species ]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'get ArrayBuffer [ @@species ]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.5.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/@@species\n
The slice() method returns a new ArrayBuffer whose contents are a copy of this ArrayBuffer's bytes from begin, inclusive, up to end, exclusive.
arraybuffer.slice(begin[, end])
beginendArrayBuffer contains all bytes from begin to the end of this ArrayBuffer. The range specified by the begin and end values is clamped to the valid index range for the current array. If the computed length of the new ArrayBuffer would be negative, it is clamped to zero.A new ArrayBuffer object.
The slice method copies up to, but not including, the byte indicated by the end parameter. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.
ArrayBuffer\nvar buf1 = new ArrayBuffer(8);\nvar buf2 = buf1.slice(0);\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by EMCAScript 6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'ArrayBuffer.prototype.slice' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'ArrayBuffer.prototype.slice' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n 12\n
| \n11 | \nYes | \n6 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n 14\n
| \nYes | \n6 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/slice\n
This is an experimental technology
Check the Browser compatibility table carefully before using this in production.
The static ArrayBuffer.transfer() method returns a new ArrayBuffer whose contents have been taken from the oldBuffer's data and then is either truncated or zero-extended by newByteLength. If newByteLength is undefined, the byteLength of the oldBuffer is used. This operation leaves oldBuffer in a detached state.
ArrayBuffer.transfer(oldBuffer [, newByteLength]);
oldBufferArrayBuffer object from which to transfer.ArrayBuffer object.A new ArrayBuffer object.
The ArrayBuffer.transfer() method allows you to grow and detach ArrayBuffer objects. The ability to grow an ArrayBuffer without copying has the advantage of being much faster for large buffers (similar to realloc). The ability to detach an ArrayBuffer gives the developer explicit control over when the underlying memory is released. This avoids having to drop all references and wait for garbage collection.
var buf1 = new ArrayBuffer(40);\nnew Int32Array(buf1)[0] = 42;\n\nvar buf2 = ArrayBuffer.transfer(buf1, 80);\nbuf1.byteLength; // 0 but if you use the polyfill then the value is still 40\nbuf2.byteLength; // 80\nnew Int32Array(buf2)[0]; // 42\n\nvar buf3 = ArrayBuffer.transfer(buf2, 0);\nbuf2.byteLength; // 0 but if you use the polyfill then the value is still 80\nbuf3.byteLength; // 0\n
You can partially work around this by inserting the following code at the beginning of your scripts, allowing use of much of the functionality of transfer() in browsers that do not natively support it. This is not the exact equivalent of this API because browsers that natively support it are be able to internally use the C++ function realloc() which extends the length of the memory and only copies it to a new location as-needed as opposed to the following pollyfill which always copies the whole thing to a new space of memory, but this function transfers data from one ArrayBuffer to another ArrayBuffer.
if (!ArrayBuffer.transfer) {\n ArrayBuffer.transfer = function(source, length) {\n if (!(source instanceof ArrayBuffer))\n throw new TypeError('Source must be an instance of ArrayBuffer');\n if (length <= source.byteLength)\n return source.slice(0, length);\n var sourceView = new Uint8Array(source),\n destView = new Uint8Array(new ArrayBuffer(length));\n destView.set(sourceView);\n return destView.buffer;\n };\n} | Specification | Status | Comment |
|---|---|---|
\nArrayBuffer.prototype.transfer proposal | Draft | Stage 2 Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/transfer\n
The Number.MAX_SAFE_INTEGER constant represents the maximum safe integer in JavaScript (253 - 1).
Property attributes of Number.MAX_SAFE_INTEGER\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The MAX_SAFE_INTEGER constant has a value of 9007199254740991 (9,007,199,254,740,991 or ~9 quadrillion). The reasoning behind that number is that JavaScript uses double-precision floating-point format numbers as specified in IEEE 754 and can only safely represent numbers between -(253 - 1) and 253 - 1.
Safe in this context refers to the ability to represent integers exactly and to correctly compare them. For example, Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 will evaluate to true, which is mathematically incorrect. See Number.isSafeInteger() for more information.
Because MAX_SAFE_INTEGER is a static property of Number, you always use it as Number.MAX_SAFE_INTEGER, rather than as a property of a Number object you created.
Number.MAX_SAFE_INTEGER // 9007199254740991\nNumber.MAX_SAFE_INTEGER * Number.EPSILON // 2 because in floating points, the value is actually the decimal trailing \"1\"\n // except for in subnormal precision cases such as zero\n
if (!Number.MAX_SAFE_INTEGER) {\n Number.MAX_SAFE_INTEGER = Math.pow(2, 53) - 1; // 9007199254740991\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.MAX_SAFE_INTEGER' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.MAX_SAFE_INTEGER' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n34 | \nYes | \n31 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n31 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER\n
The TypedArray.BYTES_PER_ELEMENT property represents the size in bytes of each element in an typed array.
Property attributes of TypedArray.BYTES_PER_ELEMENT\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
TypedArray.BYTES_PER_ELEMENT;
TypedArray objects differ from each other in the number of bytes per element and in the way the bytes are interpreted. The BYTES_PER_ELEMENT constant contains the number of bytes each element in the given TypedArray has.
Int8Array.BYTES_PER_ELEMENT; // 1\nUint8Array.BYTES_PER_ELEMENT; // 1\nUint8ClampedArray.BYTES_PER_ELEMENT; // 1\nInt16Array.BYTES_PER_ELEMENT; // 2\nUint16Array.BYTES_PER_ELEMENT; // 2\nInt32Array.BYTES_PER_ELEMENT; // 4\nUint32Array.BYTES_PER_ELEMENT; // 4\nFloat32Array.BYTES_PER_ELEMENT; // 4\nFloat64Array.BYTES_PER_ELEMENT; // 8
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.BYTES_PER_ELEMENT' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.BYTES_PER_ELEMENT' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/BYTES_PER_ELEMENT\n
The byteOffset accessor property represents the offset (in bytes) of a typed array from the start of its ArrayBuffer.
typedarray.byteOffset
The byteOffset property is an accessor property whose set accessor function is undefined, meaning that you can only read this property. The value is established when a TypedArray is constructed and cannot be changed. TypedArray is one of the TypedArray objects.
byteOffset propertyvar buffer = new ArrayBuffer(8);\n\nvar uint8 = new Uint8Array(buffer);\nuint8.byteOffset; // 0 (no offset specified)\n\nvar uint8 = new Uint8Array(buffer, 3);\nuint8.byteOffset; // 3 (as specified when constructing Uint8Array)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.byteOffset' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.byteOffset' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteOffset\n
The byteLength accessor property represents the length (in bytes) of a typed array.
typedarray.byteLength
The byteLength property is an accessor property whose set accessor function is undefined, meaning that you can only read this property. The value is established when a TypedArray is constructed and cannot be changed. If the TypedArray is not specifying an byteOffset or a length, the length of the referenced ArrayBuffer will be returned. TypedArray is one of the TypedArray objects.
byteLength propertyvar buffer = new ArrayBuffer(8);\n\nvar uint8 = new Uint8Array(buffer);\nuint8.byteLength; // 8 (matches the byteLength of the buffer)\n\nvar uint8 = new Uint8Array(buffer, 1, 5);\nuint8.byteLength; // 5 (as specified when constructing the Uint8Array)\n\nvar uint8 = new Uint8Array(buffer, 2);\nuint8.byteLength; // 6 (due to the offset of the constructed Uint8Array)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.byteLength' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.byteLength' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/byteLength\n
This page describes JavaScript's lexical grammar. The source text of ECMAScript scripts gets scanned from left to right and is converted into a sequence of input elements which are tokens, control characters, line terminators, comments or white space. ECMAScript also defines certain keywords and literals and has rules for automatic insertion of semicolons to end statements.
Control characters have no visual representation but are used to control the interpretation of the text.
| Code point | Name | Abbreviation | Description |
|---|---|---|---|
U+200C | Zero width non-joiner | <ZWNJ> | Placed between characters to prevent being connected into ligatures in certain languages (Wikipedia). |
U+200D | Zero width joiner | <ZWJ> | Placed between characters that would not normally be connected in order to cause the characters to be rendered using their connected form in certain languages (Wikipedia). |
U+FEFF | Byte order mark | <BOM> | Used at the start of the script to mark it as Unicode and the text's byte order (Wikipedia). |
White space characters improve the readability of source text and separate tokens from each other. These characters are usually unnecessary for the functionality of the code. Minification tools are often used to remove whitespace in order to reduce the amount of data that needs to be transferred.
| Code point | Name | Abbreviation | Description | Escape sequence |
|---|---|---|---|---|
| U+0009 | Character tabulation | <HT> | Horizontal tabulation | \\t |
| U+000B | Line tabulation | <VT> | Vertical tabulation | \\v |
| U+000C | Form feed | <FF> | Page breaking control character (Wikipedia). | \\f |
| U+0020 | Space | <SP> | Normal space | |
| U+00A0 | No-break space | <NBSP> | Normal space, but no point at which a line may break | |
| Others | Other Unicode space characters | <USP> | Spaces in Unicode on Wikipedia |
In addition to white space characters, line terminator characters are used to improve the readability of the source text. However, in some cases, line terminators can influence the execution of JavaScript code as there are a few places where they are forbidden. Line terminators also affect the process of automatic semicolon insertion. Line terminators are matched by the \\s class in regular expressions.
Only the following Unicode code points are treated as line terminators in ECMAScript, other line breaking characters are treated as white space (for example, Next Line, NEL, U+0085 is considered as white space).
| Code point | Name | Abbreviation | Description | Escape sequence |
|---|---|---|---|---|
| U+000A | Line Feed | <LF> | New line character in UNIX systems. | \\n |
| U+000D | Carriage Return | <CR> | New line character in Commodore and early Mac systems. | \\r |
| U+2028 | Line Separator | <LS> | Wikipedia | |
| U+2029 | Paragraph Separator | <PS> | Wikipedia |
Comments are used to add hints, notes, suggestions, or warnings to JavaScript code. This can make it easier to read and understand. They can also be used to disable code to prevent it from being executed; this can be a valuable debugging tool.
JavaScript has two ways of assigning comments in its code.
The first way is the // comment; this makes all text following it on the same line into a comment. For example:
function comment() {\n // This is a one line JavaScript comment\n console.log('Hello world!');\n}\ncomment();\n The second way is the /* */ style, which is much more flexible.
For example, you can use it on a single line:
function comment() {\n /* This is a one line JavaScript comment */\n console.log('Hello world!');\n}\ncomment(); You can also make multiple-line comments, like this:
function comment() {\n /* This comment spans multiple lines. Notice\n that we don't need to end the comment until we're done. */\n console.log('Hello world!');\n}\ncomment(); You can also use it in the middle of a line, if you wish, although this can make your code harder to read so it should be used with caution:
function comment(x) {\n console.log('Hello ' + x /* insert the value of x */ + ' !');\n}\ncomment('world'); In addition, you can use it to disable code to prevent it from running, by wrapping code in a comment, like this:
function comment() {\n /* console.log('Hello world!'); */\n}\ncomment(); In this case, the console.log() call is never issued, since it's inside a comment. Any number of lines of code can be disabled this way.
breakcasecatchclassconstcontinuedebuggerdefaultdeletedoelseexportextendsfinallyforfunctionifimportininstanceofnewreturnsuperswitchthisthrowtrytypeofvarvoidwhilewithyieldThe following are reserved as future keywords by the ECMAScript specification. They have no special functionality at present, but they might at some future time, so they cannot be used as identifiers.
These are always reserved:
enumThe following are only reserved when they are found in strict mode code:
implementsinterfaceletpackageprivateprotectedpublicstaticThe following are only reserved when they are found in module code:
awaitThe following are reserved as future keywords by older ECMAScript specifications (ECMAScript 1 till 3).
abstractbooleanbytechardoublefinalfloatgotointlongnativeshortsynchronizedthrowstransientvolatileAdditionally, the literals null, true, and false cannot be used as identifiers in ECMAScript.
Reserved words actually only apply to Identifiers (vs. IdentifierNames) . As described in es5.github.com/#A.1, these are all IdentifierNames which do not exclude ReservedWords.
a.import\na['import']\na = { import: 'test' }.\n On the other hand the following is illegal because it's an Identifier, which is an IdentifierName without the reserved words. Identifiers are used for FunctionDeclaration, FunctionExpression, VariableDeclaration and so on. IdentifierNames are used for MemberExpression, CallExpression and so on.
function import() {} // Illegal. See also null for more information.
null
See also Boolean for more information.
true\nfalse
1234567890\n42\n\n// Caution when using with a leading zero:\n0888 // 888 parsed as decimal\n0777 // parsed as octal, 511 in decimal\n
Note that decimal literals can start with a zero (0) followed by another decimal digit, but If all digits after the leading 0 are smaller than 8, the number is interpreted as an octal number. This won't throw in JavaScript, see bug 957513. See also the page about parseInt().
Binary number syntax uses a leading zero followed by a lowercase or uppercase Latin letter \"B\" (0b or 0B). Because this syntax is new in ECMAScript 2015, see the browser compatibility table, below. If the digits after the 0b are not 0 or 1, the following SyntaxError is thrown: \"Missing binary digits after 0b\".
var FLT_SIGNBIT = 0b10000000000000000000000000000000; // 2147483648\nvar FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040\nvar FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607
Octal number syntax uses a leading zero followed by a lowercase or uppercase Latin letter \"O\" (0o or 0O). Because this syntax is new in ECMAScript 2015, see the browser compatibility table, below. If the digits after the 0o are outside the range (01234567), the following SyntaxError is thrown: \"Missing octal digits after 0o\".
var n = 0O755; // 493\nvar m = 0o644; // 420\n\n// Also possible with just a leading zero (see note about decimals above)\n0755\n0644\n
Hexadecimal number syntax uses a leading zero followed by a lowercase or uppercase Latin letter \"X\" (0x or 0X). If the digits after 0x are outside the range (0123456789ABCDEF), the following SyntaxError is thrown: \"Identifier starts immediately after numeric literal\".
0xFFFFFFFFFFFFFFFFF // 295147905179352830000\n0x123456789ABCDEF // 81985529216486900\n0XA // 10\n
See also Object and Object initializer for more information.
var o = { a: 'foo', b: 'bar', c: 42 };\n\n// shorthand notation. New in ES2015\nvar a = 'foo', b = 'bar', c = 42;\nvar o = {a, b, c};\n\n// instead of\nvar o = { a: a, b: b, c: c };\n See also Array for more information.
[1954, 1974, 1990, 2014]
A string literal is zero or more Unicode code points enclosed in single or double quotes. Unicode code points may also be represented by an escape sequence. All code points may appear literally in a string literal except for these closing quote code points:
Prior to the proposal to make all JSON text valid ECMA-262, U+2028 <LS> and U+2029 <PS>, were also disallowed from appearing unescaped in string literals.
Any code points may appear in the form of an escape sequence. String literals evaluate to ECMAScript String values. When generating these String values Unicode code points are UTF-16 encoded.
'foo'\n\"bar\"
Hexadecimal escape sequences consist of \\x followed by exactly two hexadecimal digits representing a code unit or code point in the range 0x0000 to 0x00FF.
'\\xA9' // \"©\"\n
A Unicode escape sequence consists of exactly four hexadecimal digits following \\u. It represents a code unit in the UTF-16 encoding. For code points U+0000 to U+FFFF, the code unit is equal to the code point. Code points U+10000 to U+10FFFF require two escape sequences representing the two code units (a surrogate pair) used to encode the character; the surrogate pair is distinct from the code point.
See also String.fromCharCode() and String.prototype.charCodeAt().
'\\u00A9' // \"©\" (U+A9)
A Unicode code point escape consists of \\u{, followed by a code point in hexadecimal base, followed by }. The value of the hexadecimal digits must be in the range 0 and 0x10FFFF inclusive. Code points in the range U+10000 to U+10FFFF do not need to be represented as a surrogate pair. Code point escapes were added to JavaScript in ECMAScript 2015 (ES6).
See also String.fromCodePoint() and String.prototype.codePointAt().
'\\u{2F804}' // CJK COMPATIBILITY IDEOGRAPH-2F804 (U+2F804)\n\n// the same character represented as a surrogate pair\n'\\uD87E\\uDC04' See also RegExp for more information.
/ab+c/g\n\n// An \"empty\" regular expression literal\n// The empty non-capturing group is necessary \n// to avoid ambiguity with single-line comments.\n/(?:)/
See also template strings for more information.
`string text`\n\n`string text line 1\n string text line 2`\n\n`string text ${expression} string text`\n\ntag `string text ${expression} string text` Some JavaScript statements must be terminated with semicolons and are therefore affected by automatic semicolon insertion (ASI):
let, const, variable statementimport, export, module declarationdebuggercontinue, break, throw\nreturnThe ECMAScript specification mentions three rules of semicolon insertion.
1. A semicolon is inserted before, when a Line terminator or \"}\" is encountered that is not allowed by the grammar.
{ 1 2 } 3 \n\n// is transformed by ASI into \n\n{ 1 2 ;} 3; 2. A semicolon is inserted at the end, when the end of the input stream of tokens is detected and the parser is unable to parse the single input stream as a complete program.
Here ++ is not treated as a postfix operator applying to variable b, because a line terminator occurs between b and ++.
a = b\n++c\n\n// is transformend by ASI into\n\na = b;\n++c;\n
3. A semicolon is inserted at the end, when a statement with restricted productions in the grammar is followed by a line terminator. These statements with \"no LineTerminator here\" rules are:
++ and --)continuebreakreturnyield, yield*\nmodulereturn\na + b\n\n// is transformed by ASI into\n\nreturn;\na + b;\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Lexical Conventions' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Lexical Grammar' in that specification. | Standard | Added: Binary and Octal Numeric literals, Unicode code point escapes, Templates |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Lexical Grammar' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
Array literals ([1, 2, 3]) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Binary numeric literals (0b) | \n41 | \n12 | \n25 | \nNo | \n28 | \n9 | \n
Boolean literals (true/false) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Decimal numeric literals (1234567890) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Hexadecimal escape sequences ('\\0xA9') | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Hexadecimal numeric literals (0xAF) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Null literal (null) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Octal numeric literals (0o) | \n41 | \n12 | \n25 | \nYes | \n28 | \n9 | \n
Regular expression literals (/ab+c/g) | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
String literals ('Hello world') | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Unicode escape sequences ('\\u00A9') | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Unicode point escapes (\\u{}) | \n44 | \n12 | \n40 | \nNo | \n31 | \n9 | \n
| Shorthand notation for object literals | \n43 | \n12 | \n33 | \nNo | \n30 | \n9 | \n
| Template literals | \n41 | \n12 | \n34 | \nNo | \n28 | \n9 | \n
| Trailing commas | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
Array literals ([1, 2, 3]) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Binary numeric literals (0b) | \n41 | \n41 | \n12 | \n25 | \n28 | \nYes | \n4.0 | \n
Boolean literals (true/false) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Decimal numeric literals (1234567890) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Hexadecimal escape sequences ('\\0xA9') | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Hexadecimal numeric literals (0xAF) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Null literal (null) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Octal numeric literals (0o) | \n41 | \n41 | \n12 | \n25 | \n28 | \nYes | \n4.0 | \n
Regular expression literals (/ab+c/g) | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
String literals ('Hello world') | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Unicode escape sequences ('\\u00A9') | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Unicode point escapes (\\u{}) | \n44 | \n44 | \n12 | \n40 | \n31 | \n? | \n4.0 | \n
| Shorthand notation for object literals | \n43 | \n43 | \n12 | \n33 | \n30 | \n? | \n4.0 | \n
| Template literals | \n41 | \n41 | \n12 | \n34 | \n28 | \n? | \n4.0 | \n
| Trailing commas | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
Array literals ([1, 2, 3]) | \nYes | \n
Binary numeric literals (0b) | \n 4.0.0\n
| \n
Boolean literals (true/false) | \nYes | \n
Decimal numeric literals (1234567890) | \nYes | \n
Hexadecimal escape sequences ('\\0xA9') | \nYes | \n
Hexadecimal numeric literals (0xAF) | \nYes | \n
Null literal (null) | \nYes | \n
Octal numeric literals (0o) | \nYes | \n
Regular expression literals (/ab+c/g) | \nYes | \n
String literals ('Hello world') | \nYes | \n
Unicode escape sequences ('\\u00A9') | \nYes | \n
Unicode point escapes (\\u{}) | \nYes | \n
| Shorthand notation for object literals | \nYes | \n
| Template literals | \n4.0.0 | \n
| Trailing commas | \nYes | \n
BooleanNumberRegExpString\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar\n
The TypedArray.name property represents a string value of the typed array constructor name.
Property attributes of TypedArray.name\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
TypedArray.name;
TypedArray objects differ from each other in the number of bytes per element and in the way the bytes are interpreted. The name property describes of what data type the array consists. The first part can be Int for \"integer\" or Uint for an \"unsigned integer\", also Float for \"floating point\" is used. The second part is a number describing the bit-size of the array. Finally, the object type is Array, with ClampedArray as a special case. Please see Uint8ClampedArray for more details.
Int8Array.name; // \"Int8Array\"\nUint8Array.name; // \"Uint8Array\"\nUint8ClampedArray.name; // \"Uint8ClampedArray\"\nInt16Array.name; // \"Int16Array\"\nUint16Array.name; // \"Uint16Array\"\nInt32Array.name; // \"Int32Array\"\nUint32Array.name; // \"Uint32Array\"\nFloat32Array.name; // \"Float32Array\"\nFloat64Array.name; // \"Float64Array\"
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.name' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.name' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/name\n
The buffer accessor property represents the ArrayBuffer referenced by a TypedArray at construction time.
typedArray.buffer
The buffer property is an accessor property whose set accessor function is undefined, meaning that you can only read this property. The value is established when the TypedArray is constructed and cannot be changed. TypedArray is one of the TypedArray objects.
buffer propertyvar buffer = new ArrayBuffer(8);\nvar uint16 = new Uint16Array(buffer);\nuint16.buffer; // ArrayBuffer { byteLength: 8 }\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.buffer' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.buffer' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/buffer\n
The TypedArray.of() method creates a new typed array with a variable number of arguments. This method is nearly the same as Array.of().
TypedArray.of(element0[, element1[, ...[, elementN]]])\n\nwhere TypedArray is one of:\n\nInt8Array\nUint8Array\nUint8ClampedArray\nInt16Array\nUint16Array\nInt32Array\nUint32Array\nFloat32Array\nFloat64Array
elementNA new TypedArray instance.
Some subtle distinctions between Array.of() and TypedArray.of():
this value passed to TypedArray.of is not a constructor, TypedArray.of will throw a TypeError, where Array.of defaults to creating a new Array.TypedArray.of uses [[Put]] where Array.of uses [[DefineProperty]]. Hence, when working with Proxy objects, it calls handler.set to create new elements rather than handler.defineProperty.Uint8Array.of(1); // Uint8Array [ 1 ]\nInt8Array.of('1', '2', '3'); // Int8Array [ 1, 2, 3 ]\nFloat32Array.of(1, 2, 3); // Float32Array [ 1, 2, 3 ]\nInt16Array.of(undefined); // IntArray [ 0 ]\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.of' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.of' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n38 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nNo | \n? | \n38 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/of\n
The length accessor property represents the length (in elements) of a typed array.
typedarray.length
The length property is an accessor property whose set accessor function is undefined, meaning that you can only read this property. The value is established when a TypedArray is constructed and cannot be changed. If the TypedArray is not specifying an byteOffset or a length, the length of the referenced ArrayBuffer will be returned. TypedArray is one of the TypedArray objects.
length propertyvar buffer = new ArrayBuffer(8);\n\nvar uint8 = new Uint8Array(buffer);\nuint8.length; // 8 (matches the length of the buffer)\n\nvar uint8 = new Uint8Array(buffer, 1, 5);\nuint8.length; // 5 (as specified when constructing the Uint8Array)\n\nvar uint8 = new Uint8Array(buffer, 2);\nuint8.length; // 6 (due to the offset of the constructed Uint8Array)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.length' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.length' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/length\n
The TypedArray[@@species] accessor property returns the constructor of a typed array.
TypedArray[Symbol.species]\n\nwhere TypedArray is one of:\n\nInt8Array\nUint8Array\nUint8ClampedArray\nInt16Array\nUint16Array\nInt32Array\nUint32Array\nFloat32Array\nFloat64Array\n
The species accessor property returns the default constructor for typed array objects. Subclass constructors may over-ride it to change the constructor assignment.
The species property returns the default constructor function, which is one of the typed array constructors for a given typed array object:
Int8Array[Symbol.species]; // function Int8Array()\nUint8Array[Symbol.species]; // function Uint8Array()\nFloat32Array[Symbol.species]; // function Float32Array()\n
In a derived collection object (e.g. your custom typed array MyTypedArray), the MyTypedArray species is the MyTypedArray constructor. However, you might want to overwrite this, in order to return a parent typed array object in your derived class methods:
class MyTypedArray extends Uint8Array {\n // Overwrite MyTypedArray species to the parent Uint8Array constructor\n static get [Symbol.species]() { return Uint8Array; }\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'get %TypedArray% [ @@species ]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'get %TypedArray% [ @@species ]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n? | \n48 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.5.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/@@species\n
The TypedArray.from() method creates a new typed array from an array-like or iterable object. This method is nearly the same as Array.from().
TypedArray.from(source[, mapFn[, thisArg]])\n\nwhere TypedArray is one of:\n\nInt8Array\nUint8Array\nUint8ClampedArray\nInt16Array\nUint16Array\nInt32Array\nUint32Array\nFloat32Array\nFloat64Array\n
sourcemapFnthisArgthis when executing mapFn.A new TypedArray instance.
TypedArray.from() lets you create typed arrays from:
length property and indexed elements) orMap and Set).TypedArray.from() has an optional parameter mapFn, which allows you to execute a map function on each element of the typed array (or subclass object) that is being created. More clearly, TypedArray.from(obj, mapFn, thisArg) is the same as TypedArray.from(Array.prototype.map.call(obj, mapFn, thisArg)).
The length property of the from() method is 1.
Some subtle distinctions between Array.from() and TypedArray.from():
|this| value passed to TypedArray.from is not a constructor, TypedArray.from will throw a TypeError, where Array.from defaults to creating a new Array.TypedArray.from uses [[Put]] where Array.from uses [[DefineProperty]]. Hence, when working with Proxy objects, it calls handler.set to create new elements rather than handler.defineProperty.from gets an iterator, the TypedArray version first collects all the values from the iterator, then creates an instance of |this| using the count, then sets the values on the instance. Array.from sets each value as it gets them from the iterator then sets the length at the end.Array.from gets an array-like which isn't an iterator, it respects holes, where TypedArray.from will ensure the result is dense.// Set (iterable object)\nvar s = new Set([1, 2, 3]);\nUint8Array.from(s);\n// Uint8Array [ 1, 2, 3 ]\n\n\n// String\nInt16Array.from('123'); \n// Int16Array [ 1, 2, 3 ]\n\n\n// Using an arrow function as the map function to\n// manipulate the elements\nFloat32Array.from([1, 2, 3], x => x + x); \n// Float32Array [ 2, 4, 6 ]\n\n\n// Generate a sequence of numbers\nUint8Array.from({length: 5}, (v, k) => k); \n// Uint8Array [ 0, 1, 2, 3, 4 ]\n You can partially work around this by inserting the following code at the beginning of your scripts, allowing use of much of the functionality of from() in implementations that do not natively support it.
if (!Int8Array.__proto__.from) {\n (function () {\n Int8Array.__proto__.from = function (obj, func, thisObj) {\n\n var typedArrayClass = Int8Array.__proto__;\n if(typeof this !== 'function') {\n throw new TypeError('# is not a constructor');\n }\n if (this.__proto__ !== typedArrayClass) {\n throw new TypeError('this is not a typed array.');\n }\n \n func = func || function (elem) {\n return elem;\n };\n\n if (typeof func !== 'function') {\n throw new TypeError('specified argument is not a function');\n }\n\n obj = Object(obj);\n if (!obj['length']) {\n return new this(0);\n }\n var copy_data = [];\n for(var i = 0; i < obj.length; i++) {\n copy_data.push(obj[i]);\n }\n\n copy_data = copy_data.map(func, thisObj);\n\n var typed_array = new this(copy_data.length);\n for(var i = 0; i < typed_array.length; i++) {\n typed_array[i] = copy_data[i];\n }\n return typed_array;\n }\n })();\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.from' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.from' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n38 | \nNo | \nNo | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nNo | \n? | \n38 | \nNo | \n10 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from\n
The copyWithin() method copies the sequence of array elements within the array to the position starting at target. The copy is taken from the index positions of the second and third arguments start and end. The end argument is optional and defaults to the length of the array. This method has the same algorithm as Array.prototype.copyWithin. TypedArray is one of the typed array types here.
typedarray.copyWithin(target, start[, end = this.length])
targetstartend OptionalThe modified array.
See Array.prototype.copyWithin for more details.
This method replaces the experimental TypedArray.prototype.move().
var buffer = new ArrayBuffer(8);\nvar uint8 = new Uint8Array(buffer);\nuint8.set([1,2,3]);\nconsole.log(uint8); // Uint8Array [ 1, 2, 3, 0, 0, 0, 0, 0 ]\nuint8.copyWithin(3,0,3);\nconsole.log(uint8); // Uint8Array [ 1, 2, 3, 1, 2, 3, 0, 0 ]\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.copyWithin' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.copyWithin' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n34 | \nNo | \n36 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nNo | \n? | \n34 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin\n
The filter() method creates a new typed array with all elements that pass the test implemented by the provided function. This method has the same algorithm as Array.prototype.filter(). TypedArray is one of the typed array types here.
typedarray.filter(callback[, thisArg])
callback(element, index, typedarray). Return true to keep the element, false otherwise.thisArg Optionalthis when executing callback.A new typed array with the elements that pass the test.
The filter() method calls a provided callback function once for each element in a typed array, and constructs a new typed array of all the values for which callback returns a true value. callback is invoked only for indexes of the typed array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values. Typed array elements which do not pass the callback test are simply skipped, and are not included in the new typed array.
callback is invoked with three arguments:
If a thisArg parameter is provided to filter, it will be passed to callback when invoked, for use as its this value. Otherwise, the value undefined will be passed for use as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
filter() does not mutate the typed array on which it is called.
The range of elements processed by filter() is set before the first invocation of callback. Elements which are appended to the typed array after the call to filter() begins will not be visited by callback. If existing elements of the typed array are changed, or deleted, their value as passed to callback will be the value at the time filter() visits them; elements that are deleted are not visited.
The following example uses filter() to create a filtered typed array that has all elements with values less than 10 removed.
function isBigEnough(element, index, array) {\n return element >= 10;\n}\nnew Uint8Array([12, 5, 8, 130, 44]).filter(isBigEnough); \n// Uint8Array [ 12, 130, 44 ]\n Arrow functions provide a shorter syntax for the same test.
new Uint8Array([12, 5, 8, 130, 44]).filter(elem => elem >= 10); \n// Uint8Array [ 12, 130, 44 ]
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.filter' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.filter' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n38 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nYes | \n? | \n38 | \nNo | \nNo | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/filter\n
The every() method tests whether all elements in the typed array pass the test implemented by the provided function. This method has the same algorithm as Array.prototype.every(). TypedArray is one of the typed array types here.
typedarray.every(callback[, thisArg])
callbackcurrentValueindexarrayevery was called upon.thisArgthis when executing callback.true if the callback function returns a truthy value for every array element; otherwise, false.
The every method executes the provided callback function once for each element present in the typed array until it finds one where callback returns a falsy value (a value that becomes false when converted to a Boolean). If such an element is found, the every method immediately returns false. Otherwise, if callback returned a true value for all elements, every will return true.
callback is invoked with three arguments: the value of the element, the index of the element, and the array object being traversed.
If a thisArg parameter is provided to every, it will be passed to callback when invoked, for use as its this value. Otherwise, the value undefined will be passed for use as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
every does not mutate the typed array on which it is called.
The following example tests whether all elements in the typed array are bigger than 10.
function isBigEnough(element, index, array) {\n return element >= 10;\n}\nnew Uint8Array([12, 5, 8, 130, 44]).every(isBigEnough); // false\nnew Uint8Array([12, 54, 18, 130, 44]).every(isBigEnough); // true Arrow functions provide a shorter syntax for the same test.
new Uint8Array([12, 5, 8, 130, 44]).every(elem => elem >= 10); // false\nnew Uint8Array([12, 54, 18, 130, 44]).every(elem => elem >= 10); // true
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.every' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.every' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n37 | \nNo | \n36 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nYes | \n? | \n37 | \nNo | \nNo | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/every\n
The fill() method fills all the elements of a typed array from a start index to an end index with a static value. This method has the same algorithm as Array.prototype.fill(). TypedArray is one of the typed array types here.
typedarray.fill(value[, start = 0[, end = this.length]])
valuestartendThe modified array.
The elements interval to fill is [start, end).
The fill method takes up to three arguments value, start and end. The start and end arguments are optional with default values of 0 and the length of the this object.
If start is negative, it is treated as length+start where length is the length of the array. If end is negative, it is treated as length+end.
new Uint8Array([1, 2, 3]).fill(4); // Uint8Array [4, 4, 4]\nnew Uint8Array([1, 2, 3]).fill(4, 1); // Uint8Array [1, 4, 4]\nnew Uint8Array([1, 2, 3]).fill(4, 1, 2); // Uint8Array [1, 4, 3]\nnew Uint8Array([1, 2, 3]).fill(4, 1, 1); // Uint8Array [1, 2, 3]\nnew Uint8Array([1, 2, 3]).fill(4, -3, -2); // Uint8Array [4, 2, 3]\n
Since there is no global object with the name TypedArray, polyfilling must be done on an \"as needed\" basis. Use the following \"polyfill\" along with the Array.prototype.fill() polyfill.
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.fill\nif (!Uint8Array.prototype.fill) {\n Uint8Array.prototype.fill = Array.prototype.fill;\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.fill' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.fill' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n37 | \nNo | \n36 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nYes | \n? | \n37 | \nNo | \nNo | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/fill\n
The TypedArray.prototype property represents the prototype for TypedArray constructors.
Property attributes of TypedArray.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
TypedArray instances inherit from TypedArray.prototype. You can use the constructor's prototype object to add properties or methods to all TypedArray instances, where TypedArray is one of the typed array types.
See also the description about TypedArray for more information about inheritance.
TypedArray.prototype.constructorTypedArray.prototype.buffer Read only \nArrayBuffer referenced by the typed array. Fixed at construction time and thus read only.TypedArray.prototype.byteLength Read only \nTypedArray.prototype.byteOffset Read only \nArrayBuffer. Fixed at construction time and thus read only.\nTypedArray.prototype.length Read only \nTypedArray.prototype.copyWithin()Array.prototype.copyWithin().TypedArray.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array. See also Array.prototype.entries().TypedArray.prototype.every()Array.prototype.every().TypedArray.prototype.fill()Array.prototype.fill().TypedArray.prototype.filter()Array.prototype.filter().TypedArray.prototype.find()undefined if not found. See also Array.prototype.find().TypedArray.prototype.findIndex()Array.prototype.findIndex().TypedArray.prototype.forEach()Array.prototype.forEach().TypedArray.prototype.includes() \ntrue or false as appropriate. See also Array.prototype.includes().TypedArray.prototype.indexOf()Array.prototype.indexOf().TypedArray.prototype.join()Array.prototype.join().TypedArray.prototype.keys()Array Iterator that contains the keys for each index in the array. See also Array.prototype.keys().TypedArray.prototype.lastIndexOf()Array.prototype.lastIndexOf().TypedArray.prototype.map()Array.prototype.map().TypedArray.prototype.move() Unimplemented\nTypedArray.prototype.copyWithin().TypedArray.prototype.reduce()Array.prototype.reduce().TypedArray.prototype.reduceRight()Array.prototype.reduceRight().TypedArray.prototype.reverse()Array.prototype.reverse().TypedArray.prototype.set()TypedArray.prototype.slice()Array.prototype.slice().TypedArray.prototype.some()Array.prototype.some().TypedArray.prototype.sort()Array.prototype.sort().TypedArray.prototype.subarray()TypedArray.prototype.values()Array Iterator object that contains the values for each index in the array. See also Array.prototype.values().TypedArray.prototype.toLocaleString()Array.prototype.toLocaleString().TypedArray.prototype.toString()Array.prototype.toString().TypedArray.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \nYes | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/prototype\n
The entries() method returns a new Array Iterator object that contains the key/value pairs for each index in the array.
arr.entries()
A new Array Iterator object.
for...of loopvar arr = new Uint8Array([10, 20, 30, 40, 50]);\nvar eArray = arr.entries();\n// your browser must support for..of loop\n// and let-scoped variables in for loops\nfor (let n of eArray) {\n console.log(n);\n}\n var arr = new Uint8Array([10, 20, 30, 40, 50]);\nvar eArr = arr.entries();\nconsole.log(eArr.next().value); // [0, 10]\nconsole.log(eArr.next().value); // [1, 20]\nconsole.log(eArr.next().value); // [2, 30]\nconsole.log(eArr.next().value); // [3, 40]\nconsole.log(eArr.next().value); // [4, 50]\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype.entries()' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype.entries()' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n37 | \nNo | \n36 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nYes | \n? | \n37 | \nNo | \nNo | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
TypedArrayTypedArray.prototype.keys()TypedArray.prototype.values()TypedArray.prototype[@@iterator]()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/entries\n
The forEach() method executes a provided function once per array element. This method has the same algorithm as Array.prototype.forEach(). TypedArray is one of the typed array types here.
typedarray.forEach(callback[, thisArg])
callbackcurrentValueindexarrayforEach() was called upon.thisArgthis when executing callback.The forEach() method executes the provided callback once for each element present in the typed array in ascending order. It is not invoked for indexes that have been deleted or elided. However, it is executed for elements that are present and have the value undefined.
callback is invoked with three arguments:
If a thisArg parameter is provided to forEach(), it will be passed to callback when invoked, for use as its this value. Otherwise, the value undefined will be passed for use as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
The range of elements processed by forEach() is set before the first invocation of callback. Elements that are appended to the typed array after the call to forEach() begins will not be visited by callback. If the values of existing elements of the typed array are changed, the value passed to callback will be the value at the time forEach() visits them; elements that are deleted before being visited are not visited.
forEach() executes the callback function once for each typed array element; unlike every() and some() it, always returns the value undefined.
The following code logs a line for each element in a typed array:
function logArrayElements(element, index, array) {\n console.log('a[' + index + '] = ' + element);\n}\n\nnew Uint8Array([0, 1, 2, 3]).forEach(logArrayElements);\n// logs:\n// a[0] = 0\n// a[1] = 1\n// a[2] = 2\n// a[3] = 3\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype.forEach' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype.forEach' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n14 | \n38 | \nNo | \n? | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nYes | \n? | \n38 | \n? | \n? | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
TypedArray.prototype.map()TypedArray.prototype.every()TypedArray.prototype.some()Array.prototype.forEach()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/forEach\n
The join() method joins all elements of an array into a string. This method has the same algorithm as Array.prototype.join(). TypedArray is one of the typed array types here.
typedarray.join([separator = ',']);
separatorA string with all array elements joined.
var uint8 = new Uint8Array([1,2,3]);\nuint8.join(); // '1,2,3'\nuint8.join(' / '); // '1 / 2 / 3'\nuint8.join(''); // '123'\n Since there is no global object with the name TypedArray, polyfilling must be done on an \"as needed\" basis.
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.join\nif (!Uint8Array.prototype.join) {\n Object.defineProperty(Uint8Array.prototype, 'join', {\n value: Array.prototype.join\n });\n}\n If you need to support truly obsolete JavaScript engines that don't support Object.defineProperty, it's best not to polyfill Array.prototype methods at all, as you can't make them non-enumerable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.join' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.join' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n14 | \n37 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nYes | \nYes | \n37 | \nNo | \nNo | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/join\n
The sort() method sorts the elements of a typed array numerically in place and returns the typed array. This method has the same algorithm as Array.prototype.sort(), except that sorts the values numerically instead of as strings. TypedArray is one of the typed array types here.
typedarray.sort([compareFunction])
compareFunction Optional\nThe sorted typed array.
For more examples, see also the Array.prototype.sort() method.
let numbers = new Uint8Array([40, 1, 5, 200]);\nnumbers.sort();\n// Uint8Array [ 1, 5, 40, 200 ] \n// Unlike plain Arrays, a compare function is not required\n// to sort the numbers numerically.\n\n// Regular Arrays require a compare function to sort numerically:\nnumbers = [40, 1, 5, 200];\nnumbers.sort();\n// [1, 200, 40, 5]\n\nnumbers.sort((a, b) => a - b); // compare numbers\n// [ 1, 5, 40, 200 ]\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.sort' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.sort' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n14 | \n46 | \nNo | \nYes | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n46 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/sort\n
The findIndex() method returns an index in the typed array, if an element in the typed array satisfies the provided testing function. Otherwise -1 is returned.
See also the find() method, which returns the value of a found element in the typed array instead of its index.
typedarray.findIndex(callback[, thisArg])
callbackelementindexarrayfindIndex was called upon.thisArgthis when executing callback.An index in the array if an element passes the test; otherwise, -1.
The findIndex method executes the callback function once for each element present in the typed array until it finds one where callback returns a true value. If such an element is found, findIndex immediately returns the index of that element. Otherwise, findIndex returns -1. callback is invoked only for indexes of the typed array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.
callback is invoked with three arguments: the value of the element, the index of the element, and the typed array object being traversed.
If a thisArg parameter is provided to findIndex, it will be used as the this for each invocation of the callback. If it is not provided, then undefined is used.
findIndex does not mutate the typed array on which it is called.
The range of elements processed by findIndex is set before the first invocation of callback. Elements that are appended to the typed array after the call to findIndex begins will not be visited by callback. If an existing, unvisited element of the typed array is changed by callback, its value passed to the visiting callback will be the value at the time that findIndex visits that element's index; elements that are deleted are not visited.
The following example finds the index of an element in the typed array that is a prime number (or returns -1 if there is no prime number).
function isPrime(element, index, array) {\n var start = 2;\n while (start <= Math.sqrt(element)) {\n if (element % start++ < 1) {\n return false;\n }\n }\n return element > 1;\n}\n\nvar uint8 = new Uint8Array([4, 6, 8, 12]);\nvar uint16 = new Uint16Array([4, 6, 7, 12]);\n\nconsole.log(uint8.findIndex(isPrime)); // -1, not found\nconsole.log(uint16.findIndex(isPrime)); // 2\n TypedArray.prototype.findIndex = Array.prototype.findIndex = Array.prototype.findIndex || function(evaluator, thisArg) {\n 'use strict';\n if (!this) {\n throw new TypeError('Array.prototype.some called on null or undefined');\n }\n \n if (typeof(evaluator) !== 'function') {\n if (typeof(evaluator) === 'string') {\n // Attempt to convert it to a function\n if ( ! (evaluator = eval(evaluator)) ){\n throw new TypeError();\n }\n } else {\n throw new TypeError();\n }\n }\n \n var i;\n if (thisArg === undefined) { // Optimize for thisArg\n for (i in this) {\n if (evaluator(this[i], i, this)) {\n return i;\n }\n }\n return -1;\n }\n for (i in this) {\n if (evaluator.call(thisArg, this[i], i, this)) {\n return i;\n }\n }\n return -1;\n}; | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype.findIndex' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype.findIndex' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n14 | \n37 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nNo | \n? | \n37 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/findIndex\n
The find() method returns a value in the typed array, if an element satisfies the provided testing function. Otherwise undefined is returned. TypedArray is one of the typed array types here.
See also the findIndex() method, which returns the index of a found element in the typed array instead of its value.
typedarray.find(callback[, thisArg])
callbackelementindexarrayfind was called upon.thisArgthis when executing callback.A value in the array if an element passes the test; otherwise, undefined.
The find method executes the callback function once for each element present in the typed array until it finds one where callback returns a true value. If such an element is found, find immediately returns the value of that element. Otherwise, find returns undefined. callback is invoked only for indexes of the typed array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.
callback is invoked with three arguments: the value of the element, the index of the element, and the typed array object being traversed.
If a thisArg parameter is provided to find, it will be used as the this for each invocation of the callback. If it is not provided, then undefined is used.
find does not mutate the typed array on which it is called.
The range of elements processed by find is set before the first invocation of callback. Elements that are appended to the typed array after the call to find begins will not be visited by callback. If an existing, unvisited element of the typed array is changed by callback, its value passed to the visiting callback will be the value at the time that find visits that element's index; elements that are deleted are not visited.
The following example finds an element in the typed array that is a prime number (or returns undefined if there is no prime number).
function isPrime(element, index, array) {\n var start = 2;\n while (start <= Math.sqrt(element)) {\n if (element % start++ < 1) {\n return false;\n }\n }\n return element > 1;\n}\n\nvar uint8 = new Uint8Array([4, 5, 8, 12]);\nconsole.log(uint8.find(isPrime)); // 5 | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype.find' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype.find' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n14 | \n37 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nNo | \n? | \n37 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/find\n
The includes() method determines whether a typed array includes a certain element, returning true or false as appropriate. This method has the same algorithm as Array.prototype.includes(). TypedArray is one of the typed array types here.
typedarray.includes(searchElement[, fromIndex]);
searchElementfromIndexsearchElement; defaults to 0.A Boolean.
var uint8 = new Uint8Array([1,2,3]);\nuint8.includes(2); // true\nuint8.includes(4); // false\nuint8.includes(3, 3); // false\n\n// NaN handling (only true for Float32 and Float64)\nnew Uint8Array([NaN]).includes(NaN); // false, since the NaN passed to the constructor gets converted to 0\nnew Float32Array([NaN]).includes(NaN); // true;\nnew Float64Array([NaN]).includes(NaN); // true;\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2016 (ECMA-262) The definition of 'TypedArray.prototype.includes' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.includes' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n47 | \n14 | \n43 | \nNo | \n34 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n47 | \n? | \n43 | \n34 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/includes\n
The indexOf() method returns the first index at which a given element can be found in the typed array, or -1 if it is not present. This method has the same algorithm as Array.prototype.indexOf(). TypedArray is one of the typed array types here.
typedarray.indexOf(searchElement[, fromIndex = 0])
searchElementfromIndexThe first index of the element in the array; -1 if not found.
indexOf compares searchElement to elements of the typed array using strict equality (the same method used by the ===, or triple-equals, operator).
var uint8 = new Uint8Array([2, 5, 9]);\nuint8.indexOf(2); // 0\nuint8.indexOf(7); // -1\nuint8.indexOf(9, 2); // 2\nuint8.indexOf(2, -1); // -1\nuint8.indexOf(2, -3); // 0\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.indexOf' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.indexOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n 37\n
| \nNo | \n32 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n45 | \nYes | \n 37\n
| \n32 | \nNo | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/indexOf\n
The keys() method returns a new Array Iterator object that contains the keys for each index in the array.
arr.keys()
A new Array Iterator object.
for...of loopvar arr = new Uint8Array([10, 20, 30, 40, 50]);\nvar eArray = arr.keys();\n// your browser must support for..of loop\n// and let-scoped variables in for loops\nfor (let n of eArray) {\n console.log(n);\n}\n var arr = new Uint8Array([10, 20, 30, 40, 50]);\nvar eArr = arr.keys();\nconsole.log(eArr.next().value); // 0\nconsole.log(eArr.next().value); // 1\nconsole.log(eArr.next().value); // 2\nconsole.log(eArr.next().value); // 3\nconsole.log(eArr.next().value); // 4\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype.keys()' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype.keys()' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n14 | \n37 | \nNo | \nNo | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nYes | \nYes | \n37 | \nNo | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
TypedArrayTypedArray.prototype.entries()TypedArray.prototype.values()TypedArray.prototype[@@iterator]()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/keys\n
The reduce() method applies a function against an accumulator and each value of the typed array (from left-to-right) has to reduce it to a single value. This method has the same algorithm as Array.prototype.reduce(). TypedArray is one of the typed array types here.
typedarray.reduce(callback[, initialValue])
callbackpreviousValueinitialValue, if supplied (see below).currentValueindexarrayreduce was called upon.initialValuecallback.The value that results from the reduction.
The reduce method executes the callback function once for each element present in the typed array, excluding holes in the typed array, receiving four arguments: the initial value (or value from the previous callback call), the value of the current element, the current index, and the typed array over which iteration is occurring.
The first time the callback is called, previousValue and currentValue can be one of two values. If initialValue is provided in the call to reduce, then previousValue will be equal to initialValue and currentValue will be equal to the first value in the typed array. If no initialValue was provided, then previousValue will be equal to the first value in the typed array and currentValue will be equal to the second.
If the typed array is empty and no initialValue was provided, TypeError would be thrown. If the typed array has only one element (regardless of position) and no initialValue was provided, or if initialValue is provided but the typed array is empty, the solo value would be returned without calling callback.
var total = new Uint8Array([0, 1, 2, 3]).reduce(function(a, b) {\n return a + b;\n});\n// total == 6\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype.reduce' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype.reduce' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n37 | \nNo | \n32 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \nYes | \n37 | \nNo | \n10 | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduce\n
The lastIndexOf() method returns the last index at which a given element can be found in the typed array, or -1 if it is not present. The typed array is searched backwards, starting at fromIndex. This method has the same algorithm as Array.prototype.lastIndexOf(). TypedArray is one of the typed array types here.
typedarray.lastIndexOf(searchElement[, fromIndex = typedarray.length])
searchElementfromIndexThe last index of the element in the array; -1 if not found.
lastIndexOf compares searchElement to elements of the typed array using strict equality (the same method used by the ===, or triple-equals, operator).
var uint8 = new Uint8Array([2, 5, 9, 2]);\nuint8.lastIndexOf(2); // 3\nuint8.lastIndexOf(7); // -1\nuint8.lastIndexOf(2, 3); // 3\nuint8.lastIndexOf(2, 2); // 0\nuint8.lastIndexOf(2, -2); // 0\nuint8.lastIndexOf(2, -1); // 3\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.lastIndexOf' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.lastIndexOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n14 | \n 37\n
| \nNo | \nYes | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nYes | \nYes | \n 37\n
| \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/lastIndexOf\n
The reduceRight() method applies a function against an accumulator and each value of the typed array (from right-to-left) has to reduce it to a single value. This method has the same algorithm as Array.prototype.reduceRight(). TypedArray is one of the typed array types here.
typedarray.reduceRight(callback[, initialValue])
callbackpreviousValueinitialValue, if supplied (see below).currentValueindexarrayreduce was called upon.initialValuecallback.The value that results from the reduction.
The reduceRight method executes the callback function once for each element present in the typed array, excluding holes in the typed array, receiving four arguments: the initial value (or value from the previous callback call), the value of the current element, the current index, and the typed array over which iteration is occurring.
The call to the reduceRight callback would look something like this:
typedarray.reduceRight(function(previousValue, currentValue, index, typedarray) {\n // ...\n});\n The first time the function is called, the previousValue and currentValue can be one of two values. If an initialValue was provided in the call to reduceRight, then previousValue will be equal to initialValue and currentValue will be equal to the last value in the typed array. If no initialValue was provided, then previousValue will be equal to the last value in the typed array and currentValue will be equal to the second-to-last value.
If the typed array is empty and no initialValue was provided, TypeError would be thrown. If the typed array has only one element (regardless of position) and no initialValue was provided, or if initialValue is provided but the typed array is empty, the solo value would be returned without calling callback.
var total = new Uint8Array([0, 1, 2, 3]).reduceRight(function(a, b) {\n return a + b;\n});\n// total == 6\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype.reduceRight' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype.reduceRight' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n37 | \nNo | \n32 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \nYes | \n37 | \nNo | \n10 | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reduceRight\n
The reverse() method reverses a typed array in place. The first typed array element becomes the last and the last becomes the first. This method has the same algorithm as Array.prototype.reverse(). TypedArray is one of the typed array types here.
typedarray.reverse();
The reversed array.
var uint8 = new Uint8Array([1, 2, 3]);\nuint8.reverse();\n\nconsole.log(uint8); // Uint8Array [3, 2, 1]\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.reverse' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.reverse' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n37 | \nNo | \n32 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \nYes | \n37 | \nNo | \n10 | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/reverse\n
Generally speaking, a function is a \"subprogram\" that can be called by code external (or internal in the case of recursion) to the function. Like the program itself, a function is composed of a sequence of statements called the function body. Values can be passed to a function, and the function will return a value.
In JavaScript, functions are first-class objects, because they can have properties and methods just like any other object. What distinguishes them from other objects is that functions can be called. In brief, they are Function objects.
For more examples and explanations, see also the JavaScript guide about functions.
Every function in JavaScript is a Function object. See Function for information on properties and methods of Function objects.
To return a value other than the default, a function must have a return statement that specifies the value to return. A function without a return statement will return a default value. In the case of a constructor called with the new keyword, the default value is the value of its this parameter. For all other functions, the default return value is undefined.
The parameters of a function call are the function's arguments. Arguments are passed to functions by value. If the function changes the value of an argument, this change is not reflected globally or in the calling function. However, object references are values, too, and they are special: if the function changes the referred object's properties, that change is visible outside the function, as shown in the following example:
/* Declare the function 'myFunc' */\nfunction myFunc(theObject) {\n theObject.brand = \"Toyota\";\n}\n\n/*\n * Declare variable 'mycar';\n * create and initialize a new Object;\n * assign reference to it to 'mycar'\n */\nvar mycar = {\n brand: \"Honda\",\n model: \"Accord\",\n year: 1998\n};\n\n/* Logs 'Honda' */\nconsole.log(mycar.brand);\n\n/* Pass object reference to the function */\nmyFunc(mycar);\n\n/*\n * Logs 'Toyota' as the value of the 'brand' property\n * of the object, as changed to by the function.\n */\nconsole.log(mycar.brand);\n The this keyword does not refer to the currently executing function, so you must refer to Function objects by name, even within the function body.
There are several ways to define functions:
function statement)There is a special syntax for declaring functions (see function statement for details):
function name([param[, param[, ... param]]]) {\n statements\n}\n nameparamstatementsfunction expression)A function expression is similar to and has the same syntax as a function declaration (see function expression for details). A function expression may be a part of a larger expression. One can define \"named\" function expressions (where the name of the expression might be used in the call stack for example) or \"anonymous\" function expressions. Function expressions are not hoisted onto the beginning of the scope, therefore they cannot be used before they appear in the code.
function [name]([param[, param[, ... param]]]) {\n statements\n}\n nameparamstatementsHere is an example of an anonymous function expression (the name is not used):
var myFunction = function() {\n statements\n} It is also possible to provide a name inside the definition in order to create a named function expression:
var myFunction = function namedFunction(){\n statements\n}\n One of the benefits of creating a named function expression is that in case we encountered an error, the stack trace will contain the name of the function, making it easier to find the origin of the error.
As we can see, both examples do not start with the function keyword. Statements involving functions which do not start with function are function expressions.
When functions are used only once, a common pattern is an IIFE (Immediately Invokable Function Expression).
(function() {\n statements\n})(); IIFE are function expressions that are invoked as soon as the function is declared.
function* statement)There is a special syntax for generator function declarations (see function* statement for details):
function* name([param[, param[, ... param]]]) {\n statements\n}\n nameparamstatementsfunction* expression)A generator function expression is similar to and has the same syntax as a generator function declaration (see function* expression for details):
function* [name]([param[, param[, ... param]]]) {\n statements\n}\n nameparamstatementsAn arrow function expression has a shorter syntax and lexically binds its this value (see arrow functions for details):
([param[, param]]) => {\n statements\n}\n\nparam => expression\n param(). For only one argument, the parentheses are not required. (like foo => 1)statements or expressionFunction constructorNote: Using the Function constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.
As all other objects, Function objects can be created using the new operator:
new Function (arg1, arg2, ... argN, functionBody)\n
arg1, arg2, ... argNfunctionBodyInvoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.
GeneratorFunction constructorNote: GeneratorFunction is not a global object, but could be obtained from generator function instance (see GeneratorFunction for more detail).
Note: Using the GeneratorFunction constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.
As all other objects, GeneratorFunction objects can be created using the new operator:
new GeneratorFunction (arg1, arg2, ... argN, functionBody)\n
arg1, arg2, ... argNx\", \"theValue\", or \"a,b\".functionBodyInvoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.
Default function parameters allow formal parameters to be initialized with default values if no value or undefined is passed. For more details, see default parameters.
The rest parameter syntax allows representing an indefinite number of arguments as an array. For more details, see rest parameters.
arguments objectYou can refer to a function's arguments within the function by using the arguments object. See arguments.
arguments: An array-like object containing the arguments passed to the currently executing function.arguments.callee : The currently executing function.arguments.caller : The function that invoked the currently executing function.arguments.length: The number of arguments passed to the function.You can define getters (accessor methods) and setters (mutator methods) on any standard built-in object or user-defined object that supports the addition of new properties. The syntax for defining getters and setters uses the object literal syntax.
Binds an object property to a function that will be called when that property is looked up.
Starting with ECMAScript 2015, you are able to define own methods in a shorter syntax, similar to the getters and setters. See method definitions for more information.
var obj = {\n foo() {},\n bar() {}\n}; Compare the following:
A function defined with the Function constructor assigned to the variable multiply:
var multiply = new Function('x', 'y', 'return x * y'); A function declaration of a function named multiply:
function multiply(x, y) {\n return x * y;\n} // there is no semicolon here\n A function expression of an anonymous function assigned to the variable multiply:
var multiply = function(x, y) {\n return x * y;\n};\n A function expression of a function named func_name assigned to the variable multiply:
var multiply = function func_name(x, y) {\n return x * y;\n};\n All do approximately the same thing, with a few subtle differences:
There is a distinction between the function name and the variable the function is assigned to. The function name cannot be changed, while the variable the function is assigned to can be reassigned. The function name can be used only within the function's body. Attempting to use it outside the function's body results in an error (or undefined if the function name was previously declared via a var statement). For example:
var y = function x() {};\nalert(x); // throws an error\n The function name also appears when the function is serialized via Function's toString method.
On the other hand, the variable the function is assigned to is limited only by its scope, which is guaranteed to include the scope in which the function is declared.
As the 4th example shows, the function name can be different from the variable the function is assigned to. They have no relation to each other. A function declaration also creates a variable with the same name as the function name. Thus, unlike those defined by function expressions, functions defined by function declarations can be accessed by their name in the scope they were defined in:
A function defined by 'new Function' does not have a function name. However, in the SpiderMonkey JavaScript engine, the serialized form of the function shows as if it has the name \"anonymous\". For example, alert(new Function()) outputs:
function anonymous() {\n}\n Since the function actually does not have a name, anonymous is not a variable that can be accessed within the function. For example, the following would result in an error:
var foo = new Function(\"alert(anonymous);\");\nfoo();\n
Unlike functions defined by function expressions or by the Function constructor, a function defined by a function declaration can be used before the function declaration itself. For example:
foo(); // alerts FOO!\nfunction foo() {\n alert('FOO!');\n}\n A function defined by a function expression or by a function declaration inherits the current scope. That is, the function forms a closure. On the other hand, a function defined by a Function constructor does not inherit any scope other than the global scope (which all functions inherit).
/*\n * Declare and initialize a variable 'p' (global)\n * and a function 'myFunc' (to change the scope) inside which\n * declare a varible with same name 'p' (current) and\n * define three functions using three different ways:-\n * 1. function declaration\n * 2. function expression\n * 3. function constructor\n * each of which will log 'p'\n */\nvar p = 5;\nfunction myFunc() {\n var p = 9;\n\n function decl() {\n console.log(p);\n }\n var expr = function() {\n console.log(p);\n };\n var cons = new Function('\\tconsole.log(p);');\n\n decl();\n expr();\n cons();\n}\nmyFunc();\n\n/*\n * Logs:-\n * 9 - for 'decl' by function declaration (current scope)\n * 9 - for 'expr' by function expression (current scope)\n * 5 - for 'cons' by Function constructor (global scope)\n */\n Functions defined by function expressions and function declarations are parsed only once, while those defined by the Function constructor are not. That is, the function body string passed to the Function constructor must be parsed each and every time the constructor is called. Although a function expression creates a closure every time, the function body is not reparsed, so function expressions are still faster than \"new Function(...)\". Therefore the Function constructor should generally be avoided whenever possible.
It should be noted, however, that function expressions and function declarations nested within the function generated by parsing a Function constructor 's string aren't parsed repeatedly. For example:
var foo = (new Function(\"var bar = \\'FOO!\\';\\nreturn(function() {\\n\\talert(bar);\\n});\"))();\nfoo(); // The segment \"function() {\\n\\talert(bar);\\n}\" of the function body string is not re-parsed. A function declaration is very easily (and often unintentionally) turned into a function expression. A function declaration ceases to be one when it either:
var x = 0; // source element\nif (x === 0) { // source element\n x = 10; // not a source element\n function boo() {} // not a source element\n}\nfunction foo() { // source element\n var y = 20; // source element\n function bar() {} // source element\n while (y === 10) { // source element\n function blah() {} // not a source element\n y++; // not a source element\n }\n}\n // function declaration\nfunction foo() {}\n\n// function expression\n(function bar() {})\n\n// function expression\nx = function hello() {}\n\n\nif (x) {\n // function expression\n function world() {}\n}\n\n\n// function declaration\nfunction a() {\n // function declaration\n function b() {}\n if (0) {\n // function expression\n function c() {}\n }\n}\n In strict mode, starting with ES2015, functions inside blocks are now scoped to that block. Prior to ES2015, block-level functions were forbidden in strict mode.
'use strict';\n\nfunction f() { \n return 1; \n}\n\n{ \n function f() { \n return 2; \n }\n}\n\nf() === 1; // true\n\n// f() === 2 in non-strict mode\n In a word: Don't.
In non-strict code, function declarations inside blocks behave strangely. For example:
if (shouldDefineZero) {\n function zero() { // DANGER: compatibility risk\n console.log(\"This is zero.\");\n }\n}\n ES2015 says that if shouldDefineZero is false, then zero should never be defined, since the block never executes. However, it's a new part of the standard. Historically, this was left unspecified, and some browsers would define zero whether the block executed or not.
In strict mode, all browsers that support ES2015 handle this the same way: zero is defined only if shouldDefineZero is true, and only in the scope of the if-block.
A safer way to define functions conditionally is to assign a function expression to a variable:
var zero;\nif (shouldDefineZero) {\n zero = function() {\n console.log(\"This is zero.\");\n };\n}\n The following function returns a string containing the formatted representation of a number padded with leading zeros.
// This function returns a string padded with leading zeros\nfunction padZeros(num, totalLen) {\n var numStr = num.toString(); // Initialize return value as string\n var numZeros = totalLen - numStr.length; // Calculate no. of zeros\n for (var i = 1; i <= numZeros; i++) {\n numStr = \"0\" + numStr;\n }\n return numStr;\n}\n The following statements call the padZeros function.
var result;\nresult = padZeros(42,4); // returns \"0042\"\nresult = padZeros(42,2); // returns \"42\"\nresult = padZeros(5,4); // returns \"0005\" \n
You can determine whether a function exists by using the typeof operator. In the following example, a test is performed to determine if the window object has a property called noFunc that is a function. If so, it is used; otherwise, some other action is taken.
if ('function' === typeof window.noFunc) {\n // use noFunc()\n } else {\n // do something else\n }\n Note that in the if test, a reference to noFunc is used—there are no brackets \"()\" after the function name so the actual function is not called.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0 |
| ECMAScript 5.1 (ECMA-262) The definition of 'Function Definition' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Function definitions' in that specification. | Standard | New: Arrow functions, Generator functions, default parameters, rest parameters. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Function definitions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
arguments | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Arrow functions | \n45 | \nYes | \n 22\n
| \nNo | \n32 | \n10 | \n
| Block-level functions | \n? | \n? | \n46 | \n? | \n? | \n? | \n
| Default parameters | \n49 | \n14 | \n15 | \nNo | \n36 | \n10 | \n
| Method definitions | \n39 | \nYes | \n34 | \nNo | \n26 | \nNo | \n
| Rest parameters | \n47 | \n12 | \n15 | \nNo | \n34 | \n10 | \n
get | \n1 | \nYes | \n2 | \n9 | \n9.5 | \n3 | \n
set | \n1 | \nYes | \n2 | \n9 | \n9.5 | \n3 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
arguments | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Arrow functions | \n45 | \n45 | \nYes | \n 22\n
| \n32 | \n10 | \n5.0 | \n
| Block-level functions | \n? | \n? | \n? | \n46 | \n? | \n? | \n? | \n
| Default parameters | \n49 | \n49 | \n14 | \n15 | \n36 | \n10 | \n5.0 | \n
| Method definitions | \n39 | \n39 | \nYes | \n34 | \n26 | \nNo | \n4.0 | \n
| Rest parameters | \n47 | \n47 | \n12 | \n15 | \n34 | \n10 | \n5.0 | \n
get | \n1 | \n18 | \nYes | \n4 | \nYes | \nYes | \nYes | \n
set | \n1 | \n18 | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
arguments | \nYes | \n
| Arrow functions | \nYes | \n
| Block-level functions | \n? | \n
| Default parameters | \n6.0.0 | \n
| Method definitions | \nYes | \n
| Rest parameters | \n 6.0.0\n
| \n
get | \nYes | \n
set | \nYes | \n
function statementfunction expressionfunction* statementfunction* expressionFunctionGeneratorFunctionArrow functionsDefault parametersRest parametersArguments objectgettersetterMethod definitions\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions\n
The set() method stores multiple values in the typed array, reading input values from a specified array.
typedarray.set(array[, offset])\ntypedarray.set(typedarray[, offset])\n
ArrayBuffer; the JavaScript engine will intelligently copy the source range of the buffer to the destination range.array. If you omit this value, 0 is assumed (that is, the source array will overwrite values in the target array starting at index 0).RangeErroroffset is set such as it would store beyond the end of the typed array.set methodvar buffer = new ArrayBuffer(8);\nvar uint8 = new Uint8Array(buffer);\n\nuint8.set([1, 2, 3], 3);\n\nconsole.log(uint8); // Uint8Array [ 0, 0, 0, 1, 2, 3, 0, 0 ]\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.set' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.set' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set\n
The slice() method returns a shallow copy of a portion of a typed array into a new typed array object. This method has the same algorithm as Array.prototype.slice(). TypedArray is one of the typed array types here.
typedarray.slice([begin[, end]])
begin Optional\nslice(-2) extracts the last two elements in the sequence.begin is undefined, slice begins from index 0.end Optional\nslice extracts up to but not including end.slice(1,4) extracts the second element through the fourth element (elements indexed 1, 2, and 3).slice(2,-1) extracts the third element through the second-to-last element in the sequence.end is omitted, slice extracts through the end of the sequence (typedarray.length).A new typed array containing the extracted elements.
The slice method does not alter. It returns a shallow copy of elements from the original typed array.
If a new element is added to either typed array, the other typed array is not affected.
var uint8 = new Uint8Array([1,2,3]);\nuint8.slice(1); // Uint8Array [ 2, 3 ]\nuint8.slice(2); // Uint8Array [ 3 ]\nuint8.slice(-2); // Uint8Array [ 2, 3 ]\nuint8.slice(0,1); // Uint8Array [ 1 ]\n
Since there is no global object with the name TypedArray, polyfilling must be done on an \"as needed\" basis.
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.slice\nif (!Uint8Array.prototype.slice) {\n Object.defineProperty(Uint8Array.prototype, 'slice', {\n value: Array.prototype.slice\n });\n}\n This is not a complete polyfill, since it returns an instance of Array, and not Uint8Array, so it lacks properties that would normally exist on TypedArrays.
If you need to support truly obsolete JavaScript engines that don't support Object.defineProperty, it's best not to polyfill Array.prototype methods at all, as you can't make them non-enumerable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype.slice' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype.slice' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n38 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n38 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice\n
The subarray() method returns a new TypedArray on the same ArrayBuffer store and with the same element types as for this TypedArray object. The begin offset is inclusive and the end offset is exclusive. TypedArray is one of the typed array types.
typedarray.subarray([begin [,end]])\n
begin to the end of the array are included in the new view.A new TypedArray object.
The range specified by begin and end is clamped to the valid index range for the current array; if the computed length of the new array would be negative, it's clamped to zero. If either begin or end is negative, it refers to an index from the end of the array instead of from the beginning.
Also note that this is creating a new view on the existing buffer; changes to the new object's contents will impact the original object and vice versa.
subarray methodvar buffer = new ArrayBuffer(8);\nvar uint8 = new Uint8Array(buffer);\nuint8.set([1,2,3]);\n\nconsole.log(uint8); // Uint8Array [ 1, 2, 3, 0, 0, 0, 0, 0 ]\n\nvar sub = uint8.subarray(0,4);\n\nconsole.log(sub); // Uint8Array [ 1, 2, 3, 0 ]\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.subarray' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.subarray' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n7 | \n14 | \n4 | \n10 | \n11.6 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n4 | \n11.6 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray\n
The toString() method returns a string representing the specified array and its elements. This method has the same algorithm as Array.prototype.toString(). TypedArray is one of the typed array types here.
typedarray.toString()
A string representing the elements of the typed array.
The TypedArray objects override the toString method of Object. For TypedArray objects, the toString method joins the array and returns one string containing each typed array element separated by commas. For example, the following code creates a typed array and uses toString to convert the array to a string.
var numbers = new Uint8Array([2, 5, 8, 1, 4])\nnumbers.toString(); // \"2,5,8,1,4\"\n
JavaScript calls the toString method automatically when a typed array is to be represented as a text value or when an array is referred to in a string concatenation.
If a browser doesn't support the TypedArray.prototype.toString() method yet, JavaScript will call the toString method of Object:
var numbers = new Uint8Array([2, 5, 8, 1, 4])\nnumbers.toString(); // \"[object Uint8Array]\"\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.toString' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n? | \n51 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n? | \n51 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toString\n
The some() method tests whether some element in the typed array passes the test implemented by the provided function. This method has the same algorithm as Array.prototype.some(). TypedArray is one of the typed array types here.
typedarray.some(callback[, thisArg])
callbackcurrentValueindexarrayevery was called upon.thisArgthis when executing callback.true if the callback function returns a truthy value for any array element; otherwise, false.
The some method executes the callback function once for each element present in the typed array until it finds one where callback returns a true value. If such an element is found, some immediately returns true. Otherwise, some returns false.
callback is invoked with three arguments: the value of the element, the index of the element, and the array object being traversed.
If a thisArg parameter is provided to some, it will be passed to callback when invoked, for use as its this value. Otherwise, the value undefined will be passed for use as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
some does not mutate the typed array on which it is called.
The following example tests whether any element in the typed array is bigger than 10.
function isBiggerThan10(element, index, array) {\n return element > 10;\n}\nnew Uint8Array([2, 5, 8, 1, 4]).some(isBiggerThan10); // false\nnew Uint8Array([12, 5, 8, 1, 4]).some(isBiggerThan10); // true\n Arrow functions provide a shorter syntax for the same test.
new Uint8Array([2, 5, 8, 1, 4]).some(elem => elem > 10); // false\nnew Uint8Array([12, 5, 8, 1, 4]).some(elem => elem > 10); // true
Since there is no global object with the name TypedArray, polyfilling must be done on an \"as needed\" basis.
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.some\nif (!Uint8Array.prototype.some) {\n Object.defineProperty(Uint8Array.prototype, 'some', {\n value: Array.prototype.some\n });\n}\n If you need to support truly obsolete JavaScript engines that don't support Object.defineProperty, it's best not to polyfill Array.prototype methods at all, as you can't make them non-enumerable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.some' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.some' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n14 | \n37 | \nNo | \n32 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n37 | \nNo | \n10 | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/some\n
The map() method creates a new typed array with the results of calling a provided function on every element in this typed array. This method has the same algorithm as Array.prototype.map(). TypedArray is one of the typed array types here.
typedarray.map(callback[, thisArg])
callbackcurrentValueindexarraymap was called upon.thisArgthis when executing callback.A new typed array.
The map method calls a provided callback function once for each element in a typed array, in order, and constructs a new typed array from the results. callback is invoked only for indexes of the typed array which have assigned values; it is not invoked for indexes that are undefined, those which have been deleted or which have never been assigned values.
callback is invoked with three arguments: the value of the element, the index of the element, and the typed array object being traversed.
If a thisArg parameter is provided to map, it will be passed to callback when invoked, for use as its this value. Otherwise, the value undefined will be passed for use as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
map does not mutate the typed array on which it is called (although callback, if invoked, may do so).
The range of elements processed by map is set before the first invocation of callback. Elements which are appended to the array after the call to map begins will not be visited by callback. If existing elements of the typed array are changed, or deleted, their value as passed to callback will be the value at the time map visits them; elements that are deleted are not visited.
The following code takes a typed array and creates a new typed array containing the square roots of the numbers in the first typed array.
var numbers = new Uint8Array([1, 4, 9]);\nvar roots = numbers.map(Math.sqrt);\n// roots is now: Uint8Array [1, 2, 3], \n// numbers is still Uint8Array [1, 4, 9]\n
The following code shows how map works when a function requiring one argument is used with it. The argument will automatically be assigned to each element of the typed array as map loops through the original typed array.
var numbers = new Uint8Array([1, 4, 9]);\nvar doubles = numbers.map(function(num) {\n return num * 2;\n});\n// doubles is now Uint8Array [2, 8, 18]\n// numbers is still Uint8Array [1, 4, 9]\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.map' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.map' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n14 | \n38 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nYes | \nYes | \n38 | \nNo | \nNo | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/map\n
The values() method returns a new Array Iterator object that contains the values for each index in the array.
arr.values()
A new Array Iterator object.
for...of loopvar arr = new Uint8Array([10, 20, 30, 40, 50]);\nvar eArray = arr.values();\n// your browser must support for..of loop\n// and let-scoped variables in for loops\nfor (let n of eArray) {\n console.log(n);\n}\n var arr = new Uint8Array([10, 20, 30, 40, 50]);\nvar eArr = arr.values();\nconsole.log(eArr.next().value); // 10\nconsole.log(eArr.next().value); // 20\nconsole.log(eArr.next().value); // 30\nconsole.log(eArr.next().value); // 40\nconsole.log(eArr.next().value); // 50\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype.values()' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype.values()' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n14 | \n37 | \nNo | \n26 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n37 | \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
TypedArrayTypedArray.prototype.entries()TypedArray.prototype.keys()TypedArray.prototype[@@iterator]()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/values\n
The initial value of the @@iterator property is the same function object as the initial value of the values property.
arr[Symbol.iterator]()
The array iterator function, which is the values() function by default.
for...of loopvar arr = new Uint8Array([10, 20, 30, 40, 50]);\n// your browser must support for..of loop\n// and let-scoped variables in for loops\nfor (let n of arr) {\n console.log(n);\n}\n var arr = new Uint8Array([10, 20, 30, 40, 50]);\nvar eArr = arr[Symbol.iterator]();\nconsole.log(eArr.next().value); // 10\nconsole.log(eArr.next().value); // 20\nconsole.log(eArr.next().value); // 30\nconsole.log(eArr.next().value); // 40\nconsole.log(eArr.next().value); // 50\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '%TypedArray%.prototype[@@iterator]()' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '%TypedArray%.prototype[@@iterator]()' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n? | \n 36\n
| \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n? | \n 36\n
| \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
TypedArrayTypedArray.prototype.entries()TypedArray.prototype.keys()TypedArray.prototype.values()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/@@iterator\n
The Array.of() method creates a new Array instance with a variable number of arguments, regardless of number or type of the arguments.
The difference between Array.of() and the Array constructor is in the handling of integer arguments: Array.of(7) creates an array with a single element, 7, whereas Array(7) creates an empty array with a length property of 7 (Note: this implies an array of 7 empty slots, not slots with actual undefined values).
Array.of(7); // [7] \nArray.of(1, 2, 3); // [1, 2, 3]\n\nArray(7); // [ , , , , , , ]\nArray(1, 2, 3); // [1, 2, 3]\n
Array.of(element0[, element1[, ...[, elementN]]])
elementNA new Array instance.
This function is part of the ECMAScript 2015 standard. For more information see Array.of and Array.from proposal and Array.of polyfill.
Array.of(1); // [1]\nArray.of(1, 2, 3); // [1, 2, 3]\nArray.of(undefined); // [undefined]\n
Running the following code before any other code will create Array.of() if it's not natively available.
if (!Array.of) {\n Array.of = function() {\n return Array.prototype.slice.call(arguments);\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.of' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.of' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \nYes | \n25 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n39 | \nYes | \n25 | \nYes | \nYes | \n4.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n
The copyWithin() method shallow copies part of an array to another location in the same array and returns it, without modifying its size.
arr.copyWithin(target[, start[, end]])\n
targettarget will be counted from the end.target is at or greater than arr.length, nothing will be copied. If target is positioned after start, the copied sequence will be trimmed to fit arr.length.start Optional\nstart will be counted from the end.start is omitted, copyWithin will copy from the start (defaults to 0).end Optional\ncopyWithin copies up to but not including end. If negative, end will be counted from the end.end is omitted, copyWithin will copy until the end (default to arr.length).The modified array.
The copyWithin works like C and C++'s memmove, and is a high-performance method to shift the data of an Array. This especially applies to the TypedArray method of the same name. The sequence is copied and pasted as one operation; pasted sequence will have the copied values even when the copy and paste region overlap.
The copyWithin function is intentionally generic, it does not require that its this value be an Array object.
The copyWithin method is a mutable method. It does not alter the length of this, but will change its content and create new properties if necessary.
[1, 2, 3, 4, 5].copyWithin(-2);\n// [1, 2, 3, 1, 2]\n\n[1, 2, 3, 4, 5].copyWithin(0, 3);\n// [4, 5, 3, 4, 5]\n\n[1, 2, 3, 4, 5].copyWithin(0, 3, 4);\n// [4, 2, 3, 4, 5]\n\n[1, 2, 3, 4, 5].copyWithin(-2, -3, -1);\n// [1, 2, 3, 3, 4]\n\n[].copyWithin.call({length: 5, 3: 1}, 0, 3);\n// {0: 1, 3: 1, length: 5}\n\n// ES2015 Typed Arrays are subclasses of Array\nvar i32a = new Int32Array([1, 2, 3, 4, 5]);\n\ni32a.copyWithin(0, 2);\n// Int32Array [3, 4, 5, 4, 5]\n\n// On platforms that are not yet ES2015 compliant: \n[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);\n// Int32Array [4, 2, 3, 4, 5]\n if (!Array.prototype.copyWithin) {\n Array.prototype.copyWithin = function(target, start/*, end*/) {\n // Steps 1-2.\n if (this == null) {\n throw new TypeError('this is null or not defined');\n }\n\n var O = Object(this);\n\n // Steps 3-5.\n var len = O.length >>> 0;\n\n // Steps 6-8.\n var relativeTarget = target >> 0;\n\n var to = relativeTarget < 0 ?\n Math.max(len + relativeTarget, 0) :\n Math.min(relativeTarget, len);\n\n // Steps 9-11.\n var relativeStart = start >> 0;\n\n var from = relativeStart < 0 ?\n Math.max(len + relativeStart, 0) :\n Math.min(relativeStart, len);\n\n // Steps 12-14.\n var end = arguments[2];\n var relativeEnd = end === undefined ? len : end >> 0;\n\n var final = relativeEnd < 0 ?\n Math.max(len + relativeEnd, 0) :\n Math.min(relativeEnd, len);\n\n // Step 15.\n var count = Math.min(final - from, len - to);\n\n // Steps 16-17.\n var direction = 1;\n\n if (from < to && to < (from + count)) {\n direction = -1;\n from += count - 1;\n to += count - 1;\n }\n\n // Step 18.\n while (count > 0) {\n if (from in O) {\n O[to] = O[from];\n } else {\n delete O[to];\n }\n\n from += direction;\n to += direction;\n count--;\n }\n\n // Step 19.\n return O;\n };\n} | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \n12 | \n32 | \nNo | \n32 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n32 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/copyWithin\n
The entries() method returns a new Array Iterator object that contains the key/value pairs for each index in the array.
array.entries()
A new Array iterator object.
var a = ['a', 'b', 'c'];\nvar iterator = a.entries();\n\nfor (let e of iterator) {\n console.log(e);\n}\n// [0, 'a']\n// [1, 'b']\n// [2, 'c'] \n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.entries' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.entries' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n28 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n28 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Array.prototype.keys()Array.prototype.values()Array.prototype.forEach()Array.prototype.every()Array.prototype.some()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries\n
The fill() method fills all the elements of an array from a start index to an end index with a static value. The end index is not included.
arr.fill(value[, start[, end]])\n
valuestart Optional\nend Optional\nthis.length.The modified array.
The fill method takes up to three arguments value, start and end. The start and end arguments are optional with default values of 0 and the length of the this object.
If start is negative, it is treated as length+start where length is the length of the array. If end is negative, it is treated as length+end.
fill is intentionally generic, it does not require that its this value be an Array object.
fill is a mutable method, it will change this object itself, and return it, not just return a copy of it.
When fill gets passed an object, it will copy the reference and fill the array with references to that object.
[1, 2, 3].fill(4); // [4, 4, 4]\n[1, 2, 3].fill(4, 1); // [1, 4, 4]\n[1, 2, 3].fill(4, 1, 2); // [1, 4, 3]\n[1, 2, 3].fill(4, 1, 1); // [1, 2, 3]\n[1, 2, 3].fill(4, 3, 3); // [1, 2, 3]\n[1, 2, 3].fill(4, -3, -2); // [4, 2, 3]\n[1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3]\n[1, 2, 3].fill(4, 3, 5); // [1, 2, 3]\nArray(3).fill(4); // [4, 4, 4]\n[].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3}\n\n// Objects by reference.\nvar arr = Array(3).fill({}) // [{}, {}, {}];\narr[0].hi = \"hi\"; // [{ hi: \"hi\" }, { hi: \"hi\" }, { hi: \"hi\" }]\n if (!Array.prototype.fill) {\n Object.defineProperty(Array.prototype, 'fill', {\n value: function(value) {\n\n // Steps 1-2.\n if (this == null) {\n throw new TypeError('this is null or not defined');\n }\n\n var O = Object(this);\n\n // Steps 3-5.\n var len = O.length >>> 0;\n\n // Steps 6-7.\n var start = arguments[1];\n var relativeStart = start >> 0;\n\n // Step 8.\n var k = relativeStart < 0 ?\n Math.max(len + relativeStart, 0) :\n Math.min(relativeStart, len);\n\n // Steps 9-10.\n var end = arguments[2];\n var relativeEnd = end === undefined ?\n len : end >> 0;\n\n // Step 11.\n var final = relativeEnd < 0 ?\n Math.max(len + relativeEnd, 0) :\n Math.min(relativeEnd, len);\n\n // Step 12.\n while (k < final) {\n O[k] = value;\n k++;\n }\n\n // Step 13.\n return O;\n }\n });\n}\n If you need to support truly obsolete JavaScript engines that don't support Object.defineProperty, it's best not to polyfill Array.prototype methods at all, as you can't make them non-enumerable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.fill' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.fill' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \nYes | \n31 | \nNo | \nYes | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n31 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill\n
The filter() method creates a new array with all elements that pass the test implemented by the provided function.
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
callbacktrue to keep the element, false otherwise. It accepts three arguments:elementindexOptional\narrayOptional\nfilter was called upon.thisArgOptional\nthis when executing callback.A new array with the elements that pass the test. If no elements pass the test, an empty array will be returned.
filter() calls a provided callback function once for each element in an array, and constructs a new array of all the values for which callback returns a value that coerces to true. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values. Array elements which do not pass the callback test are simply skipped, and are not included in the new array.
callback is invoked with three arguments:
If a thisArg parameter is provided to filter, it will be used as the callback's this value. Otherwise, the value undefined will be used as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
filter() does not mutate the array on which it is called.
The range of elements processed by filter() is set before the first invocation of callback. Elements which are appended to the array after the call to filter() begins will not be visited by callback. If existing elements of the array are changed, or deleted, their value as passed to callback will be the value at the time filter() visits them; elements that are deleted are not visited.
The following example uses filter() to create a filtered array that has all elements with values less than 10 removed.
function isBigEnough(value) {\n return value >= 10;\n}\n\nvar filtered = [12, 5, 8, 130, 44].filter(isBigEnough);\n// filtered is [12, 130, 44]\n The following example uses filter() to create a filtered json of all elements with non-zero, numeric id.
var arr = [\n { id: 15 },\n { id: -1 },\n { id: 0 },\n { id: 3 },\n { id: 12.2 },\n { },\n { id: null },\n { id: NaN },\n { id: 'undefined' }\n];\n\nvar invalidEntries = 0;\n\nfunction isNumber(obj) {\n return obj !== undefined && typeof(obj) === 'number' && !isNaN(obj);\n}\n\nfunction filterByID(item) {\n if (isNumber(item.id) && item.id !== 0) {\n return true;\n } \n invalidEntries++;\n return false; \n}\n\nvar arrByID = arr.filter(filterByID);\n\nconsole.log('Filtered Array\\n', arrByID); \n// Filtered Array\n// [{ id: 15 }, { id: -1 }, { id: 3 }, { id: 12.2 }]\n\nconsole.log('Number of Invalid Entries = ', invalidEntries); \n// Number of Invalid Entries = 5\n Following example uses filter() to filter array content based on search criteria
var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];\n\n/**\n * Array filters items based on search criteria (query)\n */\nfunction filterItems(query) {\n return fruits.filter(function(el) {\n return el.toLowerCase().indexOf(query.toLowerCase()) > -1;\n })\n}\n\nconsole.log(filterItems('ap')); // ['apple', 'grapes']\nconsole.log(filterItems('an')); // ['banana', 'mango', 'orange'] const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];\n\n/**\n * Array filters items based on search criteria (query)\n */\nconst filterItems = (query) => {\n return fruits.filter((el) =>\n el.toLowerCase().indexOf(query.toLowerCase()) > -1\n );\n}\n\nconsole.log(filterItems('ap')); // ['apple', 'grapes']\nconsole.log(filterItems('an')); // ['banana', 'mango', 'orange']\n\n filter() was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of filter() in ECMA-262 implementations which do not natively support it. This algorithm is exactly equivalent to the one specified in ECMA-262, 5th edition, assuming that fn.call evaluates to the original value of Function.prototype.bind(), and that Array.prototype.push() has its original value.
if (!Array.prototype.filter){\n Array.prototype.filter = function(func, thisArg) {\n 'use strict';\n if ( ! ((typeof func === 'Function' || typeof func === 'function') && this) )\n throw new TypeError();\n \n var len = this.length >>> 0,\n res = new Array(len), // preallocate array\n t = this, c = 0, i = -1;\n if (thisArg === undefined){\n while (++i !== len){\n // checks to see if the key was set\n if (i in this){\n if (func(t[i], i, t)){\n res[c++] = t[i];\n }\n }\n }\n }\n else{\n while (++i !== len){\n // checks to see if the key was set\n if (i in this){\n if (func.call(thisArg, t[i], i, t)){\n res[c++] = t[i];\n }\n }\n }\n }\n \n res.length = c; // shrink down array to proper size\n return res;\n };\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.filter' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.filter' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.filter' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter\n
The find() method returns the value of the first element in the array that satisfies the provided testing function. Otherwise undefined is returned.
See also the findIndex() method, which returns the index of a found element in the array instead of its value.
If you need to find the position of an element or whether an element exists in an array, use Array.prototype.indexOf() or Array.prototype.includes().
arr.find(callback(element[, index[, array]])[, thisArg])
callbackelementindexOptional\narrayOptional\nfind was called upon.thisArg Optional\nthis when executing callback.The value of the first element in the array that satisfies the provided testing function; otherwise, undefined is returned.
The find method executes the callback function once for each index of the array until it finds one where callback returns a true value. If such an element is found, find immediately returns the value of that element. Otherwise, find returns undefined. callback is invoked for every index of the array from 0 to length - 1 and is invoked for all indexes, not just those that have been assigned values. This may mean that it's less efficient for sparse arrays than other methods that only visit indexes that have been assigned a value.
callback is invoked with three arguments: the value of the element, the index of the element, and the Array object being traversed.
If a thisArg parameter is provided to find, it will be used as the this for each invocation of the callback. If it is not provided, then undefined is used.
find does not mutate the array on which it is called.
The range of elements processed by find is set before the first invocation of callback. Elements that are appended to the array after the call to find begins will not be visited by callback. If an existing, unvisited element of the array is changed by callback, its value passed to the visiting callback will be the value at the time that find visits that element's index; elements that are deleted are still visited.
var inventory = [\n {name: 'apples', quantity: 2},\n {name: 'bananas', quantity: 0},\n {name: 'cherries', quantity: 5}\n];\n\nfunction isCherries(fruit) { \n return fruit.name === 'cherries';\n}\n\nconsole.log(inventory.find(isCherries)); \n// { name: 'cherries', quantity: 5 } const inventory = [\n {name: 'apples', quantity: 2},\n {name: 'bananas', quantity: 0},\n {name: 'cherries', quantity: 5}\n];\n\nconst result = inventory.find( fruit => fruit.name === 'cherries' );\n\nconsole.log(result) // { name: 'cherries', quantity: 5 } The following example finds an element in the array that is a prime number (or returns undefined if there is no prime number).
function isPrime(element, index, array) {\n var start = 2;\n while (start <= Math.sqrt(element)) {\n if (element % start++ < 1) {\n return false;\n }\n }\n return element > 1;\n}\n\nconsole.log([4, 6, 8, 12].find(isPrime)); // undefined, not found\nconsole.log([4, 5, 8, 12].find(isPrime)); // 5\n The following examples show that non-existent and deleted elements are visited and that the value passed to the callback is their value when visited.
// Declare array with no element at index 2, 3 and 4\nvar array = [0,1,,,,5,6];\n\n// Shows all indexes, not just those that have been assigned values\narray.find(function(value, index) {\n console.log('Visited index ' + index + ' with value ' + value); \n});\n\n// Shows all indexes, including deleted\narray.find(function(value, index) {\n\n // Delete element 5 on first iteration\n if (index == 0) {\n console.log('Deleting array[5] with value ' + array[5]);\n delete array[5];\n }\n // Element 5 is still visited even though deleted\n console.log('Visited index ' + index + ' with value ' + value); \n});\n// expected output:\n// Deleting array[5] with value 5 \n// Visited index 0 with value 0 \n// Visited index 1 with value 1 \n// Visited index 2 with value undefined \n// Visited index 3 with value undefined \n// Visited index 4 with value undefined \n// Visited index 5 with value undefined \n// Visited index 6 with value 6\n This method has been added to the ECMAScript 2015 specification and may not be available in all JavaScript implementations yet. However, you can polyfill Array.prototype.find with the following snippet:
// https://tc39.github.io/ecma262/#sec-array.prototype.find\nif (!Array.prototype.find) {\n Object.defineProperty(Array.prototype, 'find', {\n value: function(predicate) {\n // 1. Let O be ? ToObject(this value).\n if (this == null) {\n throw new TypeError('\"this\" is null or not defined');\n }\n\n var o = Object(this);\n\n // 2. Let len be ? ToLength(? Get(O, \"length\")).\n var len = o.length >>> 0;\n\n // 3. If IsCallable(predicate) is false, throw a TypeError exception.\n if (typeof predicate !== 'function') {\n throw new TypeError('predicate must be a function');\n }\n\n // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.\n var thisArg = arguments[1];\n\n // 5. Let k be 0.\n var k = 0;\n\n // 6. Repeat, while k < len\n while (k < len) {\n // a. Let Pk be ! ToString(k).\n // b. Let kValue be ? Get(O, Pk).\n // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).\n // d. If testResult is true, return kValue.\n var kValue = o[k];\n if (predicate.call(thisArg, kValue, k, o)) {\n return kValue;\n }\n // e. Increase k by 1.\n k++;\n }\n\n // 7. Return undefined.\n return undefined;\n },\n configurable: true,\n writable: true\n });\n}\n If you need to support truly obsolete JavaScript engines that don't support Object.defineProperty, it's best not to polyfill Array.prototype methods at all, as you can't make them non-enumerable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.find' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.find' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \nYes | \n25 | \nNo | \n32 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
Array.prototype.findIndex() – find and return an indexArray.prototype.includes() – test whether a value exists in the arrayArray.prototype.filter() – find all matching elementsArray.prototype.every() – test all elements together\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find\n
The keys() method returns a new Array Iterator object that contains the keys for each index in the array.
arr.keys()
A new Array iterator object.
var arr = ['a', , 'c'];\nvar sparseKeys = Object.keys(arr);\nvar denseKeys = [...arr.keys()];\nconsole.log(sparseKeys); // ['0', '2']\nconsole.log(denseKeys); // [0, 1, 2]\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.keys' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.keys' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n28 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n28 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/keys\n
The findIndex() method returns the index of the first element in the array that satisfies the provided testing function. Otherwise, it returns -1, indicating no element passed the test.
See also the find() method, which returns the value of an array element, instead of that element's index.
arr.findIndex(callback(element[, index[, array]])[, thisArg])
callbacktrue, indicating the desired element was found. It takes 3 arguments: elementindexOptional\narrayOptional\nfindIndex was called upon.thisArgOptional\nthis when executing callback.An index in the array if an element passes the test; otherwise, -1.
The findIndex method executes the callback function once for every array index 0..length-1 (inclusive) in the array until it finds one where callback returns a truthy value (a value that coerces to true).
If such an element is found, findIndex immediately returns that found element's index. If the callback never returns a truthy value or the array's length is 0, findIndex returns -1. Unlike some other array methods such as Array.some, in sparse arrays the callback is called even for indexes of entries not present in the array.
callback is invoked with 3 arguments:
If a thisArg parameter is passed to findIndex, it will be used as the this inside each invocation of the callback. If it is not provided, then undefined is used.
The range of elements processed by findIndex is set before the first invocation of callback. Elements appended to the array after the call to findIndex begins will not be processed by callback. If an existing, unvisited element of the array is changed by callback, its value passed to the callback will be the value at the time that findIndex visits that element's index; elements that are deleted are still visited.
The following example returns the index of an element in the array that is a prime number, or -1 if there is no prime number.
function isPrime(element, index, array) {\n var start = 2;\n while (start <= Math.sqrt(element)) {\n if (element % start < 1) {\n return false;\n } else {\n start++;\n }\n }\n return element > 1;\n}\n\nconsole.log([4, 6, 8, 12].findIndex(isPrime)); // -1, not found\nconsole.log([4, 6, 7, 12].findIndex(isPrime)); // 2 (array[2] is 7)\n The following example finds the index of a fruit using an arrow function:
const fruits = [\"apple\", \"banana\", \"cantaloupe\", \"blueberries\", \"grapefruit\"];\n\nconst index = fruits.findIndex(fruit => fruit === \"blueberries\");\n\nconsole.log(index); // 3\nconsole.log(fruits[index]); // blueberries\n
// https://tc39.github.io/ecma262/#sec-array.prototype.findindex\nif (!Array.prototype.findIndex) {\n Object.defineProperty(Array.prototype, 'findIndex', {\n value: function(predicate) {\n // 1. Let O be ? ToObject(this value).\n if (this == null) {\n throw new TypeError('\"this\" is null or not defined');\n }\n\n var o = Object(this);\n\n // 2. Let len be ? ToLength(? Get(O, \"length\")).\n var len = o.length >>> 0;\n\n // 3. If IsCallable(predicate) is false, throw a TypeError exception.\n if (typeof predicate !== 'function') {\n throw new TypeError('predicate must be a function');\n }\n\n // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.\n var thisArg = arguments[1];\n\n // 5. Let k be 0.\n var k = 0;\n\n // 6. Repeat, while k < len\n while (k < len) {\n // a. Let Pk be ! ToString(k).\n // b. Let kValue be ? Get(O, Pk).\n // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).\n // d. If testResult is true, return k.\n var kValue = o[k];\n if (predicate.call(thisArg, kValue, k, o)) {\n return k;\n }\n // e. Increase k by 1.\n k++;\n }\n\n // 7. Return -1.\n return -1;\n },\n configurable: true,\n writable: true\n });\n}\n If you need to support truly obsolete JavaScript engines that don't support Object.defineProperty, it's best not to polyfill Array.prototype methods at all, as you can't make them non-enumerable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.findIndex' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.findIndex' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \nYes | \n25 | \nNo | \n32 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex\n
The toLocaleString() method returns a string representing the elements of the typed array. The elements are converted to strings and are separated by a locale-specific string (such as a comma “,”). This method has the same algorithm as Array.prototype.toLocaleString() and, as the typed array elements are numbers, the same algorithm as Number.prototype.toLocaleString() applies for each element. TypedArray is one of the typed array types here.
typedarray.toLocaleString([locales [, options]]);
localesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page. The following Unicode extension key is allowed:
nu\"arab\", \"arabext\", \"bali\", \"beng\", \"deva\", \"fullwide\", \"gujr\", \"guru\", \"hanidec\", \"khmr\", \"knda\", \"laoo\", \"latn\", \"limb\", \"mlym\", \"mong\", \"mymr\", \"orya\", \"tamldec\", \"telu\", \"thai\", \"tibt\".optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.style\"decimal\" for plain number formatting, \"currency\" for currency formatting, and \"percent\" for percent formatting; the default is \"decimal\".currency\"USD\" for the US dollar, \"EUR\" for the euro, or \"CNY\" for the Chinese RMB — see the Current currency & funds code list. There is no default value; if the style is \"currency\", the currency property must be provided.currencyDisplay\"symbol\" to use a localized currency symbol such as €, \"code\" to use the ISO currency code, \"name\" to use a localized currency name such as \"dollar\"; the default is \"symbol\".useGroupingtrue and false; the default is true.The following properties fall into two groups: minimumIntegerDigits, minimumFractionDigits, and maximumFractionDigits in one group, minimumSignificantDigits and maximumSignificantDigits in the other. If at least one property from the second group is defined, then the first group is ignored.
minimumIntegerDigitsminimumFractionDigitsmaximumFractionDigitsminimumFractionDigits and 3; the default for currency formatting is the larger of minimumFractionDigits and the number of minor unit digits provided by the ISO 4217 currency code list (2 if the list doesn't provide that information); the default for percent formatting is the larger of minimumFractionDigits and 0.minimumSignificantDigitsmaximumSignificantDigitsA string representing the elements of the typed array.
toLocaleString\nvar uint = new Uint32Array([2000, 500, 8123, 12, 4212]);\n\nuint.toLocaleString(); \n// if run in a de-DE locale\n// \"2.000,500,8.123,12,4.212\"\n\nuint.toLocaleString('en-US');\n// \"2,000,500,8,123,12,4,212\"\n\nuint.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' });\n// \"￥2,000,￥500,￥8,123,￥12,￥4,212\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'TypedArray.prototype.toLocaleString' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'TypedArray.prototype.toLocaleString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \n? | \n51 | \n10 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n? | \n51 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/toLocaleString\n
The every() method tests whether all elements in the array pass the test implemented by the provided function.
Note: This method returns true for any condition put on an empty array.
arr.every(callback(element[, index[, array]])[, thisArg])
callbackelementindexOptional\narrayOptional\nevery was called upon.thisArgOptional\nthis when executing callback.true if the callback function returns a truthy value for every array element; otherwise, false.
The every method executes the provided callback function once for each element present in the array until it finds one where callback returns a falsy value. If such an element is found, the every method immediately returns false. Otherwise, if callback returns a truthy value for all elements, every returns true. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.
callback is invoked with three arguments: the value of the element, the index of the element, and the Array object being traversed.
If a thisArg parameter is provided to every, it will be used as callback's this value. Otherwise, the value undefined will be used as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
every does not mutate the array on which it is called.
The range of elements processed by every is set before the first invocation of callback. Elements which are appended to the array after the call to every begins will not be visited by callback. If existing elements of the array are changed, their value as passed to callback will be the value at the time every visits them; elements that are deleted are not visited.
every acts like the \"for all\" quantifier in mathematics. In particular, for an empty array, it returns true. (It is vacuously true that all elements of the empty set satisfy any given condition.)
The following example tests whether all elements in the array are bigger than 10.
function isBigEnough(element, index, array) {\n return element >= 10;\n}\n[12, 5, 8, 130, 44].every(isBigEnough); // false\n[12, 54, 18, 130, 44].every(isBigEnough); // true\n [{a:1, b:2, c:3, d:4}, {a:1, x:2, y:3, z:4}, {a:1, x:2, y:3, z:4}].every(obj => obj.a === 1); //true\n[{a:1, b:2, c:3, d:4}, {a:1, x:2, y:3, z:4}, {a:2, x:2, y:3, z:4}].every(obj => obj.a === 1); //false Arrow functions provide a shorter syntax for the same test.
[12, 5, 8, 130, 44].every(x => x >= 10); // false\n[12, 54, 18, 130, 44].every(x => x >= 10); // true
every was added to the ECMA-262 standard in the 5th edition; as such it may not be present in other implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of every in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming Object and TypeError have their original values and that callbackfn.call evaluates to the original value of Function.prototype.call
if (!Array.prototype.every) {\n Array.prototype.every = function(callbackfn, thisArg) {\n 'use strict';\n var T, k;\n\n if (this == null) {\n throw new TypeError('this is null or not defined');\n }\n\n // 1. Let O be the result of calling ToObject passing the this \n // value as the argument.\n var O = Object(this);\n\n // 2. Let lenValue be the result of calling the Get internal method\n // of O with the argument \"length\".\n // 3. Let len be ToUint32(lenValue).\n var len = O.length >>> 0;\n\n // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.\n if (typeof callbackfn !== 'function') {\n throw new TypeError();\n }\n\n // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.\n if (arguments.length > 1) {\n T = thisArg;\n }\n\n // 6. Let k be 0.\n k = 0;\n\n // 7. Repeat, while k < len\n while (k < len) {\n\n var kValue;\n\n // a. Let Pk be ToString(k).\n // This is implicit for LHS operands of the in operator\n // b. Let kPresent be the result of calling the HasProperty internal \n // method of O with argument Pk.\n // This step can be combined with c\n // c. If kPresent is true, then\n if (k in O) {\n\n // i. Let kValue be the result of calling the Get internal method\n // of O with argument Pk.\n kValue = O[k];\n\n // ii. Let testResult be the result of calling the Call internal method\n // of callbackfn with T as the this value and argument list \n // containing kValue, k, and O.\n var testResult = callbackfn.call(T, kValue, k, O);\n\n // iii. If ToBoolean(testResult) is false, return false.\n if (!testResult) {\n return false;\n }\n }\n k++;\n }\n return true;\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.every' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.every' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.every' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every\n
The includes() method determines whether an array includes a certain element, returning true or false as appropriate.
arr.includes(searchElement[, fromIndex])\n
searchElementfromIndex Optional\nsearchElement. A negative value searches from the index of array.length - fromIndex by asc. Defaults to 0.A Boolean which is true if the value searchElement is found within the array (or the part of the array beginning at the index fromIndex, if specified). Values of zero are all considered to be equal regardless of sign (that is, -0 is considered to be equal to both 0 and +0), but false is not considered to be the same as 0.
Note: Technically speaking, includes() uses the sameValueZero algorithm to determine whether the given element is found.
[1, 2, 3].includes(2); // true\n[1, 2, 3].includes(4); // false\n[1, 2, 3].includes(3, 3); // false\n[1, 2, 3].includes(3, -1); // true\n[1, 2, NaN].includes(NaN); // true\n
fromIndex is greater than or equal to the array lengthIf fromIndex is greater than or equal to the length of the array, false is returned. The array will not be searched.
var arr = ['a', 'b', 'c'];\n\narr.includes('c', 3); // false\narr.includes('c', 100); // false If fromIndex is negative, the computed index is calculated to be used as a position in the array at which to begin searching for searchElement. If the computed index is less or equal than -1 * array.length, the entire array will be searched.
// array length is 3\n// fromIndex is -100\n// computed index is 3 + (-100) = -97\n\nvar arr = ['a', 'b', 'c'];\n\narr.includes('a', -100); // true\narr.includes('b', -100); // true\narr.includes('c', -100); // true\narr.includes('a', -2); // false includes() used as a generic methodincludes() method is intentionally generic. It does not require this value to be an Array object, so it can be applied to other kinds of objects (e.g. array-like objects). The example below illustrates includes() method called on the function's arguments object.
(function() {\n console.log([].includes.call(arguments, 'a')); // true\n console.log([].includes.call(arguments, 'd')); // false\n})('a','b','c'); // https://tc39.github.io/ecma262/#sec-array.prototype.includes\nif (!Array.prototype.includes) {\n Object.defineProperty(Array.prototype, 'includes', {\n value: function(searchElement, fromIndex) {\n\n if (this == null) {\n throw new TypeError('\"this\" is null or not defined');\n }\n\n // 1. Let O be ? ToObject(this value).\n var o = Object(this);\n\n // 2. Let len be ? ToLength(? Get(O, \"length\")).\n var len = o.length >>> 0;\n\n // 3. If len is 0, return false.\n if (len === 0) {\n return false;\n }\n\n // 4. Let n be ? ToInteger(fromIndex).\n // (If fromIndex is undefined, this step produces the value 0.)\n var n = fromIndex | 0;\n\n // 5. If n ≥ 0, then\n // a. Let k be n.\n // 6. Else n < 0,\n // a. Let k be len + n.\n // b. If k < 0, let k be 0.\n var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);\n\n function sameValueZero(x, y) {\n return x === y || (typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y));\n }\n\n // 7. Repeat, while k < len\n while (k < len) {\n // a. Let elementK be the result of ? Get(O, ! ToString(k)).\n // b. If SameValueZero(searchElement, elementK) is true, return true.\n if (sameValueZero(o[k], searchElement)) {\n return true;\n }\n // c. Increase k by 1. \n k++;\n }\n\n // 8. Return false\n return false;\n }\n });\n}\n If you need to support truly obsolete JavaScript engines that don't support Object.defineProperty(), it's best not to polyfill Array.prototype methods at all, as you can't make them non-enumerable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2016 (ECMA-262) The definition of 'Array.prototype.includes' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.includes' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n47 | \n14 | \n43 | \nNo | \n34 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n14 | \n43 | \n34 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.0.0\n
| \n
TypedArray.prototype.includes()String.prototype.includes()Array.prototype.indexOf()Array.prototype.find()Array.prototype.findIndex()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes\n
The join() method creates and returns a new string by concatenating all of the elements in an array (or an array-like object), separated by commas or a specified separator string.
arr.join([separator])
separator Optional\nseparator is an empty string, all elements are joined without any characters in between them.A string with all array elements joined. If arr.length is 0, the empty string is returned.
The string conversions of all array elements are joined into one string.
If an element is undefined or null, it is converted to the empty string.
The following example creates an array, a, with three elements, then joins the array four times: using the default separator, then a comma and a space, then a plus and an empty string.
var a = ['Wind', 'Rain', 'Fire'];\na.join(); // 'Wind,Rain,Fire'\na.join(', '); // 'Wind, Rain, Fire'\na.join(' + '); // 'Wind + Rain + Fire'\na.join(''); // 'WindRainFire' The following example joins array-like object (arguments), by calling Function.prototype.call on Array.prototype.join.
function f(a, b, c) {\n var s = Array.prototype.join.call(arguments);\n console.log(s); // '\n}\nf(1, 'a', true);\n//expected output: \"1,a,true\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.join' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.join' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.join' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join\n
The Array.from() method creates a new, shallow-copied Array instance from an array-like or iterable object.
Array.from(arrayLike[, mapFn[, thisArg]])\n
arrayLikemapFnOptional\nthisArgOptional\nthis when executing mapFn.A new Array instance.
Array.from() lets you create Arrays from:
length property and indexed elements) orMap and Set).Array.from() has an optional parameter mapFn, which allows you to execute a map function on each element of the array (or subclass object) that is being created. More clearly, Array.from(obj, mapFn, thisArg) has the same result as Array.from(obj).map(mapFn, thisArg), except that it does not create an intermediate array. This is especially important for certain array subclasses, like typed arrays, since the intermediate array would necessarily have values truncated to fit into the appropriate type.
The length property of the from() method is 1.
In ES2015, the class syntax allows for sub-classing of both built-in and user defined classes; as a result, static methods such as Array.from are \"inherited\" by subclasses of Array and create new instances of the subclass, not Array.
String\nArray.from('foo'); \n// [\"f\", \"o\", \"o\"] Set\nvar s = new Set(['foo', window]); \nArray.from(s); \n// [\"foo\", window]
Map\nvar m = new Map([[1, 2], [2, 4], [4, 8]]);\nArray.from(m);\n// [[1, 2], [2, 4], [4, 8]]\n\nvar mapper = new Map([['1', 'a'], ['2', 'b']]);\nArray.from(mapper.values());\n// ['a', 'b'];\n\nArray.from(mapper.keys());\n// ['1', '2'];\n
function f() {\n return Array.from(arguments);\n}\n\nf(1, 2, 3);\n\n// [1, 2, 3] Array.from\n// Using an arrow function as the map function to\n// manipulate the elements\nArray.from([1, 2, 3], x => x + x); \n// [2, 4, 6]\n\n\n// Generate a sequence of numbers\n// Since the array is initialized with `undefined` on each position,\n// the value of `v` below will be `undefined`\nArray.from({length: 5}, (v, i) => i);\n// [0, 1, 2, 3, 4]\n // Sequence generator function (commonly referred to as \"range\", e.g. Clojure, PHP etc)\nconst range = (start, stop, step) => Array.from({ length: (stop - start) / step }, (_, i) => start + (i * step));\n\n// Generate numbers range 0..4\nrange(0, 5, 1);\n// [0, 1, 2, 3, 4]\n\n// Generate the alphabet using Array.from making use of it being ordered as a sequence\nrange('A'.charCodeAt(0), 'Z'.charCodeAt(0) + 1, 1).map(x => String.fromCharCode(x));\n// [\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\", \"H\", \"I\", \"J\", \"K\", \"L\", \"M\", \"N\", \"O\", \"P\", \"Q\", \"R\", \"S\", \"T\", \"U\", \"V\", \"W\", \"X\", \"Y\", \"Z\"]\n Array.from was added to the ECMA-262 standard in the 6th edition (ES2015); as such it may not be present in other implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of Array.from in implementations that don't natively support it. This algorithm is exactly the one specified in ECMA-262, 6th edition, assuming Object and TypeError have their original values and that callback.call evaluates to the original value of Function.prototype.call. In addition, since true iterables can not be polyfilled, this implementation does not support generic iterables as defined in the 6th edition of ECMA-262.
// Production steps of ECMA-262, Edition 6, 22.1.2.1\nif (!Array.from) {\n Array.from = (function () {\n var toStr = Object.prototype.toString;\n var isCallable = function (fn) {\n return typeof fn === 'function' || toStr.call(fn) === '[object Function]';\n };\n var toInteger = function (value) {\n var number = Number(value);\n if (isNaN(number)) { return 0; }\n if (number === 0 || !isFinite(number)) { return number; }\n return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));\n };\n\n var toLength = function (value) {\n var len = toInteger(value);\n return len >>> 0;\n };\n\n // The length property of the from method is 1.\n return function from(arrayLike/*, mapFn, thisArg */) {\n // 1. Let C be the this value.\n var C = this;\n\n // 2. Let items be ToObject(arrayLike).\n var items = Object(arrayLike);\n\n // 3. ReturnIfAbrupt(items).\n if (arrayLike == null) {\n throw new TypeError('Array.from requires an array-like object - not null or undefined');\n }\n\n // 4. If mapfn is undefined, then let mapping be false.\n var mapFn = arguments.length > 1 ? arguments[1] : void undefined;\n var T;\n if (typeof mapFn !== 'undefined') {\n // 5. else\n // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.\n if (!isCallable(mapFn)) {\n throw new TypeError('Array.from: when provided, the second argument must be a function');\n }\n\n // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.\n if (arguments.length > 2) {\n T = arguments[2];\n }\n }\n\n // 10. Let lenValue be Get(items, \"length\").\n // 11. Let len be ToLength(lenValue).\n var len = toLength(items.length);\n\n // 13. If IsConstructor(C) is true, then\n // 13. a. Let A be the result of calling the [[Construct]] internal method \n // of C with an argument list containing the single item len.\n // 14. a. Else, Let A be ArrayCreate(len).\n var A = isCallable(C) ? Object(new C(len)) : new Array(len);\n\n // 16. Let k be 0.\n var k = 0;\n // 17. Repeat, while k < len… (also steps a - h)\n var kValue;\n while (k < len) {\n kValue = items[k];\n if (mapFn) {\n A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);\n } else {\n A[k] = kValue;\n }\n k += 1;\n }\n // 18. Let putStatus be Put(A, \"length\", len, true).\n A.length = len;\n // 20. Return A.\n return A;\n };\n }());\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.from' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.from' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \nYes | \n32 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \nYes | \nYes | \n32 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from\n
The forEach() method executes a provided function once for each array element.
arr.forEach(function callback(currentValue[, index[, array]]) {\n //your iterator\n}[, thisArg]); callbackcurrentValueindexOptional\narrayOptional\nforEach() is being applied to.thisArg Optional\nValue to use as this (i.e the reference Object) when executing callback.
forEach() executes the provided callback once for each element present in the array in ascending order. It is not invoked for index properties that have been deleted or are uninitialized (i.e. on sparse arrays).
callback is invoked with three arguments:
If a thisArg parameter is provided to forEach(), it will be used as callback's this value. Otherwise, the value undefined will be used as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
The range of elements processed by forEach() is set before the first invocation of callback. Elements that are appended to the array after the call to forEach() begins will not be visited by callback. If the values of existing elements of the array are changed, the value passed to callback will be the value at the time forEach() visits them; elements that are deleted before being visited are not visited. If elements that are already visited are removed (e.g. using shift()) during the iteration, later elements will be skipped - see example below.
forEach() executes the callback function once for each array element; unlike map() or reduce() it always returns the value undefined and is not chainable. The typical use case is to execute side effects at the end of a chain.
forEach() does not mutate the array on which it is called (although callback, if invoked, may do so).
There is no way to stop or break a forEach() loop other than by throwing an exception. If you need such behavior, the forEach() method is the wrong tool.
Early termination may be accomplished with:
Array.prototype.every()Array.prototype.some()Array.prototype.find()Array.prototype.findIndex()The other Array methods: every(), some(), find(), and findIndex() test the array elements with a predicate returning a truthy value to determine if further iteration is required.
before
const items = ['item1', 'item2', 'item3'];\nconst copy = [];\n\nfor (let i=0; i<items.length; i++) {\n copy.push(items[i])\n}\n after
const items = ['item1', 'item2', 'item3'];\nconst copy = [];\n\nitems.forEach(function(item){\n copy.push(item)\n});\n\n The following code logs a line for each element in an array:
function logArrayElements(element, index, array) {\n console.log('a[' + index + '] = ' + element);\n}\n\n// Notice that index 2 is skipped since there is no item at\n// that position in the array.\n[2, 5, , 9].forEach(logArrayElements);\n// logs:\n// a[0] = 2\n// a[1] = 5\n// a[3] = 9\n thisArg\nThe following (contrived) example updates an object's properties from each entry in the array:
function Counter() {\n this.sum = 0;\n this.count = 0;\n}\nCounter.prototype.add = function(array) {\n array.forEach(function(entry) {\n this.sum += entry;\n ++this.count;\n }, this);\n // ^---- Note\n};\n\nconst obj = new Counter();\nobj.add([2, 5, 9]);\nobj.count;\n// 3 \nobj.sum;\n// 16\n Since the thisArg parameter (this) is provided to forEach(), it is passed to callback each time it's invoked, for use as its this value.
If passing the function argument using an arrow function expression the thisArg parameter can be omitted as arrow functions lexically bind the this value.
The following code creates a copy of a given object. There are different ways to create a copy of an object; the following is just one way and is presented to explain how Array.prototype.forEach() works by using ECMAScript 5 Object.* meta property functions.
function copy(obj) {\n const copy = Object.create(Object.getPrototypeOf(obj));\n const propNames = Object.getOwnPropertyNames(obj);\n\n propNames.forEach(function(name) {\n const desc = Object.getOwnPropertyDescriptor(obj, name);\n Object.defineProperty(copy, name, desc);\n });\n\n return copy;\n}\n\nconst obj1 = { a: 1, b: 2 };\nconst obj2 = copy(obj1); // obj2 looks like obj1 now\n The following example logs \"one\", \"two\", \"four\". When the entry containing the value \"two\" is reached, the first entry of the whole array is shifted off, which results in all remaining entries moving up one position. Because element \"four\" is now at an earlier position in the array, \"three\" will be skipped. forEach() does not make a copy of the array before iterating.
var words = ['one', 'two', 'three', 'four'];\nwords.forEach(function(word) {\n console.log(word);\n if (word === 'two') {\n words.shift();\n }\n});\n// one\n// two\n// four\n forEach() was added to the ECMA-262 standard in the 5th edition; as such it may not be present in other implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of forEach() in implementations that don't natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming Object and TypeError have their original values and that callback.call() evaluates to the original value of Function.prototype.call().
// Production steps of ECMA-262, Edition 5, 15.4.4.18\n// Reference: http://es5.github.io/#x15.4.4.18\nif (!Array.prototype.forEach) {\n\n Array.prototype.forEach = function(callback/*, thisArg*/) {\n\n var T, k;\n\n if (this == null) {\n throw new TypeError('this is null or not defined');\n }\n\n // 1. Let O be the result of calling toObject() passing the\n // |this| value as the argument.\n var O = Object(this);\n\n // 2. Let lenValue be the result of calling the Get() internal\n // method of O with the argument \"length\".\n // 3. Let len be toUint32(lenValue).\n var len = O.length >>> 0;\n\n // 4. If isCallable(callback) is false, throw a TypeError exception. \n // See: http://es5.github.com/#x9.11\n if (typeof callback !== 'function') {\n throw new TypeError(callback + ' is not a function');\n }\n\n // 5. If thisArg was supplied, let T be thisArg; else let\n // T be undefined.\n if (arguments.length > 1) {\n T = arguments[1];\n }\n\n // 6. Let k be 0.\n k = 0;\n\n // 7. Repeat while k < len.\n while (k < len) {\n\n var kValue;\n\n // a. Let Pk be ToString(k).\n // This is implicit for LHS operands of the in operator.\n // b. Let kPresent be the result of calling the HasProperty\n // internal method of O with argument Pk.\n // This step can be combined with c.\n // c. If kPresent is true, then\n if (k in O) {\n\n // i. Let kValue be the result of calling the Get internal\n // method of O with argument Pk.\n kValue = O[k];\n\n // ii. Call the Call internal method of callback with T as\n // the this value and argument list containing kValue, k, and O.\n callback.call(T, kValue, k, O);\n }\n // d. Increase k by 1.\n k++;\n }\n // 8. return undefined.\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.forEach' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.forEach' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.forEach' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Array.prototype.find()Array.prototype.findIndex()Array.prototype.map()Array.prototype.every()Array.prototype.some()Map.prototype.forEach()Set.prototype.forEach()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach\n
The indexOf() method returns the first index at which a given element can be found in the array, or -1 if it is not present.
Note: For the String method, see String.prototype.indexOf().
arr.indexOf(searchElement[, fromIndex])
searchElementfromIndex Optional\nThe first index of the element in the array; -1 if not found.
indexOf() compares searchElement to elements of the Array using strict equality (the same method used by the === or triple-equals operator).
indexOf()\nThe following example uses indexOf() to locate values in an array.
var array = [2, 9, 9];\narray.indexOf(2); // 0\narray.indexOf(7); // -1\narray.indexOf(9, 2); // 2\narray.indexOf(2, -1); // -1\narray.indexOf(2, -3); // 0\n
var indices = [];\nvar array = ['a', 'b', 'a', 'c', 'a', 'd'];\nvar element = 'a';\nvar idx = array.indexOf(element);\nwhile (idx != -1) {\n indices.push(idx);\n idx = array.indexOf(element, idx + 1);\n}\nconsole.log(indices);\n// [0, 2, 4]\n function updateVegetablesCollection (veggies, veggie) {\n if (veggies.indexOf(veggie) === -1) {\n veggies.push(veggie);\n console.log('New veggies collection is : ' + veggies);\n } else if (veggies.indexOf(veggie) > -1) {\n console.log(veggie + ' already exists in the veggies collection.');\n }\n}\n\nvar veggies = ['potato', 'tomato', 'chillies', 'green-pepper'];\n\nupdateVegetablesCollection(veggies, 'spinach'); \n// New veggies collection is : potato,tomato,chillies,green-pepper,spinach\nupdateVegetablesCollection(veggies, 'spinach'); \n// spinach already exists in the veggies collection.\n indexOf() was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all browsers. You can work around this by utilizing the following code at the beginning of your scripts. This will allow you to use indexOf() when there is still no native support. This algorithm matches the one specified in ECMA-262, 5th edition, assuming TypeError and Math.abs() have their original values.
if (!Array.prototype.indexOf) Array.prototype.indexOf = (function(Object, max, min){\n \"use strict\";\n return function indexOf(member, fromIndex) {\n if(this===null||this===undefined)throw TypeError(\"Array.prototype.indexOf called on null or undefined\");\n \n var that = Object(this), Len = that.length >>> 0, i = min(fromIndex | 0, Len);\n if (i < 0) i = max(0, Len+i); else if (i >= Len) return -1;\n \n if(member===void 0){ for(; i !== Len; ++i) if(that[i]===void 0 && i in that) return i; // undefined\n }else if(member !== member){ for(; i !== Len; ++i) if(that[i] !== that[i]) return i; // NaN\n }else for(; i !== Len; ++i) if(that[i] === member) return i; // all else\n\n return -1; // if the value was not found, then return -1\n };\n})(Object, Math.max, Math.min);\n However, if you are more interested in all the little technical bits defined by the ECMA standard, and are less concerned about performance or conciseness, then you may find this more descriptive polyfill to be more useful.
// Production steps of ECMA-262, Edition 5, 15.4.4.14\n// Reference: http://es5.github.io/#x15.4.4.14\nif (!Array.prototype.indexOf) {\n Array.prototype.indexOf = function(searchElement, fromIndex) {\n\n var k;\n\n // 1. Let o be the result of calling ToObject passing\n // the this value as the argument.\n if (this == null) {\n throw new TypeError('\"this\" is null or not defined');\n }\n\n var o = Object(this);\n\n // 2. Let lenValue be the result of calling the Get\n // internal method of o with the argument \"length\".\n // 3. Let len be ToUint32(lenValue).\n var len = o.length >>> 0;\n\n // 4. If len is 0, return -1.\n if (len === 0) {\n return -1;\n }\n\n // 5. If argument fromIndex was passed let n be\n // ToInteger(fromIndex); else let n be 0.\n var n = fromIndex | 0;\n\n // 6. If n >= len, return -1.\n if (n >= len) {\n return -1;\n }\n\n // 7. If n >= 0, then Let k be n.\n // 8. Else, n<0, Let k be len - abs(n).\n // If k is less than 0, then let k be 0.\n k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);\n\n // 9. Repeat, while k < len\n while (k < len) {\n // a. Let Pk be ToString(k).\n // This is implicit for LHS operands of the in operator\n // b. Let kPresent be the result of calling the\n // HasProperty internal method of o with argument Pk.\n // This step can be combined with c\n // c. If kPresent is true, then\n // i. Let elementK be the result of calling the Get\n // internal method of o with the argument ToString(k).\n // ii. Let same be the result of applying the\n // Strict Equality Comparison Algorithm to\n // searchElement and elementK.\n // iii. If same is true, return k.\n if (k in o && o[k] === searchElement) {\n return k;\n }\n k++;\n }\n return -1;\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.indexOf' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.indexOf' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.indexOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
-0. For example, [0].indexOf(0, -0) will now always return +0 (bug 1242043).\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf\n
The some() method tests whether at least one element in the array passes the test implemented by the provided function.
Note: This method returns false for any condition put on an empty array.
arr.some(callback(element[, index[, array]])[, thisArg])
callbackelementindex Optional\narrayOptional\nsome() was called upon.thisArgOptional\nthis when executing callback.true if the callback function returns a truthy value for any array element; otherwise, false.
some() executes the callback function once for each element present in the array until it finds one where callback returns a truthy value (a value that becomes true when converted to a Boolean). If such an element is found, some() immediately returns true. Otherwise, some() returns false. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.
callback is invoked with three arguments: the value of the element, the index of the element, and the array object being traversed.
If a thisArg parameter is provided to some(), it will be used as callbacks' this value. Otherwise, the value undefined will be used as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
some() does not mutate the array on which it is called.
The range of elements processed by some() is set before the first invocation of callback. Elements that are appended to the array after the call to some() begins will not be visited by callback. If an existing, unvisited element of the array is changed by callback, its value passed to the visiting callback will be the value at the time that some() visits that element's index; elements that are deleted are not visited.
The following example tests whether any element in the array is bigger than 10.
function isBiggerThan10(element, index, array) {\n return element > 10;\n}\n\n[2, 5, 8, 1, 4].some(isBiggerThan10); // false\n[12, 5, 8, 1, 4].some(isBiggerThan10); // true\n Arrow functions provide a shorter syntax for the same test.
[2, 5, 8, 1, 4].some(x => x > 10); // false\n[12, 5, 8, 1, 4].some(x => x > 10); // true\n
To mimic the function of the includes() method, this custom function returns true if the element exists in the array:
var fruits = ['apple', 'banana', 'mango', 'guava'];\n\nfunction checkAvailability(arr, val) {\n return arr.some(function(arrVal) {\n return val === arrVal;\n });\n}\n\ncheckAvailability(fruits, 'kela'); // false\ncheckAvailability(fruits, 'banana'); // true var fruits = ['apple', 'banana', 'mango', 'guava'];\n\nfunction checkAvailability(arr, val) {\n return arr.some(arrVal => val === arrVal);\n}\n\ncheckAvailability(fruits, 'kela'); // false\ncheckAvailability(fruits, 'banana'); // true var TRUTHY_VALUES = [true, 'true', 1];\n\nfunction getBoolean(value) {\n 'use strict';\n \n if (typeof value === 'string') { \n value = value.toLowerCase().trim();\n }\n\n return TRUTHY_VALUES.some(function(t) {\n return t === value;\n });\n}\n\ngetBoolean(false); // false\ngetBoolean('false'); // false\ngetBoolean(1); // true\ngetBoolean('true'); // true some() was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of some() in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming Object and TypeError have their original values and that fun.call evaluates to the original value of Function.prototype.call().
// Production steps of ECMA-262, Edition 5, 15.4.4.17\n// Reference: http://es5.github.io/#x15.4.4.17\nif (!Array.prototype.some) {\n Array.prototype.some = function(fun, thisArg) {\n 'use strict';\n\n if (this == null) {\n throw new TypeError('Array.prototype.some called on null or undefined');\n }\n\n if (typeof fun !== 'function') {\n throw new TypeError();\n }\n\n var t = Object(this);\n var len = t.length >>> 0;\n\n for (var i = 0; i < len; i++) {\n if (i in t && fun.call(thisArg, t[i], i, t)) {\n return true;\n }\n }\n\n return false;\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.some' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.some' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.some' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Array.prototype.find()Array.prototype.forEach()Array.prototype.every()TypedArray.prototype.some()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some\n
The Intl.getCanonicalLocales() method returns an array containing the canonical locale names. Duplicates will be omitted and elements will be validated as structurally valid language tags.
Intl.getCanonicalLocales(locales)
localesString values for which to get the canonical locale names.An array containing the canonical locale names.
Intl.getCanonicalLocales('EN-US'); // [\"en-US\"]\nIntl.getCanonicalLocales(['EN-US', 'Fr']); // [\"en-US\", \"fr\"]\n\nIntl.getCanonicalLocales('EN_US'); \n// RangeError:'EN_US' is not a structurally valid language tag\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Internationalization API 4.0 (ECMA-402) The definition of 'Intl.getCanonicalLocales' in that specification. | Draft | Initial definition |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n54 | \n16 | \n48 | \nNo | \nNo | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nNo | \nNo | \n56 | \nNo | \n11 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
Intl.NumberFormat.supportedLocalesOf()Intl.DateTimeFormat.supportedLocalesOf()Intl.Collator.supportedLocalesOf()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales\n
The lastIndexOf() method returns the last index at which a given element can be found in the array, or -1 if it is not present. The array is searched backwards, starting at fromIndex.
arr.lastIndexOf(searchElement)\narr.lastIndexOf(searchElement, fromIndex)\n
searchElementfromIndex Optional\narr.length - 1), i.e. the whole array will be searched. If the index is greater than or equal to the length of the array, the whole array will be searched. If negative, it is taken as the offset from the end of the array. Note that even when the index is negative, the array is still searched from back to front. If the calculated index is less than 0, -1 is returned, i.e. the array will not be searched.The last index of the element in the array; -1 if not found.
lastIndexOf compares searchElement to elements of the Array using strict equality (the same method used by the ===, or triple-equals, operator).
lastIndexOf\nThe following example uses lastIndexOf to locate values in an array.
var numbers = [2, 5, 9, 2];\nnumbers.lastIndexOf(2); // 3\nnumbers.lastIndexOf(7); // -1\nnumbers.lastIndexOf(2, 3); // 3\nnumbers.lastIndexOf(2, 2); // 0\nnumbers.lastIndexOf(2, -2); // 0\nnumbers.lastIndexOf(2, -1); // 3\n
The following example uses lastIndexOf to find all the indices of an element in a given array, using push to add them to another array as they are found.
var indices = [];\nvar array = ['a', 'b', 'a', 'c', 'a', 'd'];\nvar element = 'a';\nvar idx = array.lastIndexOf(element);\nwhile (idx != -1) {\n indices.push(idx);\n idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1);\n}\n\nconsole.log(indices);\n// [4, 2, 0]\n Note that we have to handle the case idx == 0 separately here because the element will always be found regardless of the fromIndex parameter if it is the first element of the array. This is different from the indexOf method.
lastIndexOf was added to the ECMA-262 standard in the 5th edition; as such it may not be present in other implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of lastIndexOf in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming Object, TypeError, Number, Math.floor, Math.abs, and Math.min have their original values.
// Production steps of ECMA-262, Edition 5, 15.4.4.15\n// Reference: http://es5.github.io/#x15.4.4.15\nif (!Array.prototype.lastIndexOf) {\n Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/) {\n 'use strict';\n\n if (this === void 0 || this === null) {\n throw new TypeError();\n }\n\n var n, k,\n t = Object(this),\n len = t.length >>> 0;\n if (len === 0) {\n return -1;\n }\n\n n = len - 1;\n if (arguments.length > 1) {\n n = Number(arguments[1]);\n if (n != n) {\n n = 0;\n }\n else if (n != 0 && n != (1 / 0) && n != -(1 / 0)) {\n n = (n > 0 || -1) * Math.floor(Math.abs(n));\n }\n }\n\n for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) {\n if (k in t && t[k] === searchElement) {\n return k;\n }\n }\n return -1;\n };\n}\n Again, note that this implementation aims for absolute compatibility with lastIndexOf in Firefox and the SpiderMonkey JavaScript engine, including in several cases which are arguably edge cases. If you intend to use this in real-world applications, you may be able to calculate from with less complicated code if you ignore those cases.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.lastIndexOf' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.lastIndexOf' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.lastIndexOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
-0. For example, [0].lastIndexOf(0, -0) will now always return +0 (bug 1242043).\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf\n
The map() method creates a new array with the results of calling a provided function on every element in the calling array.
var new_array = arr.map(function callback(currentValue[, index[, array]]) {\n // Return element for new_array\n}[, thisArg]) callbackcurrentValueindexOptional\narrayOptional\nmap was called upon.thisArgOptional\nthis when executing callback.A new array with each element being the result of the callback function.
map calls a provided callback function once for each element in an array, in order, and constructs a new array from the results. callback is invoked only for indexes of the array which have assigned values, including undefined. It is not called for missing elements of the array (that is, indexes that have never been set, which have been deleted or which have never been assigned a value).
Since map builds a new array, using it when you aren't using the returned array is an anti-pattern; use forEach or for-of instead. Signs you shouldn't be using map: A) You're not using the array it returns, and/or B) You're not returning a value from the callback.
callback is invoked with three arguments: the value of the element, the index of the element, and the Array object being traversed.
If a thisArg parameter is provided to map, it will be used as callback's this value. Otherwise, the value undefined will be used as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
map does not mutate the array on which it is called (although callback, if invoked, may do so).
The range of elements processed by map is set before the first invocation of callback. Elements which are appended to the array after the call to map begins will not be visited by callback. If existing elements of the array are changed, their value as passed to callback will be the value at the time map visits them. Elements that are deleted after the call to map begins and before being visited are not visited.
Due to the algorithm defined in the specification if the array which map was called upon is sparse, resulting array will also be sparse keeping same indices blank.
The following code takes an array of numbers and creates a new array containing the square roots of the numbers in the first array.
var numbers = [1, 4, 9];\nvar roots = numbers.map(Math.sqrt);\n// roots is now [1, 2, 3]\n// numbers is still [1, 4, 9]\n
The following code takes an array of objects and creates a new array containing the newly reformatted objects.
var kvArray = [{key: 1, value: 10}, \n {key: 2, value: 20}, \n {key: 3, value: 30}];\n\nvar reformattedArray = kvArray.map(obj =>{ \n var rObj = {};\n rObj[obj.key] = obj.value;\n return rObj;\n});\n// reformattedArray is now [{1: 10}, {2: 20}, {3: 30}], \n\n// kvArray is still: \n// [{key: 1, value: 10}, \n// {key: 2, value: 20}, \n// {key: 3, value: 30}]\n The following code shows how map works when a function requiring one argument is used with it. The argument will automatically be assigned from each element of the array as map loops through the original array.
var numbers = [1, 4, 9];\nvar doubles = numbers.map(function(num) {\n return num * 2;\n});\n\n// doubles is now [2, 8, 18]\n// numbers is still [1, 4, 9]\n map genericallyThis example shows how to use map on a String to get an array of bytes in the ASCII encoding representing the character values:
var map = Array.prototype.map;\nvar a = map.call('Hello World', function(x) { \n return x.charCodeAt(0); \n});\n// a now equals [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]\n map generically querySelectorAll\nThis example shows how to iterate through a collection of objects collected by querySelectorAll. In this case we get all selected options on the screen and printed on the console:
var elems = document.querySelectorAll('select option:checked');\nvar values = Array.prototype.map.call(elems, function(obj) {\n return obj.value;\n});\n Easier way would be using Array.from() method.
It is common to use the callback with one argument (the element being traversed). Certain functions are also commonly used with one argument, even though they take additional optional arguments. These habits may lead to confusing behaviors.
// Consider:\n['1', '2', '3'].map(parseInt);\n// While one could expect [1, 2, 3]\n// The actual result is [1, NaN, NaN]\n\n// parseInt is often used with one argument, but takes two.\n// The first is an expression and the second is the radix.\n// To the callback function, Array.prototype.map passes 3 arguments: \n// the element, the index, the array\n// The third argument is ignored by parseInt, but not the second one,\n// hence the possible confusion. See the blog post for more details\n// If the link doesn't work\n// here is concise example of the iteration steps:\n// parseInt(string, radix) -> map(parseInt(value, index))\n// first iteration (index is 0): parseInt('1', 0) // results in parseInt('1', 0) -> 1\n// second iteration (index is 1): parseInt('2', 1) // results in parseInt('2', 1) -> NaN\n// third iteration (index is 2): parseInt('3', 2) // results in parseInt('3', 2) -> NaN\n\nfunction returnInt(element) {\n return parseInt(element, 10);\n}\n\n['1', '2', '3'].map(returnInt); // [1, 2, 3]\n// Actual result is an array of numbers (as expected)\n\n// Same as above, but using the concise arrow function syntax\n['1', '2', '3'].map( str => parseInt(str) );\n\n// A simpler way to achieve the above, while avoiding the \"gotcha\":\n['1', '2', '3'].map(Number); // [1, 2, 3]\n// but unlike `parseInt` will also return a float or (resolved) exponential notation:\n['1.1', '2.2e2', '3e300'].map(Number); // [1.1, 220, 3e+300]\n One alternative output of the map method being called with parseInt as a parameter runs as follows:
var xs = ['10', '10', '10'];\n\nxs = xs.map(parseInt);\n\nconsole.log(xs);\n// Actual result of 10,NaN,2 may be unexpected based on the above description.
map was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of map in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming Object, TypeError, and Array have their original values and that callback.call evaluates to the original value of Function.prototype.call
// Production steps of ECMA-262, Edition 5, 15.4.4.19\n// Reference: http://es5.github.io/#x15.4.4.19\nif (!Array.prototype.map) {\n\n Array.prototype.map = function(callback/*, thisArg*/) {\n\n var T, A, k;\n\n if (this == null) {\n throw new TypeError('this is null or not defined');\n }\n\n // 1. Let O be the result of calling ToObject passing the |this| \n // value as the argument.\n var O = Object(this);\n\n // 2. Let lenValue be the result of calling the Get internal \n // method of O with the argument \"length\".\n // 3. Let len be ToUint32(lenValue).\n var len = O.length >>> 0;\n\n // 4. If IsCallable(callback) is false, throw a TypeError exception.\n // See: http://es5.github.com/#x9.11\n if (typeof callback !== 'function') {\n throw new TypeError(callback + ' is not a function');\n }\n\n // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.\n if (arguments.length > 1) {\n T = arguments[1];\n }\n\n // 6. Let A be a new array created as if by the expression new Array(len) \n // where Array is the standard built-in constructor with that name and \n // len is the value of len.\n A = new Array(len);\n\n // 7. Let k be 0\n k = 0;\n\n // 8. Repeat, while k < len\n while (k < len) {\n\n var kValue, mappedValue;\n\n // a. Let Pk be ToString(k).\n // This is implicit for LHS operands of the in operator\n // b. Let kPresent be the result of calling the HasProperty internal \n // method of O with argument Pk.\n // This step can be combined with c\n // c. If kPresent is true, then\n if (k in O) {\n\n // i. Let kValue be the result of calling the Get internal \n // method of O with argument Pk.\n kValue = O[k];\n\n // ii. Let mappedValue be the result of calling the Call internal \n // method of callback with T as the this value and argument \n // list containing kValue, k, and O.\n mappedValue = callback.call(T, kValue, k, O);\n\n // iii. Call the DefineOwnProperty internal method of A with arguments\n // Pk, Property Descriptor\n // { Value: mappedValue,\n // Writable: true,\n // Enumerable: true,\n // Configurable: true },\n // and false.\n\n // In browsers that support Object.defineProperty, use the following:\n // Object.defineProperty(A, k, {\n // value: mappedValue,\n // writable: true,\n // enumerable: true,\n // configurable: true\n // });\n\n // For best browser support, use the following:\n A[k] = mappedValue;\n }\n // d. Increase k by 1.\n k++;\n }\n\n // 9. return A\n return A;\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.map' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.6. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.map' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.map' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1.5 | \n9 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Array.prototype.forEach()Map objectArray.from()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map\n
The sort() method sorts the elements of an array in place and returns the array. The default sort order is built upon converting the elements into strings, then comparing their sequences of UTF-16 code units values.
The time and space complexity of the sort cannot be guaranteed as it is implementation dependent.
arr.sort([compareFunction])\n
compareFunction Optional\nThe sorted array. Note that the array is sorted in place, and no copy is made.
If compareFunction is not supplied, all non-undefined array elements are sorted by converting them to strings and comparing strings in UTF-16 code units order. For example, \"Banana\" comes before \"cherry\". In a numeric sort, 9 comes before 80, but because numbers are converted to strings, \"80\" comes before \"9\" in Unicode order. All undefined elements are sorted to the end of the array.
Note : In UTF-16, Unicode characters above \\uFFFF are encoded as two surrogate code units, of the range \\uD800-\\uDFFF. The value of each code unit is taken separately into account for the comparison. Thus the character formed by the surrogate pair \\uD655\\uDE55 will be sorted before the character \\uFF3A.
If compareFunction is supplied, all non-undefined array elements are sorted according to the return value of the compare function (all undefined elements are sorted to the end of the array, with no call to compareFunction). If a and b are two elements being compared, then:
compareFunction(a, b) is less than 0, sort a to an index lower than b, i.e. a comes first.compareFunction(a, b) returns 0, leave a and b unchanged with respect to each other, but sorted with respect to all different elements. Note: the ECMAscript standard does not guarantee this behaviour, and thus not all browsers (e.g. Mozilla versions dating back to at least 2003) respect this.compareFunction(a, b) is greater than 0, sort b to an index lower than a, i.e. b comes first.compareFunction(a, b) must always return the same value when given a specific pair of elements a and b as its two arguments. If inconsistent results are returned then the sort order is undefined.So, the compare function has the following form:
function compare(a, b) {\n if (a is less than b by some ordering criterion) {\n return -1;\n }\n if (a is greater than b by the ordering criterion) {\n return 1;\n }\n // a must be equal to b\n return 0;\n}\n To compare numbers instead of strings, the compare function can simply subtract b from a. The following function will sort the array ascending (if it doesn't contain Infinity and NaN):
function compareNumbers(a, b) {\n return a - b;\n}\n The sort method can be conveniently used with function expressions:
var numbers = [4, 2, 5, 1, 3];\nnumbers.sort(function(a, b) {\n return a - b;\n});\nconsole.log(numbers);\n\n// [1, 2, 3, 4, 5]\n Objects can be sorted given the value of one of their properties.
var items = [\n { name: 'Edward', value: 21 },\n { name: 'Sharpe', value: 37 },\n { name: 'And', value: 45 },\n { name: 'The', value: -12 },\n { name: 'Magnetic', value: 13 },\n { name: 'Zeros', value: 37 }\n];\n\n// sort by value\nitems.sort(function (a, b) {\n return a.value - b.value;\n});\n\n// sort by name\nitems.sort(function(a, b) {\n var nameA = a.name.toUpperCase(); // ignore upper and lowercase\n var nameB = b.name.toUpperCase(); // ignore upper and lowercase\n if (nameA < nameB) {\n return -1;\n }\n if (nameA > nameB) {\n return 1;\n }\n\n // names must be equal\n return 0;\n}); The following example creates four arrays and displays the original array, then the sorted arrays. The numeric arrays are sorted without, then with, a compare function.
var stringArray = ['Blue', 'Humpback', 'Beluga'];\nvar numericStringArray = ['80', '9', '700'];\nvar numberArray = [40, 1, 5, 200];\nvar mixedNumericArray = ['80', '9', '700', 40, 1, 5, 200];\n\nfunction compareNumbers(a, b) {\n return a - b;\n}\n\nconsole.log('stringArray:', stringArray.join());\nconsole.log('Sorted:', stringArray.sort());\n\nconsole.log('numberArray:', numberArray.join());\nconsole.log('Sorted without a compare function:', numberArray.sort());\nconsole.log('Sorted with compareNumbers:', numberArray.sort(compareNumbers));\n\nconsole.log('numericStringArray:', numericStringArray.join());\nconsole.log('Sorted without a compare function:', numericStringArray.sort());\nconsole.log('Sorted with compareNumbers:', numericStringArray.sort(compareNumbers));\n\nconsole.log('mixedNumericArray:', mixedNumericArray.join());\nconsole.log('Sorted without a compare function:', mixedNumericArray.sort());\nconsole.log('Sorted with compareNumbers:', mixedNumericArray.sort(compareNumbers));\n This example produces the following output. As the output shows, when a compare function is used, numbers sort correctly whether they are numbers or numeric strings.
stringArray: Blue,Humpback,Beluga\nSorted: Beluga,Blue,Humpback\n\nnumberArray: 40,1,5,200\nSorted without a compare function: 1,200,40,5\nSorted with compareNumbers: 1,5,40,200\n\nnumericStringArray: 80,9,700\nSorted without a compare function: 700,80,9\nSorted with compareNumbers: 9,80,700\n\nmixedNumericArray: 80,9,700,40,1,5,200\nSorted without a compare function: 1,200,40,5,700,80,9\nSorted with compareNumbers: 1,5,9,40,80,200,700\n
For sorting strings with non-ASCII characters, i.e. strings with accented characters (e, é, è, a, ä, etc.), strings from languages other than English: use String.localeCompare. This function can compare those characters so they appear in the right order.
var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];\nitems.sort(function (a, b) {\n return a.localeCompare(b);\n});\n\n// items is ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']\n The compareFunction can be invoked multiple times per element within the array. Depending on the compareFunction's nature, this may yield a high overhead. The more work a compareFunction does and the more elements there are to sort, the wiser it may be to consider using a map for sorting. The idea is to traverse the array once to extract the actual values used for sorting into a temporary array, sort the temporary array and then traverse the temporary array to achieve the right order.
// the array to be sorted\nvar list = ['Delta', 'alpha', 'CHARLIE', 'bravo'];\n\n// temporary array holds objects with position and sort-value\nvar mapped = list.map(function(el, i) {\n return { index: i, value: el.toLowerCase() };\n})\n\n// sorting the mapped array containing the reduced values\nmapped.sort(function(a, b) {\n if (a.value > b.value) {\n return 1;\n }\n if (a.value < b.value) {\n return -1;\n }\n return 0;\n});\n\n// container for the resulting order\nvar result = mapped.map(function(el){\n return list[el.index];\n});\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.sort' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.sort' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.sort' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Array.prototype.reverse()String.prototype.localeCompare()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort\n
The values() method returns a new Array Iterator object that contains the values for each index in the array.
var a = ['w', 'y', 'k', 'o', 'p']; \nvar iterator = a.values();\n\nconsole.log(iterator.next().value); // w \nconsole.log(iterator.next().value); // y \nconsole.log(iterator.next().value); // k \nconsole.log(iterator.next().value); // o \nconsole.log(iterator.next().value); // p
arr.values()
A new Array iterator object.
for...of loopvar arr = ['w', 'y', 'k', 'o', 'p'];\nvar iterator = arr.values();\n\nfor (let letter of iterator) {\n console.log(letter);\n}\n Array.prototype.values is default implementation of Array.prototype[Symbol.iterator].
Array.prototype.values === Array.prototype[Symbol.iterator] //true
TODO please write about why we need it, usecases.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.values' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.values' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n66 | \nYes | \n60 | \nNo | \n53 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n66 | \n66 | \nYes | \n60 | \n53 | \n9 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 10.9.0\n
| \n
Array.prototype.keys()Array.prototype.entries()Array.prototype.forEach()Array.prototype.every()Array.prototype.some()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values\n
The reduce() method executes a reducer function (that you provide) on each member of the array resulting in a single output value.
The reducer function is fed four parameters:
Your reducer function's returned value is assigned to the accumulator, whose value is remembered across each iteration throughout the array and ultimately becomes the final, single resulting value.
arr.reduce(callback[, initialValue])
callbackaccumulatorinitialValue, if supplied (see below).currentValuecurrentIndexOptional\ninitialValue is provided, and at index 1 otherwise.arrayOptional\nreduce() was called upon.initialValueOptional\ncallback. If no initial value is supplied, the first element in the array will be used. Calling reduce() on an empty array without an initial value is an error.The value that results from the reduction.
reduce() executes the callback function once for each element present in the array, excluding holes in the array, receiving four arguments:
accumulatorcurrentValuecurrentIndexarrayThe first time the callback is called, accumulator and currentValue can be one of two values. If initialValue is provided in the call to reduce(), then accumulator will be equal to initialValue, and currentValue will be equal to the first value in the array. If no initialValue is provided, then accumulator will be equal to the first value in the array, and currentValue will be equal to the second.
Note: If initialValue isn't provided, reduce() will execute the callback function starting at index 1, skipping the first index. If initialValue is provided, it will start at index 0.
If the array is empty and no initialValue is provided, TypeError will be thrown. If the array has only one element (regardless of position) and no initialValue is provided, or if initialValue is provided but the array is empty, the solo value will be returned without calling callback.
It is usually safer to provide an initial value because there are three possible outputs without initialValue, as shown in the following example.
var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x );\nvar maxCallback2 = ( max, cur ) => Math.max( max, cur );\n\n// reduce() without initialValue\n[ { x: 22 }, { x: 42 } ].reduce( maxCallback ); // 42\n[ { x: 22 } ].reduce( maxCallback ); // { x: 22 }\n[ ].reduce( maxCallback ); // TypeError\n\n// map/reduce; better solution, also works for empty or larger arrays\n[ { x: 22 }, { x: 42 } ].map( el => el.x )\n .reduce( maxCallback2, -Infinity );\n Suppose the following use of reduce() occurred:
[0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array) {\n return accumulator + currentValue;\n});\n The callback would be invoked four times, with the arguments and return values in each call being as follows:
callback | accumulator | currentValue | currentIndex | array | return value |
|---|---|---|---|---|---|
| first call | 0 | 1 | 1 | [0, 1, 2, 3, 4] | 1 |
| second call | 1 | 2 | 2 | [0, 1, 2, 3, 4] | 3 |
| third call | 3 | 3 | 3 | [0, 1, 2, 3, 4] | 6 |
| fourth call | 6 | 4 | 4 | [0, 1, 2, 3, 4] | 10 |
The value returned by reduce() would be that of the last callback invocation (10).
You can also provide an Arrow Function in lieu of a full function. The code below will produce the same output as the code in the block above:
[0, 1, 2, 3, 4].reduce( (accumulator, currentValue, currentIndex, array) => accumulator + currentValue );\n
If you were to provide an initial value as the second argument to reduce(), the result would look like this:
[0, 1, 2, 3, 4].reduce((accumulator, currentValue, currentIndex, array) => {\n return accumulator + currentValue;\n}, 10);\n callback | accumulator | currentValue | currentIndex | array | return value |
|---|---|---|---|---|---|
| first call | 10 | 0 | 0 | [0, 1, 2, 3, 4] | 10 |
| second call | 10 | 1 | 1 | [0, 1, 2, 3, 4] | 11 |
| third call | 11 | 2 | 2 | [0, 1, 2, 3, 4] | 13 |
| fourth call | 13 | 3 | 3 | [0, 1, 2, 3, 4] | 16 |
| fifth call | 16 | 4 | 4 | [0, 1, 2, 3, 4] | 20 |
The value returned by reduce() in this case would be 20.
var sum = [0, 1, 2, 3].reduce(function (accumulator, currentValue) {\n return accumulator + currentValue;\n}, 0);\n// sum is 6\n\n Alternatively, written with an arrow function:
var total = [ 0, 1, 2, 3 ].reduce(\n ( accumulator, currentValue ) => accumulator + currentValue,\n 0\n);
To sum up values contained in an array of objects you must supply an initial value so that each item passes through your function.
var initialValue = 0;\nvar sum = [{x: 1}, {x:2}, {x:3}].reduce(function (accumulator, currentValue) {\n return accumulator + currentValue.x;\n},initialValue)\n\nconsole.log(sum) // logs 6\n Alternatively, written with an arrow function:
var initialValue = 0;\nvar sum = [{x: 1}, {x:2}, {x:3}].reduce(\n (accumulator, currentValue) => accumulator + currentValue.x\n ,initialValue\n);\n\nconsole.log(sum) // logs 6 var flattened = [[0, 1], [2, 3], [4, 5]].reduce(\n function(accumulator, currentValue) {\n return accumulator.concat(currentValue);\n },\n []\n);\n// flattened is [0, 1, 2, 3, 4, 5]\n Alternatively, written with an arrow function:
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(\n ( accumulator, currentValue ) => accumulator.concat(currentValue),\n []\n);\n
var names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];\n\nvar countedNames = names.reduce(function (allNames, name) { \n if (name in allNames) {\n allNames[name]++;\n }\n else {\n allNames[name] = 1;\n }\n return allNames;\n}, {});\n// countedNames is:\n// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }\n var people = [\n { name: 'Alice', age: 21 },\n { name: 'Max', age: 20 },\n { name: 'Jane', age: 20 }\n];\n\nfunction groupBy(objectArray, property) {\n return objectArray.reduce(function (acc, obj) {\n var key = obj[property];\n if (!acc[key]) {\n acc[key] = [];\n }\n acc[key].push(obj);\n return acc;\n }, {});\n}\n\nvar groupedPeople = groupBy(people, 'age');\n// groupedPeople is:\n// { \n// 20: [\n// { name: 'Max', age: 20 }, \n// { name: 'Jane', age: 20 }\n// ], \n// 21: [{ name: 'Alice', age: 21 }] \n// }\n // friends - an array of objects \n// where object field \"books\" - list of favorite books \nvar friends = [{\n name: 'Anna',\n books: ['Bible', 'Harry Potter'],\n age: 21\n}, {\n name: 'Bob',\n books: ['War and peace', 'Romeo and Juliet'],\n age: 26\n}, {\n name: 'Alice',\n books: ['The Lord of the Rings', 'The Shining'],\n age: 18\n}];\n\n// allbooks - list which will contain all friends' books + \n// additional list contained in initialValue\nvar allbooks = friends.reduce(function(accumulator, currentValue) {\n return [...accumulator, ...currentValue.books];\n}, ['Alphabet']);\n\n// allbooks = [\n// 'Alphabet', 'Bible', 'Harry Potter', 'War and peace', \n// 'Romeo and Juliet', 'The Lord of the Rings',\n// 'The Shining'\n// ] let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4];\nlet result = arr.sort().reduce((accumulator, current) => {\n const length = accumulator.length\n if (length === 0 || accumulator[length - 1] !== current) {\n accumulator.push(current);\n }\n return accumulator;\n}, []);\nconsole.log(result); //[1,2,3,4,5]\n /**\n * Runs promises from array of functions that can return promises\n * in chained manner\n *\n * @param {array} arr - promise arr\n * @return {Object} promise object\n */\nfunction runPromiseInSequence(arr, input) {\n return arr.reduce(\n (promiseChain, currentFunction) => promiseChain.then(currentFunction),\n Promise.resolve(input)\n );\n}\n\n// promise function 1\nfunction p1(a) {\n return new Promise((resolve, reject) => {\n resolve(a * 5);\n });\n}\n\n// promise function 2\nfunction p2(a) {\n return new Promise((resolve, reject) => {\n resolve(a * 2);\n });\n}\n\n// function 3 - will be wrapped in a resolved promise by .then()\nfunction f3(a) {\n return a * 3;\n}\n\n// promise function 4\nfunction p4(a) {\n return new Promise((resolve, reject) => {\n resolve(a * 4);\n });\n}\n\nconst promiseArr = [p1, p2, f3, p4];\nrunPromiseInSequence(promiseArr, 10)\n .then(console.log); // 1200\n // Building-blocks to use for composition\nconst double = x => x + x;\nconst triple = x => 3 * x;\nconst quadruple = x => 4 * x;\n\n// Function composition enabling pipe functionality\nconst pipe = (...functions) => input => functions.reduce(\n (acc, fn) => fn(acc),\n input\n);\n\n// Composed functions for multiplication of specific values\nconst multiply6 = pipe(double, triple);\nconst multiply9 = pipe(triple, triple);\nconst multiply16 = pipe(quadruple, quadruple);\nconst multiply24 = pipe(double, triple, quadruple);\n\n// Usage\nmultiply6(6); // 36\nmultiply9(9); // 81\nmultiply16(16); // 256\nmultiply24(10); // 240\n\n
if (!Array.prototype.mapUsingReduce) {\n Array.prototype.mapUsingReduce = function(callback, thisArg) {\n return this.reduce(function(mappedArray, currentValue, index, array) {\n mappedArray[index] = callback.call(thisArg, currentValue, index, array);\n return mappedArray;\n }, []);\n };\n}\n\n[1, 2, , 3].mapUsingReduce(\n (currentValue, index, array) => currentValue + index + array.length\n); // [5, 7, , 10]\n\n // Production steps of ECMA-262, Edition 5, 15.4.4.21\n// Reference: http://es5.github.io/#x15.4.4.21\n// https://tc39.github.io/ecma262/#sec-array.prototype.reduce\nif (!Array.prototype.reduce) {\n Object.defineProperty(Array.prototype, 'reduce', {\n value: function(callback /*, initialValue*/) {\n if (this === null) {\n throw new TypeError( 'Array.prototype.reduce ' + \n 'called on null or undefined' );\n }\n if (typeof callback !== 'function') {\n throw new TypeError( callback +\n ' is not a function');\n }\n\n // 1. Let O be ? ToObject(this value).\n var o = Object(this);\n\n // 2. Let len be ? ToLength(? Get(O, \"length\")).\n var len = o.length >>> 0; \n\n // Steps 3, 4, 5, 6, 7 \n var k = 0; \n var value;\n\n if (arguments.length >= 2) {\n value = arguments[1];\n } else {\n while (k < len && !(k in o)) {\n k++; \n }\n\n // 3. If len is 0 and initialValue is not present,\n // throw a TypeError exception.\n if (k >= len) {\n throw new TypeError( 'Reduce of empty array ' +\n 'with no initial value' );\n }\n value = o[k++];\n }\n\n // 8. Repeat, while k < len\n while (k < len) {\n // a. Let Pk be ! ToString(k).\n // b. Let kPresent be ? HasProperty(O, Pk).\n // c. If kPresent is true, then\n // i. Let kValue be ? Get(O, Pk).\n // ii. Let accumulator be ? Call(\n // callbackfn, undefined,\n // « accumulator, kValue, k, O »).\n if (k in o) {\n value = callback(value, o[k], k, o);\n }\n\n // d. Increase k by 1. \n k++;\n }\n\n // 9. Return accumulator.\n return value;\n }\n });\n}\n If you need to support truly obsolete JavaScript engines that don't support Object.defineProperty(), it's best not to polyfill Array.prototype methods at all, as you can't make them non-enumerable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.reduce()' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.reduce()' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.reduce()' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n3 | \n9 | \n10.5 | \n4 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce\n
The toString() method returns a string representing the specified array and its elements.
arr.toString()
A string representing the elements of the array.
The Array object overrides the toString method of Object. For Array objects, the toString method joins the array and returns one string containing each array element separated by commas.
JavaScript calls the toString method automatically when an array is to be represented as a text value or when an array is referred to in a string concatenation.
Starting in JavaScript 1.8.5 (Firefox 4), and consistent with ECMAScript 5th edition semantics, the toString() method is generic and can be used with any object. Object.prototype.toString() will be called, and the resulting value will be returned.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.toString' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.toString' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString\n
The Intl.Collator.prototype property represents the prototype object for the Intl.Collator constructor.
Property attributes of Intl.Collator.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
See Collator for a description of Intl.Collator instances.
Intl.Collator instances inherit from Intl.Collator.prototype. Modifications to the prototype object are inherited by all Intl.Collator instances.
Intl.Collator.prototype.compareIntl.Collator object.Intl.Collator.prototype.constructorIntl.Collator.Intl.Collator.prototype.resolvedOptions()| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator/prototype\n
The Intl.Collator.prototype.resolvedOptions() method returns a new object with properties reflecting the locale and collation options computed during initialization of this Collator object.
collator.resolvedOptions()
A new object with properties reflecting the locale and collation options computed during the initialization of the given Collator object.
The resulting object has the following properties:
localelocale.usagesensitivityignorePunctuationoptions argument or filled in as defaults.collation\"co\", if it is supported for locale, or \"default\".numericcaseFirstoptions argument or using the Unicode extension keys \"kn\" and \"kf\" or filled in as defaults. If the implementation does not support these properties, they are omitted.resolvedOptions methodvar de = new Intl.Collator('de', { sensitivity: 'base' })\nvar usedOptions = de.resolvedOptions();\n\nusedOptions.locale; // \"de\"\nusedOptions.usage; // \"sort\"\nusedOptions.sensitivity; // \"base\"\nusedOptions.ignorePunctuation; // false\nusedOptions.collation; // \"default\"\nusedOptions.numeric; // false\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator/resolvedOptions\n
The reduceRight() method applies a function against an accumulator and each value of the array (from right-to-left) to reduce it to a single value.
See also Array.prototype.reduce() for left-to-right.
arr.reduceRight(callback[, initialValue])
callbackaccumulatorinitialValue, if supplied. (See below.)currentValueindexOptional\narrayOptional\nreduce was called upon.initialValueOptional\ncallback. If no initial value is supplied, the last element in the array will be used. Calling reduce on an empty array without an initial value is an error.The value that results from the reduction.
reduceRight executes the callback function once for each element present in the array, excluding holes in the array, receiving four arguments: the initial value (or value from the previous callback call), the value of the current element, the current index, and the array over which iteration is occurring.
The call to the reduceRight callback would look something like this:
array.reduceRight(function(accumulator, currentValue, index, array) {\n // ...\n});\n The first time the function is called, the accumulator and currentValue can be one of two values. If an initialValue was provided in the call to reduceRight, then accumulator will be equal to initialValue and currentValue will be equal to the last value in the array. If no initialValue was provided, then accumulator will be equal to the last value in the array and currentValue will be equal to the second-to-last value.
If the array is empty and no initialValue was provided, TypeError would be thrown. If the array has only one element (regardless of position) and no initialValue was provided, or if initialValue is provided but the array is empty, the solo value would be returned without calling callback.
Some example run-throughs of the function would look like this:
[0, 1, 2, 3, 4].reduceRight(function(accumulator, currentValue, index, array) {\n return accumulator + currentValue;\n});\n The callback would be invoked four times, with the arguments and return values in each call being as follows:
callback | accumulator | currentValue | index | array | return value |
|---|---|---|---|---|---|
| first call | 4 | 3 | 3 | [0, 1, 2, 3, 4] | 7 |
| second call | 7 | 2 | 2 | [0, 1, 2, 3, 4] | 9 |
| third call | 9 | 1 | 1 | [0, 1, 2, 3, 4] | 10 |
| fourth call | 10 | 0 | 0 | [0, 1, 2, 3, 4] | 10 |
The value returned by reduceRight would be that of the last callback invocation (10).
And if you were to provide an initialValue, the result would look like this:
[0, 1, 2, 3, 4].reduceRight(function(accumulator, currentValue, index, array) {\n return accumulator + currentValue;\n}, 10);\n callback | accumulator | currentValue | index | array | return value |
|---|---|---|---|---|---|
| first call | 10 | 4 | 4 | [0, 1, 2, 3, 4] | 14 |
| second call | 14 | 3 | 3 | [0, 1, 2, 3, 4] | 17 |
| third call | 17 | 2 | 2 | [0, 1, 2, 3, 4] | 19 |
| fourth call | 19 | 1 | 1 | [0, 1, 2, 3, 4] | 20 |
| fifth call | 20 | 0 | 0 | [0, 1, 2, 3, 4] | 20 |
The value returned by reduceRight this time would be, of course, 20.
var sum = [0, 1, 2, 3].reduceRight(function(a, b) {\n return a + b;\n});\n// sum is 6\n var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {\n return a.concat(b);\n}, []);\n// flattened is [4, 5, 2, 3, 0, 1]\n\n const waterfall = (...functions) => (callback, ...args) =>\n functions.reduceRight(\n (composition, fn) => (...results) => fn(composition, ...results),\n callback\n )(...args);\n\nconst randInt = max => Math.floor(Math.random() * max)\n\nconst add5 = (callback, x) => {\n setTimeout(callback, randInt(1000), x + 5);\n};\nconst mult3 = (callback, x) => {\n setTimeout(callback, randInt(1000), x * 3);\n};\nconst sub2 = (callback, x) => {\n setTimeout(callback, randInt(1000), x - 2);\n};\nconst split = (callback, x) => {\n setTimeout(callback, randInt(1000), x, x);\n};\nconst add = (callback, x, y) => {\n setTimeout(callback, randInt(1000), x + y);\n};\nconst div4 = (callback, x) => {\n setTimeout(callback, randInt(1000), x / 4);\n};\n\nconst computation = waterfall(add5, mult3, sub2, split, add, div4);\ncomputation(console.log, 5) // -> 14\n\n// same as:\n\nconst computation2 = (input, callback) => {\n const f6 = x=> div4(callback, x);\n const f5 = (x, y) => add(f6, x, y);\n const f4 = x => split(f5, x);\n const f3 = x => sub2(f4, x);\n const f2 = x => mult3(f3, x);\n add5(f2, input);\n} reduce and reduceRight\nvar a = ['1', '2', '3', '4', '5']; \nvar left = a.reduce(function(prev, cur) { return prev + cur; }); \nvar right = a.reduceRight(function(prev, cur) { return prev + cur; }); \n\nconsole.log(left); // \"12345\"\nconsole.log(right); // \"54321\" reduceRight was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of reduceRight in implementations which do not natively support it.
// Production steps of ECMA-262, Edition 5, 15.4.4.22\n// Reference: http://es5.github.io/#x15.4.4.22\nif ('function' !== typeof Array.prototype.reduceRight) {\n Array.prototype.reduceRight = function(callback /*, initialValue*/) {\n 'use strict';\n if (null === this || 'undefined' === typeof this) {\n throw new TypeError('Array.prototype.reduce called on null or undefined');\n }\n if ('function' !== typeof callback) {\n throw new TypeError(callback + ' is not a function');\n }\n var t = Object(this), len = t.length >>> 0, k = len - 1, value;\n if (arguments.length >= 2) {\n value = arguments[1];\n } else {\n while (k >= 0 && !(k in t)) {\n k--;\n }\n if (k < 0) {\n throw new TypeError('Reduce of empty array with no initial value');\n }\n value = t[k--];\n }\n for (; k >= 0; k--) {\n if (k in t) {\n value = callback(value, t[k], k, t);\n }\n }\n return value;\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.reduceRight' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.reduceRight' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.reduceRight' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n3 | \n9 | \n10.5 | \n4 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight\n
The reverse() method reverses an array in place. The first array element becomes the last, and the last array element becomes the first.
a.reverse()
The reversed array.
The reverse method transposes the elements of the calling array object in place, mutating the array, and returning a reference to the array.
The following example creates an array a, containing three elements, then reverses the array. The call to reverse() returns a reference to the reversed array a.
const a = [1, 2, 3];\n\nconsole.log(a); // [1, 2, 3]\n\na.reverse();\n\nconsole.log(a); // [3, 2, 1]\n\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.reverse' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.reverse' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.reverse' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse\n
The slice() method returns a shallow copy of a portion of an array into a new array object selected from begin to end (end not included). The original array will not be modified.
arr.slice([begin[, end]])\n
begin Optional\nslice(-2) extracts the last two elements in the sequence.begin is undefined, slice begins from index 0.begin is greater than the length of the sequence, an empty array is returned.end Optional\nslice extracts up to but not including end.slice(1,4) extracts the second element through the fourth element (elements indexed 1, 2, and 3).slice(2,-1) extracts the third element through the second-to-last element in the sequence.end is omitted, slice extracts through the end of the sequence (arr.length).end is greater than the length of the sequence, slice extracts through to the end of the sequence (arr.length).A new array containing the extracted elements.
slice does not alter the original array. It returns a shallow copy of elements from the original array. Elements of the original array are copied into the returned array as follows:
slice copies object references into the new array. Both the original and new array refer to the same object. If a referenced object changes, the changes are visible to both the new and original arrays.String, Number and Boolean objects), slice copies the values into the new array. Changes to the string, number or boolean in one array do not affect the other array.If a new element is added to either array, the other array is not affected.
var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];\nvar citrus = fruits.slice(1, 3);\n\n// fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']\n// citrus contains ['Orange','Lemon']\n
slice\nIn the following example, slice creates a new array, newCar, from myCar. Both include a reference to the object myHonda. When the color of myHonda is changed to purple, both arrays reflect the change.
// Using slice, create newCar from myCar.\nvar myHonda = { color: 'red', wheels: 4, engine: { cylinders: 4, size: 2.2 } };\nvar myCar = [myHonda, 2, 'cherry condition', 'purchased 1997'];\nvar newCar = myCar.slice(0, 2);\n\n// Display the values of myCar, newCar, and the color of myHonda\n// referenced from both arrays.\nconsole.log('myCar = ' + JSON.stringify(myCar));\nconsole.log('newCar = ' + JSON.stringify(newCar));\nconsole.log('myCar[0].color = ' + myCar[0].color);\nconsole.log('newCar[0].color = ' + newCar[0].color);\n\n// Change the color of myHonda.\nmyHonda.color = 'purple';\nconsole.log('The new color of my Honda is ' + myHonda.color);\n\n// Display the color of myHonda referenced from both arrays.\nconsole.log('myCar[0].color = ' + myCar[0].color);\nconsole.log('newCar[0].color = ' + newCar[0].color);\n This script writes:
myCar = [{color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}}, 2,\n 'cherry condition', 'purchased 1997']\nnewCar = [{color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}}, 2]\nmyCar[0].color = red \nnewCar[0].color = red\nThe new color of my Honda is purple\nmyCar[0].color = purple\nnewCar[0].color = purple\n slice method can also be called to convert Array-like objects / collections to a new Array. You just bind the method to the object. The arguments inside a function is an example of an 'array-like object'.
function list() {\n return Array.prototype.slice.call(arguments);\n}\n\nvar list1 = list(1, 2, 3); // [1, 2, 3]\n Binding can be done with the .call function of Function.prototype and it can also be reduced using [].slice.call(arguments) instead of Array.prototype.slice.call. Anyway, it can be simplified using bind.
var unboundSlice = Array.prototype.slice;\nvar slice = Function.prototype.call.bind(unboundSlice);\n\nfunction list() {\n return slice(arguments);\n}\n\nvar list1 = list(1, 2, 3); // [1, 2, 3]\n Although host objects (such as DOM objects) are not required by spec to follow the Mozilla behavior when converted by Array.prototype.slice and IE < 9 does not do so, versions of IE starting with version 9 do allow this. “Shimming” it can allow reliable cross-browser behavior. As long as other modern browsers continue to support this ability, as currently do IE, Mozilla, Chrome, Safari, and Opera, developers reading (DOM-supporting) slice code relying on this shim will not be misled by the semantics; they can safely rely on the semantics to provide the now apparently de facto standard behavior. (The shim also fixes IE to work with the second argument of slice() being an explicit null/undefined value as earlier versions of IE also did not allow but all modern browsers, including IE >= 9, now do.)
/**\n * Shim for \"fixing\" IE's lack of support (IE < 9) for applying slice\n * on host objects like NamedNodeMap, NodeList, and HTMLCollection\n * (technically, since host objects have been implementation-dependent,\n * at least before ES2015, IE hasn't needed to work this way).\n * Also works on strings, fixes IE < 9 to allow an explicit undefined\n * for the 2nd argument (as in Firefox), and prevents errors when\n * called on other DOM objects.\n */\n(function () {\n 'use strict';\n var _slice = Array.prototype.slice;\n\n try {\n // Can't be used with DOM elements in IE < 9\n _slice.call(document.documentElement);\n } catch (e) { // Fails in IE < 9\n // This will work for genuine arrays, array-like objects, \n // NamedNodeMap (attributes, entities, notations),\n // NodeList (e.g., getElementsByTagName), HTMLCollection (e.g., childNodes),\n // and will not fail on other DOM objects (as do DOM elements in IE < 9)\n Array.prototype.slice = function(begin, end) {\n // IE < 9 gets unhappy with an undefined end argument\n end = (typeof end !== 'undefined') ? end : this.length;\n\n // For native Array objects, we use the native slice function\n if (Object.prototype.toString.call(this) === '[object Array]'){\n return _slice.call(this, begin, end); \n }\n\n // For array like object we handle it ourselves.\n var i, cloned = [],\n size, len = this.length;\n\n // Handle negative value for \"begin\"\n var start = begin || 0;\n start = (start >= 0) ? start : Math.max(0, len + start);\n\n // Handle negative value for \"end\"\n var upTo = (typeof end == 'number') ? Math.min(end, len) : len;\n if (end < 0) {\n upTo = len + end;\n }\n\n // Actual expected size of the slice\n size = upTo - start;\n\n if (size > 0) {\n cloned = new Array(size);\n if (this.charAt) {\n for (i = 0; i < size; i++) {\n cloned[i] = this.charAt(start + i);\n }\n } else {\n for (i = 0; i < size; i++) {\n cloned[i] = this[start + i];\n }\n }\n }\n\n return cloned;\n };\n }\n}());\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.slice' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.slice' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.slice' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice\n
The toLocaleString() method returns a string representing the elements of the array. The elements are converted to Strings using their toLocaleString methods and these Strings are separated by a locale-specific String (such as a comma “,”).
arr.toLocaleString([locales[, options]]);\n
locales Optional\nlocales argument, see the Intl page.options Optional\nNumber.prototype.toLocaleString(), and for dates see Date.prototype.toLocaleString().A string representing the elements of the array.
locales and options\nThe elements of the array are converted to strings using their toLocaleString methods.
Object: Object.prototype.toLocaleString()\nNumber: Number.prototype.toLocaleString()\nDate: Date.prototype.toLocaleString()\nAlways display the currency for the strings and numbers in the prices array:
var prices = ['￥7', 500, 8123, 12]; \nprices.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' });\n\n// \"￥7,￥500,￥8,123,￥12\"\n For more examples, see also the Intl, NumberFormat, and DateTimeFormat pages.
// https://tc39.github.io/ecma402/#sup-array.prototype.tolocalestring\nif (!Array.prototype.toLocaleString) {\n Object.defineProperty(Array.prototype, 'toLocaleString', {\n value: function(locales, options) {\n // 1. Let O be ? ToObject(this value).\n if (this == null) {\n throw new TypeError('\"this\" is null or not defined');\n }\n\n var a = Object(this);\n\n // 2. Let len be ? ToLength(? Get(A, \"length\")).\n var len = a.length >>> 0;\n\n // 3. Let separator be the String value for the \n // list-separator String appropriate for the \n // host environment's current locale (this is \n // derived in an implementation-defined way).\n // NOTE: In this case, we will use a comma\n var separator = ',';\n\n // 4. If len is zero, return the empty String.\n if (len === 0) {\n return '';\n }\n\n // 5. Let firstElement be ? Get(A, \"0\").\n var firstElement = a[0];\n // 6. If firstElement is undefined or null, then\n // a.Let R be the empty String.\n // 7. Else,\n // a. Let R be ? \n // ToString(? \n // Invoke(\n // firstElement, \n // \"toLocaleString\", \n // « locales, options »\n // )\n // )\n var r = firstElement == null ? \n '' : firstElement.toLocaleString(locales, options);\n\n // 8. Let k be 1.\n var k = 1;\n\n // 9. Repeat, while k < len\n while (k < len) {\n // a. Let S be a String value produced by \n // concatenating R and separator.\n var s = r + separator;\n\n // b. Let nextElement be ? Get(A, ToString(k)).\n var nextElement = a[k];\n\n // c. If nextElement is undefined or null, then\n // i. Let R be the empty String.\n // d. Else,\n // i. Let R be ? \n // ToString(? \n // Invoke(\n // nextElement, \n // \"toLocaleString\", \n // « locales, options »\n // )\n // )\n r = nextElement == null ? \n '' : nextElement.toLocaleString(locales, options);\n\n // e. Let R be a String value produced by \n // concatenating S and R.\n r = s + r;\n\n // f. Increase k by 1.\n k++;\n }\n\n // 10. Return R.\n return r;\n }\n });\n}\n If you need to support truly obsolete JavaScript engines that don't support Object.defineProperty, it's best not to polyfill Array.prototype methods at all, as you can't make them non-enumerable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.toLocaleString' in that specification. | Draft | Initial definition was in ECMAScript 3. |
| ECMAScript Internationalization API 4.0 (ECMA-402) The definition of 'Array.prototype.toLocaleString' in that specification. | Draft | This definition supersedes the definition provided in ECMA-262. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
Optional locales parameter | \n? | \n? | \n52 | \n? | \n? | \n? | \n
Optional options parameter | \n? | \n? | \n52 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
Optional locales parameter | \n? | \n? | \n? | \nNo | \n? | \n? | \n? | \n
Optional options parameter | \nNo | \n? | \n? | \nNo | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Optional locales parameter | \n? | \n
Optional options parameter | \n? | \n
Array.prototype.toString()IntlObject.prototype.toLocaleString()Number.prototype.toLocaleString()Date.prototype.toLocaleString()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString\n
The Number.POSITIVE_INFINITY property represents the positive Infinity value.
You do not have to create a Number object to access this static property (use Number.POSITIVE_INFINITY).
Property attributes of Number.POSITIVE_INFINITY\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The value of Number.POSITIVE_INFINITY is the same as the value of the global object's Infinity property.
This value behaves slightly differently than mathematical infinity:
POSITIVE_INFINITY, multiplied by POSITIVE_INFINITY is POSITIVE_INFINITY.NEGATIVE_INFINITY, multiplied by POSITIVE_INFINITY is NEGATIVE_INFINITY.POSITIVE_INFINITY is positive Zero.POSITIVE_INFINITY is negative Zero.POSITIVE_INFINITY is NaN.NaN multiplied by POSITIVE_INFINITY is NaN.POSITIVE_INFINITY, divided by any negative value except NEGATIVE_INFINITY, is NEGATIVE_INFINITY.POSITIVE_INFINITY, divided by any positive value except POSITIVE_INFINITY, is POSITIVE_INFINITY.POSITIVE_INFINITY, divided by either NEGATIVE_INFINITY or POSITIVE_INFINITY, is NaN.You might use the Number.POSITIVE_INFINITY property to indicate an error condition that returns a finite number in case of success. Note, however, that isFinite would be more appropriate in such a case.
POSITIVE_INFINITY\nIn the following example, the variable bigNumber is assigned a value that is larger than the maximum value. When the if statement executes, bigNumber has the value Infinity, so bigNumber is set to a more manageable value before continuing.
var bigNumber = Number.MAX_VALUE * 2;\n\nif (bigNumber == Number.POSITIVE_INFINITY) {\n bigNumber = returnFinite();\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.POSITIVE_INFINITY' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.POSITIVE_INFINITY' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.POSITIVE_INFINITY' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY\n
The Number.NEGATIVE_INFINITY property represents the negative Infinity value.
You do not have to create a Number object to access this static property (use Number.NEGATIVE_INFINITY).
Property attributes of Number.NEGATIVE_INFINITY\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The value of Number.NEGATIVE_INFINITY is the same as the negative value of the global object's Infinity property.
This value behaves slightly differently than mathematical infinity:
POSITIVE_INFINITY, multiplied by NEGATIVE_INFINITY is NEGATIVE_INFINITY.NEGATIVE_INFINITY, multiplied by NEGATIVE_INFINITY is POSITIVE_INFINITY.NEGATIVE_INFINITY is negativezero.NEGATIVE_INFINITY is positive zero.NEGATIVE_INFINITY is NaN.NaN multiplied by NEGATIVE_INFINITY is NaN.NEGATIVE_INFINITY, divided by any negative value except NEGATIVE_INFINITY, is POSITIVE_INFINITY.NEGATIVE_INFINITY, divided by any positive value except POSITIVE_INFINITY, is NEGATIVE_INFINITY.NEGATIVE_INFINITY, divided by either NEGATIVE_INFINITY or POSITIVE_INFINITY, is NaN.You might use the Number.NEGATIVE_INFINITY property to indicate an error condition that returns a finite number in case of success. Note, however, that isFinite would be more appropriate in such a case.
NEGATIVE_INFINITY\nIn the following example, the variable smallNumber is assigned a value that is smaller than the minimum value. When the if statement executes, smallNumber has the value -Infinity, so smallNumber is set to a more manageable value before continuing.
var smallNumber = (-Number.MAX_VALUE) * 2;\n\nif (smallNumber === Number.NEGATIVE_INFINITY) {\n smallNumber = returnFinite();\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.NEGATIVE_INFINITY' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.NEGATIVE_INFINITY' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.NEGATIVE_INFINITY' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY\n
The Intl.Collator.prototype.compare property returns a function that compares two strings according to the sort order of this Collator object.
collator.compare(string1, string2)
string1string2The function returned by the compare getter returns a number indicating how string1 and string2 compare to each other according to the sort order of this Collator object: a negative value if string1 comes before string2; a positive value if string1 comes after string2; 0 if they are considered equal.
compare for array sortUse the function returned by the compare getter for sorting arrays. Note that the function is bound to the collator from which it was obtained, so it can be passed directly to Array.prototype.sort().
var a = ['Offenbach', 'Österreich', 'Odenwald'];\nvar collator = new Intl.Collator('de-u-co-phonebk');\na.sort(collator.compare);\nconsole.log(a.join(', '));\n// → \"Odenwald, Österreich, Offenbach\"\n compare for array searchUse the function returned by the compare getter for finding matching strings in arrays:
var a = ['Congrès', 'congres', 'Assemblée', 'poisson'];\nvar collator = new Intl.Collator('fr', { usage: 'search', sensitivity: 'base' });\nvar s = 'congres';\nvar matches = a.filter(v => collator.compare(v, s) === 0);\nconsole.log(matches.join(', '));\n// → \"Congrès, congres\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator/compare\n
The Intl.NumberFormat.prototype property represents the prototype object for the Intl.NumberFormat constructor.
Property attributes of Intl.NumberFormat.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
See NumberFormat for a description of Intl.NumberFormat instances.
Intl.NumberFormat instances inherit from Intl.NumberFormat.prototype. Modifications to the prototype object are inherited by all Intl.NumberFormat instances.
Intl.NumberFormat.prototype.constructorIntl.NumberFormat.Intl.NumberFormat.prototype.formatNumberFormat object.Intl.NumberFormat.prototype.formatToParts()Array of objects representing the number string in parts that can be used for custom locale-aware formatting.Intl.NumberFormat.prototype.resolvedOptions()| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype\n
The Intl.Collator.supportedLocalesOf() method returns an array containing those of the provided locales that are supported in collation without having to fall back to the runtime's default locale.
Intl.Collator.supportedLocalesOf(locales[, options])
localeslocales argument, see the Intl page.optionsOptional. An object that may have the following property:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.An array of strings representing a subset of the given locale tags that are supported in collation without having to fall back to the runtime's default locale.
Returns an array with a subset of the language tags provided in locales. The language tags returned are those for which the runtime supports a locale in collation that the locale matching algorithm used considers a match, so that it wouldn't have to fall back to the default locale.
supportedLocalesOf\nAssuming a runtime that supports Indonesian and German but not Balinese in collation, supportedLocalesOf returns the Indonesian and German language tags unchanged, even though pinyin collation is not used with Indonesian and a specialized German for Indonesia is unlikely to be supported. Note the specification of the \"lookup\" algorithm here — a \"best fit\" matcher might decide that Indonesian is an adequate match for Balinese since most Balinese speakers also understand Indonesian, and therefore return the Balinese language tag as well.
var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];\nvar options = { localeMatcher: 'lookup' };\nconsole.log(Intl.Collator.supportedLocalesOf(locales, options).join(', '));\n// → \"id-u-co-pinyin, de-ID\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator/supportedLocalesOf\n
The Number.isFinite() method determines whether the passed value is a finite number.
Number.isFinite(value)
valueA Boolean indicating whether or not the given value is a finite number.
In comparison to the global isFinite() function, this method doesn't forcibly convert the parameter to a number. This means only values of the type number, that are also finite, return true.
Number.isFinite(Infinity); // false\nNumber.isFinite(NaN); // false\nNumber.isFinite(-Infinity); // false\n\nNumber.isFinite(0); // true\nNumber.isFinite(2e64); // true\n\nNumber.isFinite('0'); // false, would've been true with\n // global isFinite('0')\nNumber.isFinite(null); // false, would've been true with\n // global isFinite(null)\n if (Number.isFinite === undefined) Number.isFinite = function(value) {\n return typeof value === 'number' && isFinite(value);\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.isInteger' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.isInteger' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n19 | \nYes | \n16 | \nNo | \n15 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n16 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite\n
The Intl.NumberFormat.prototype.format property returns a getter function that formats a number according to the locale and formatting options of this NumberFormat object.
numberFormat.format(number)
numberThe function returned by the format getter formats a number into a string according to the locale and formatting options of this NumberFormat object.
format\nUse the function returned by the format getter for formatting a single currency value, here for Russia:
var options = { style: 'currency', currency: 'RUB' };\nvar numberFormat = new Intl.NumberFormat('ru-RU', options);\nconsole.log(numberFormat.format(654321.987));\n// → \"654 321,99 руб.\"\n format with map\nUse the function returned by the format getter for formatting all numbers in an array. Note that the function is bound to the NumberFormat from which it was obtained, so it can be passed directly to Array.prototype.map.
var a = [123456.789, 987654.321, 456789.123];\nvar numberFormat = new Intl.NumberFormat('es-ES');\nvar formatted = a.map(numberFormat.format);\nconsole.log(formatted.join('; '));\n// → \"123.456,789; 987.654,321; 456.789,123\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/format\n
The Intl.NumberFormat.prototype.resolvedOptions() method returns a new object with properties reflecting the locale and number formatting options computed during initialization of this NumberFormat object.
numberFormat.resolvedOptions()
A new object with properties reflecting the locale and number formatting options computed during the initialization of the given NumberFormat object.
The resulting object has the following properties:
localelocale.numberingSystem\"nu\" or filled in as a default.styleuseGroupingoptions argument or filled in as defaults.currencycurrencyDisplayoptions argument or filled in as defaults. These properties are only present if style is \"currency\".Only one of the following two groups of properties is included:
minimumIntegerDigitsminimumFractionDigitsmaximumFractionDigitsoptions argument or filled in as defaults. These properties are present only if neither minimumSignificantDigits nor maximumSignificantDigits was provided in the options argument.minimumSignificantDigitsmaximumSignificantDigitsoptions argument or filled in as defaults. These properties are present only if at least one of them was provided in the options argument.resolvedOptions methodvar de = new Intl.NumberFormat('de-DE');\nvar usedOptions = de.resolvedOptions();\n\nusedOptions.locale; // \"de-DE\"\nusedOptions.numberingSystem; // \"latn\"\nusedOption.style; // \"decimal\"\nusedOptions.minimumIntegerDigits; // 1\nusedOptions.minimumFractionDigits; // 0\nusedOptions.maximumFractionDigits; // 3\nusedOptions.useGrouping; // true\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \n12 | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/resolvedOptions\n
The Intl.NumberFormat.supportedLocalesOf() method returns an array containing those of the provided locales that are supported in number formatting without having to fall back to the runtime's default locale.
Intl.NumberFormat.supportedLocalesOf(locales[, options])
localeslocales argument, see the Intl page.optionsOptional. An object that may have the following property:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.An array of strings representing a subset of the given locale tags that are supported in number formatting without having to fall back to the runtime's default locale.
Returns an array with a subset of the language tags provided in locales. The language tags returned are those for which the runtime supports a locale in number formatting that the locale matching algorithm used considers a match, so that it wouldn't have to fall back to the default locale.
supportedLocalesOf\nAssuming a runtime that supports Indonesian and German but not Balinese in number formatting, supportedLocalesOf returns the Indonesian and German language tags unchanged, even though pinyin collation is neither relevant to number formatting nor used with Indonesian, and a specialized German for Indonesia is unlikely to be supported. Note the specification of the \"lookup\" algorithm here — a \"best fit\" matcher might decide that Indonesian is an adequate match for Balinese since most Balinese speakers also understand Indonesian, and therefore return the Balinese language tag as well.
var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];\nvar options = { localeMatcher: 'lookup' };\nconsole.log(Intl.NumberFormat.supportedLocalesOf(locales, options).join(', '));\n// → \"id-u-co-pinyin, de-ID\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/supportedLocalesOf\n
The localeCompare() method returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order.
The new locales and options arguments let applications specify the language whose sort order should be used and customize the behavior of the function. In older implementations, which ignore the locales and options arguments, the locale and sort order used are entirely implementation dependent.
referenceStr.localeCompare(compareString[, locales[, options]])
Check the Browser compatibility section to see which browsers support the locales and options arguments, and Check browser support for extended arguments for feature detection.
compareStringlocalesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page. The following Unicode extension keys are allowed:
co\"big5han\", \"dict\", \"direct\", \"ducet\", \"gb2312\", \"phonebk\", \"phonetic\", \"pinyin\", \"reformed\", \"searchjl\", \"stroke\", \"trad\", \"unihan\". The \"standard\" and \"search\" values are ignored; they are replaced by the options property usage (see below).kn\"true\" and \"false\". This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence.kf\"upper\", \"lower\", or \"false\" (use the locale's default). This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence.optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.usage\"sort\" and \"search\"; the default is \"sort\".sensitivityWhich differences in the strings should lead to non-zero result values. Possible values are:
\"base\": Only strings that differ in base letters compare as unequal. Examples: a ≠ b, a = á, a = A.\"accent\": Only strings that differ in base letters or accents and other diacritic marks compare as unequal. Examples: a ≠ b, a ≠ á, a = A.\"case\": Only strings that differ in base letters or case compare as unequal. Examples: a ≠ b, a = á, a ≠ A.\"variant\": Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal. Other differences may also be taken into consideration. Examples: a ≠ b, a ≠ á, a ≠ A.The default is \"variant\" for usage \"sort\"; it's locale dependent for usage \"search\".
ignorePunctuationtrue and false; the default is false.numerictrue and false; the default is false. This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence. Implementations are not required to support this property.caseFirst\"upper\", \"lower\", or \"false\" (use the locale's default); the default is \"false\". This option can be set through an options property or through a Unicode extension key; if both are provided, the options property takes precedence. Implementations are not required to support this property.A negative number if the reference string occurs before the compare string; positive if the reference string occurs after the compare string; 0 if they are equivalent.
Returns an integer indicating whether the referenceStr comes before, after or is equivalent to the compareStr.
DO NOT rely on exact return values of -1 or 1. Negative and positive integer results vary between browsers (as well as between browser versions) because the W3C specification only mandates negative and positive values. Some browsers may return -2 or 2 or even some other negative or positive value.
localeCompare()\n// The letter \"a\" is before \"c\" yielding a negative value\n'a'.localeCompare('c'); // -2 or -1 (or some other negative value)\n\n// Alphabetically the word \"check\" comes after \"against\" yielding a positive value\n'check'.localeCompare('against'); // 2 or 1 (or some other positive value)\n\n// \"a\" and \"a\" are equivalent yielding a neutral value of zero\n'a'.localeCompare('a'); // 0\n localeCompare enables a case-insensitive sort of an array.
var items = ['réservé', 'Premier', 'Cliché', 'communiqué', 'café', 'Adieu'];\nitems.sort((a, b) => a.localeCompare(b, 'fr', {ignorePunctuation: true})); // ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé']\n The locales and options arguments are not supported in all browsers yet. To check whether an implementation supports them, use the \"i\" argument (a requirement that illegal language tags are rejected) and look for a RangeError exception:
function localeCompareSupportsLocales() {\n try {\n 'foo'.localeCompare('bar', 'i');\n } catch (e) {\n return e.name === 'RangeError';\n }\n return false;\n}\n locales\nThe results provided by localeCompare() vary between languages. In order to get the sort order of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:
console.log('ä'.localeCompare('z', 'de')); // a negative value: in German, ä sorts before z\nconsole.log('ä'.localeCompare('z', 'sv')); // a positive value: in Swedish, ä sorts after z\n options\nThe results provided by localeCompare() can be customized using the options argument:
// in German, ä has a as the base letter\nconsole.log('ä'.localeCompare('a', 'de', { sensitivity: 'base' })); // 0\n\n// in Swedish, ä and a are separate base letters\nconsole.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // a positive value\n // by default, \"2\" > \"10\"\nconsole.log(); // 1\n\n// numeric using options:\nconsole.log(); // -1\n\n// numeric using locales tag:\nconsole.log(); // -1\n
When comparing large numbers of strings, such as in sorting large arrays, it is better to create an Intl.Collator object and use the function provided by its compare property.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.localeCompare' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.localeCompare' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.localeCompare' in that specification. | Draft | |
| ECMAScript Internationalization API 1.0 (ECMA-402) The definition of 'String.prototype.localeCompare' in that specification. | Standard | \nlocale and option parameter definitions. |
| ECMAScript Internationalization API 2.0 (ECMA-402) The definition of 'String.prototype.localeCompare' in that specification. | Standard | |
| ECMAScript Internationalization API 4.0 (ECMA-402) The definition of 'String.prototype.localeCompare' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
locales | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
options | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
locales | \nNo | \n26 | \n? | \nNo | \nNo | \n10 | \nYes | \n
options | \nNo | \n26 | \n? | \nNo | \nNo | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
locales | \n? | \n
options | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare\n
The toLocaleString() method returns a string with a language-sensitive representation of this number.
The new locales and options arguments customize the behavior of the function and let applications specify the language whose formatting conventions should be used. In older implementations, which ignore the locales and options arguments, the locale used and the form of the string returned are entirely implementation dependent.
numObj.toLocaleString([locales [, options]])
Check the Browser compatibility section to see which browsers support the locales and options arguments, and the Example: Checking for support for locales and options arguments for feature detection.
Note: ECMAScript Internationalization API, implemented with Firefox 29, added the locales argument to the Number.toLocaleString() method. If the argument is undefined, this method returns localized digits specified by the OS, while the previous versions of Firefox returned Western Arabic digits. This change has been reported as a regression affecting backward compatibility which might be fixed soon. (bug 999003)
localesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page. The following Unicode extension key is allowed:
nu\"arab\", \"arabext\", \"bali\", \"beng\", \"deva\", \"fullwide\", \"gujr\", \"guru\", \"hanidec\", \"khmr\", \"knda\", \"laoo\", \"latn\", \"limb\", \"mlym\", \"mong\", \"mymr\", \"orya\", \"tamldec\", \"telu\", \"thai\", \"tibt\".optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.style\"decimal\" for plain number formatting, \"currency\" for currency formatting, and \"percent\" for percent formatting; the default is \"decimal\".currency\"USD\" for the US dollar, \"EUR\" for the euro, or \"CNY\" for the Chinese RMB — see the Current currency & funds code list. There is no default value; if the style is \"currency\", the currency property must be provided.currencyDisplay\"symbol\" to use a localized currency symbol such as €, \"code\" to use the ISO currency code, \"name\" to use a localized currency name such as \"dollar\"; the default is \"symbol\".useGroupingtrue and false; the default is true.The following properties fall into two groups: minimumIntegerDigits, minimumFractionDigits, and maximumFractionDigits in one group, minimumSignificantDigits and maximumSignificantDigits in the other. If at least one property from the second group is defined, then the first group is ignored.
minimumIntegerDigitsminimumFractionDigitsmaximumFractionDigitsminimumFractionDigits and 3; the default for currency formatting is the larger of minimumFractionDigits and the number of minor unit digits provided by the ISO 4217 currency code list (2 if the list doesn't provide that information); the default for percent formatting is the larger of minimumFractionDigits and 0.minimumSignificantDigitsmaximumSignificantDigitsA string with a language-sensitive representation of the given number.
toLocaleString\nIn basic use without specifying a locale, a formatted string in the default locale and with default options is returned.
var number = 3500;\n\nconsole.log(number.toLocaleString()); // Displays \"3,500\" if in U.S. English locale\n
locales and options argumentsThe locales and options arguments are not supported in all browsers yet. To check for support in ES5.1 and later implementations, the requirement that illegal language tags are rejected with a RangeError exception can be used:
function toLocaleStringSupportsLocales() {\n var number = 0;\n try {\n number.toLocaleString('i');\n } catch (e) {\n return e.name === 'RangeError';\n }\n return false;\n}\n Prior to ES5.1, implementations were not required to throw a range error exception if toLocaleString is called with arguments.
A check that works in all hosts, including those supporting ECMA-262 prior to ed 5.1, is to test for the features specified in ECMA-402 that are required to support regional options for Number.prototype.toLocaleString directly:
function toLocaleStringSupportsOptions() {\n return !!(typeof Intl == 'object' && Intl && typeof Intl.NumberFormat == 'function');\n}\n This tests for a global Intl object, checks that it's not null and that it has a NumberFormat property that is a function.
locales\nThis example shows some of the variations in localized number formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:
var number = 123456.789;\n\n// German uses comma as decimal separator and period for thousands\nconsole.log(number.toLocaleString('de-DE'));\n// → 123.456,789\n\n// Arabic in most Arabic speaking countries uses Eastern Arabic digits\nconsole.log(number.toLocaleString('ar-EG'));\n// → ١٢٣٤٥٦٫٧٨٩\n\n// India uses thousands/lakh/crore separators\nconsole.log(number.toLocaleString('en-IN'));\n// → 1,23,456.789\n\n// the nu extension key requests a numbering system, e.g. Chinese decimal\nconsole.log(number.toLocaleString('zh-Hans-CN-u-nu-hanidec'));\n// → 一二三,四五六.七八九\n\n// when requesting a language that may not be supported, such as\n// Balinese, include a fallback language, in this case Indonesian\nconsole.log(number.toLocaleString(['ban', 'id']));\n// → 123.456,789\n options\nThe results provided by toLocaleString can be customized using the options argument:
var number = 123456.789;\n\n// request a currency format\nconsole.log(number.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' }));\n// → 123.456,79 €\n\n// the Japanese yen doesn't use a minor unit\nconsole.log(number.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' }))\n// → ￥123,457\n\n// limit to three significant digits\nconsole.log(number.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));\n// → 1,23,000\n\n// Use the host default language with options for number formatting\nvar num = 30000.65;\nconsole.log(num.toLocaleString(undefined, {minimumFractionDigits: 2, maximumFractionDigits: 2}));\n// → \"30,000.65\" where English is the default language, or\n// → \"30.000,65\" where German is the default language, or\n// → \"30 000,65\" where French is the default language\n When formatting large numbers of numbers, it is better to create a NumberFormat object and use the function provided by its NumberFormat.format property.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
locales | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
options | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
locales | \nNo | \n26 | \n? | \nNo | \nNo | \n10 | \nYes | \n
options | \nNo | \n26 | \n? | \nNo | \nNo | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
locales | \nYes | \n
options | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString\n
The toLocaleString() method returns a string with a language sensitive representation of this date. The new locales and options arguments let applications specify the language whose formatting conventions should be used and customize the behavior of the function. In older implementations, which ignore the locales and options arguments, the locale used and the form of the string returned are entirely implementation dependent.
dateObj.toLocaleString([locales[, options]])
Check the Browser compatibility section to see which browsers support the locales and options arguments, and the Example: Checking for support for locales and options arguments for feature detection.
localesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page. The following Unicode extension keys are allowed:
nu\"arab\", \"arabext\", \"bali\", \"beng\", \"deva\", \"fullwide\", \"gujr\", \"guru\", \"hanidec\", \"khmr\", \"knda\", \"laoo\", \"latn\", \"limb\", \"mlym\", \"mong\", \"mymr\", \"orya\", \"tamldec\", \"telu\", \"thai\", \"tibt\".ca\"buddhist\", \"chinese\", \"coptic\", \"ethioaa\", \"ethiopic\", \"gregory\", \"hebrew\", \"indian\", \"islamic\", \"islamicc\", \"iso8601\", \"japanese\", \"persian\", \"roc\".hc\"h11\", \"h12\", \"h23\", \"h24\".optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.timeZone\"UTC\"; the default is the runtime's default time zone. Implementations may also recognize the time zone names of the IANA time zone database, such as \"Asia/Shanghai\", \"Asia/Kolkata\", \"America/New_York\".hour12true and false; the default is locale dependent. This option overrides the hc language tag and/or the hourCycle option in case both are present.hourCycle\"h11\", \"h12\", \"h23\", or \"h24\". This option overrides the hc language tag, if both are present, and the hour12 option takes precedence in case both options have been specified.formatMatcher\"basic\" and \"best fit\"; the default is \"best fit\". See the following paragraphs for information about the use of this property.The following properties describe the date-time components to use in formatted output, and their desired representations. Implementations are required to support at least the following subsets:
weekday, year, month, day, hour, minute, second\nweekday, year, month, day\nyear, month, day\nyear, month\nmonth, day\nhour, minute, second\nhour, minute\nImplementations may support other subsets, and requests will be negotiated against all available subset-representation combinations to find the best match. Two algorithms are available for this negotiation and selected by the formatMatcher property: A fully specified \"basic\" algorithm and an implementation-dependent \"best fit\" algorithm.
weekday\"narrow\", \"short\", \"long\".era\"narrow\", \"short\", \"long\".year\"numeric\", \"2-digit\".month\"numeric\", \"2-digit\", \"narrow\", \"short\", \"long\".day\"numeric\", \"2-digit\".hour\"numeric\", \"2-digit\".minute\"numeric\", \"2-digit\".second\"numeric\", \"2-digit\".timeZoneName\"short\", \"long\".The default value for each date-time component property is undefined, but if the weekday, year, month, day, hour, minute, second properties are all undefined, then year, month, day, hour, minute, and second are assumed to be \"numeric\".
A string representing the given date according to language-specific conventions.
toLocaleString()\nIn basic use without specifying a locale, a formatted string in the default locale and with default options is returned.
var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));\n\n// toLocaleString() without arguments depends on the implementation,\n// the default locale, and the default time zone\nconsole.log(date.toLocaleString());\n// → \"12/11/2012, 7:00:00 PM\" if run in en-US locale with time zone America/Los_Angeles\n
locales and options argumentsThe locales and options arguments are not supported in all browsers yet. To check whether an implementation supports them already, you can use the requirement that illegal language tags are rejected with a RangeError exception:
function toLocaleStringSupportsLocales() {\n try {\n new Date().toLocaleString('i');\n } catch (e) {\n return e instanceof RangeError;\n }\n return false;\n}\n locales\nThis example shows some of the variations in localized date and time formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));\n\n// formats below assume the local time zone of the locale;\n// America/Los_Angeles for the US\n\n// US English uses month-day-year order and 12-hour time with AM/PM\nconsole.log(date.toLocaleString('en-US'));\n// → \"12/19/2012, 7:00:00 PM\"\n\n// British English uses day-month-year order and 24-hour time without AM/PM\nconsole.log(date.toLocaleString('en-GB'));\n// → \"20/12/2012 03:00:00\"\n\n// Korean uses year-month-day order and 12-hour time with AM/PM\nconsole.log(date.toLocaleString('ko-KR'));\n// → \"2012. 12. 20. 오후 12:00:00\"\n\n// Arabic in most Arabic speaking countries uses real Arabic digits\nconsole.log(date.toLocaleString('ar-EG'));\n// → \"٢٠/١٢/٢٠١٢ ٥:٠٠:٠٠ ص\"\n\n// for Japanese, applications may want to use the Japanese calendar,\n// where 2012 was the year 24 of the Heisei era\nconsole.log(date.toLocaleString('ja-JP-u-ca-japanese'));\n// → \"24/12/20 12:00:00\"\n\n// when requesting a language that may not be supported, such as\n// Balinese, include a fallback language, in this case Indonesian\nconsole.log(date.toLocaleString(['ban', 'id']));\n// → \"20/12/2012 11.00.00\"\n options\nThe results provided by toLocaleString() can be customized using the options argument:
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));\n\n// request a weekday along with a long date\nvar options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };\nconsole.log(date.toLocaleString('de-DE', options));\n// → \"Donnerstag, 20. Dezember 2012\"\n\n// an application may want to use UTC and make that visible\noptions.timeZone = 'UTC';\noptions.timeZoneName = 'short';\nconsole.log(date.toLocaleString('en-US', options));\n// → \"Thursday, December 20, 2012, GMT\"\n\n// sometimes even the US needs 24-hour time\nconsole.log(date.toLocaleString('en-US', { hour12: false }));\n// → \"12/19/2012, 19:00:00\"\n When formatting large numbers of dates, it is better to create an Intl.DateTimeFormat object and use the function provided by its format property.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.toLocaleString' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.toLocaleString' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.toLocaleString' in that specification. | Draft | |
| ECMAScript Internationalization API 1.0 (ECMA-402) The definition of 'Date.prototype.toLocaleString' in that specification. | Standard | Defines locales and options arguments. |
| ECMAScript Internationalization API 2.0 (ECMA-402) The definition of 'Date.prototype.toLocaleString' in that specification. | Standard | |
| ECMAScript Internationalization API 4.0 (ECMA-402) The definition of 'Date.prototype.toLocaleString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
locales | \n24 | \n? | \n29 | \n11 | \n15 | \n10 | \n
options | \n24 | \n? | \n29 | \n11 | \n15 | \n10 | \n
IANA time zone names in timeZone option | \n24 | \n? | \n52 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
locales | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
options | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
IANA time zone names in timeZone option | \n? | \n? | \n? | \nNo | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
locales | \n? | \n
options | \n? | \n
IANA time zone names in timeZone option | \n? | \n
Intl.DateTimeFormatDate.prototype.toLocaleDateString()Date.prototype.toLocaleTimeString()Date.prototype.toString()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString\n
This is an experimental technology
Check the Browser compatibility table carefully before using this in production.
The Intl.Numberformat.prototype.formatToParts() method allows locale-aware formatting of strings produced by NumberTimeFormat formatters.
Intl.NumberFormat.prototype.formatToParts(number)
number Optional\nAn Array of objects containing the formatted number in parts.
The formatToParts() method is useful for custom formatting of number strings. It returns an Array of objects containing the locale-specific tokens from which it possible to build custom strings while preserving the locale-specific parts. The structure the formatToParts() method returns, looks like this:
[\n { type: \"integer\", value: \"3\" }\n { type: \"group\", value: \".\" }\n { type: \"integer\", value: \"500\" }\n] Possible types are the following:
currencyDisplay is specified.Infinity string (\"∞\").NaN string (\"NaN\").NumberFormat outputs localized, opaque strings that cannot be manipulated directly:
var number = 3500;\n\nvar formatter = new Intl.NumberFormat('de-DE', { \n style: 'currency', \n currency: 'EUR' \n});\n\nformatter.format(number);\n// \"3.500,00 €\"\n However, in many User Interfaces there is a desire to customize the formatting of this string. The formatToParts method enables locale-aware formatting of strings produced by NumberFormat formatters by providing you the string in parts:
formatter.formatToParts(number);\n\n// return value: \n[ \n { type: \"integer\", value: \"3\" }\n { type: \"group\", value: \".\" }\n { type: \"integer\", value: \"500\" }\n { type: \"decimal\", value: \",\" }\n { type: \"fraction\", value: \"00\" }\n { type: \"literal\", value: \" \" }\n { type: \"currency\", value: \"€\" }\n]\n Now the information is available separately and it can be formatted and concatenated again in a customized way. For example by using Array.prototype.map(), arrow functions, a switch statement, template literals, and Array.prototype.reduce().
var numberString = formatter.formatToParts(number).map(({type, value}) => { \n switch (type) {\n case 'currency': return `<strong>${value}</strong>`; \n default : return value; \n } \n}).reduce((string, part) => string + part);\n This will make the currency bold, when using the formatToParts() method.
console.log(numberString);\n// \"3.500,00 <strong>€</strong>\"
A polyfill for this feature is available in the proposal repository.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Internationalization API 4.0 (ECMA-402) The definition of 'Intl.NumberFormat.prototype.formatToParts' in that specification. | Draft | Initial definition |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \n 63\n
| \nYes | \n58 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nNo | \n 63\n
| \n? | \n? | \n? | \n? | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \n? | \n
Intl.NumberFormatIntl.NumberFormat.prototype.formatIntl.DateTimeFormat.prototype.formatToParts()\n\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/formatToParts\n
The Intl.PluralRules.prototype property represents the prototype object for the Intl.PluralRules constructor.
Property attributes of Intl.PluralRules.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
See PluralRules for a description of Intl.PluralRules instances.
Intl.PluralRules instances inherit from Intl.PluralRules.prototype. Modifications to the prototype object are inherited by all Intl.PluralRules instances.
Intl.PluralRules.prototype.constructorIntl.PluralRules.Intl.PluralRules.prototype.resolvedOptions()Intl.PluralRules.prototype.select()String indicating which plurar rule to use for locale-aware formatting.| Specification | Status | Comment |
|---|---|---|
| Intl Plural Rules Draft | Draft | Initial definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n63 | \nYes | \n58 | \nNo | \n50 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules/prototype\n
The Intl.DateTimeFormat.prototype.format property returns a getter function that formats a date according to the locale and formatting options of this Intl.DateTimeFormat object.
dateTimeFormat.format(date)
dateThe function returned by the format getter formats a date into a string according to the locale and formatting options of this Intl.DateTimeFormat object.
format\nUse the function returned by the format getter for formatting a single date, here for Serbia:
var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };\nvar dateTimeFormat = new Intl.DateTimeFormat('sr-RS', options);\nconsole.log(dateTimeFormat.format(new Date()));\n// → \"недеља, 7. април 2013.\"\n format with map\nUse the function returned by the format getter for formatting all dates in an array. Note that the function is bound to the Intl.DateTimeFormat from which it was obtained, so it can be passed directly to Array.prototype.map().
var a = [new Date(2012, 08), new Date(2012, 11), new Date(2012, 03)];\nvar options = { year: 'numeric', month: 'long' };\nvar dateTimeFormat = new Intl.DateTimeFormat('pt-BR', options);\nvar formatted = a.map(dateTimeFormat.format);\nconsole.log(formatted.join('; '));\n// → \"setembro de 2012; dezembro de 2012; abril de 2012\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \n12 | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
Intl.DateTimeFormatDate.prototype.toLocaleString()Date.prototype.toLocaleDateString()Date.prototype.toLocaleTimeString()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/format\n
The JSON.parse() method parses a JSON string, constructing the JavaScript value or object described by the string. An optional reviver function can be provided to perform a transformation on the resulting object before it is returned.
JSON.parse(text[, reviver])
textJSON object for a description of JSON syntax.reviver Optional\nThe Object corresponding to the given JSON text.
Throws a SyntaxError exception if the string to parse is not valid JSON.
JSON.parse()\nJSON.parse('{}'); // {}\nJSON.parse('true'); // true\nJSON.parse('\"foo\"'); // \"foo\"\nJSON.parse('[1, 5, \"false\"]'); // [1, 5, \"false\"]\nJSON.parse('null'); // null\n reviver parameterIf a reviver is specified, the value computed by parsing is transformed before being returned. Specifically, the computed value and all its properties (beginning with the most nested properties and proceeding to the original value itself) are individually run through the reviver. Then it is called, with the object containing the property being processed as this, and with the property name as a string, and the property value as arguments. If the reviver function returns undefined (or returns no value, for example, if execution falls off the end of the function), the property is deleted from the object. Otherwise, the property is redefined to be the return value.
If the reviver only transforms some values and not others, be certain to return all untransformed values as-is, otherwise they will be deleted from the resulting object.
JSON.parse('{\"p\": 5}', (key, value) =>\n typeof value === 'number'\n ? value * 2 // return value * 2 for numbers\n : value // return everything else unchanged\n);\n\n// { p: 10 }\n\nJSON.parse('{\"1\": 1, \"2\": 2, \"3\": {\"4\": 4, \"5\": {\"6\": 6}}}', (key, value) => {\n console.log(key); // log the current property name, the last is \"\".\n return value; // return the unchanged property value.\n});\n\n// 1\n// 2\n// 4\n// 6\n// 5\n// 3 \n// \"\"\n JSON.parse() does not allow trailing commas// both will throw a SyntaxError\nJSON.parse('[1, 2, 3, 4, ]');\nJSON.parse('{\"foo\" : 1, }');\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'JSON.parse' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.7. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'JSON.parse' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'JSON.parse' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n3.5 | \n8 | \n10.5 | \n4 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse\n
The Intl.DateTimeFormat.supportedLocalesOf() method returns an array containing those of the provided locales that are supported in date and time formatting without having to fall back to the runtime's default locale.
Intl.DateTimeFormat.supportedLocalesOf(locales[, options])
localeslocales argument, see the Intl page.optionsOptional. An object that may have the following property:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.An array of strings representing a subset of the given locale tags that are supported in date and time formatting without having to fall back to the runtime's default locale.
Returns an array with a subset of the language tags provided in locales. The language tags returned are those for which the runtime supports a locale in date and time formatting that the locale matching algorithm used considers a match, so that it wouldn't have to fall back to the default locale.
supportedLocalesOf\nAssuming a runtime that supports Indonesian and German but not Balinese in date and time formatting, supportedLocalesOf returns the Indonesian and German language tags unchanged, even though pinyin collation is neither relevant to date and time formatting nor used with Indonesian, and a specialized German for Indonesia is unlikely to be supported. Note the specification of the \"lookup\" algorithm here — a \"best fit\" matcher might decide that Indonesian is an adequate match for Balinese since most Balinese speakers also understand Indonesian, and therefore return the Balinese language tag as well.
var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];\nvar options = { localeMatcher: 'lookup' };\nconsole.log(Intl.DateTimeFormat.supportedLocalesOf(locales, options).join(', '));\n// → \"id-u-co-pinyin, de-ID\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/supportedLocalesOf\n
The JSON.stringify() method converts a JavaScript object or value to a JSON string, optionally replacing values if a replacer function is specified or optionally including only the specified properties if a replacer array is specified.
JSON.stringify(value[, replacer[, space]])
valuereplacerOptional\nString and Number objects that serve as a whitelist for selecting/filtering the properties of the value object to be included in the JSON string. If this value is null or not provided, all properties of the object are included in the resulting JSON string.spaceOptional\nString or Number object that's used to insert white space into the output JSON string for readability purposes. If this is a Number, it indicates the number of space characters to use as white space; this number is capped at 10 (if it is greater, the value is just 10). Values less than 1 indicate that no space should be used.
If this is a String, the string (or the first 10 characters of the string, if it's longer than that) is used as white space. If this parameter is not provided (or is null), no white space is used.
A JSON string representing the given value.
Throws a TypeError (\"cyclic object value\") exception when a circular reference is found.
JSON.stringify() converts a value to JSON notation representing it:
Boolean, Number, and String objects are converted to the corresponding primitive values during stringification, in accord with the traditional conversion semantics.undefined, a Function, or a Symbol is encountered during conversion it is either omitted (when it is found in an object) or censored to null (when it is found in an array). JSON.stringify() can also just return undefined when passing in \"pure\" values like JSON.stringify(function(){}) or JSON.stringify(undefined).Symbol-keyed properties will be completely ignored, even when using the replacer function.Date implement the toJSON() function by returning a string (the same as date.toISOString()). Thus, they are treated as strings.Infinity and NaN, as well as the value null, are all considered null.Object instances (including Map, Set, WeakMap, and WeakSet) will have only their enumerable properties serialized.JSON.stringify({}); // '{}'\nJSON.stringify(true); // 'true'\nJSON.stringify('foo'); // '\"foo\"'\nJSON.stringify([1, 'false', false]); // '[1,\"false\",false]'\nJSON.stringify([NaN, null, Infinity]); // '[null,null,null]'\nJSON.stringify({ x: 5 }); // '{\"x\":5}'\n\nJSON.stringify(new Date(2006, 0, 2, 15, 4, 5)) \n// '\"2006-01-02T15:04:05.000Z\"'\n\nJSON.stringify({ x: 5, y: 6 });\n// '{\"x\":5,\"y\":6}'\nJSON.stringify([new Number(3), new String('false'), new Boolean(false)]);\n// '[3,\"false\",false]'\n\n// String-keyed array elements are not enumerable and make no sense in JSON\nlet a = ['foo', 'bar'];\na['baz'] = 'quux'; // a: [ 0: 'foo', 1: 'bar', baz: 'quux' ]\nJSON.stringify(a); \n// '[\"foo\",\"bar\"]'\n\nJSON.stringify({ x: [10, undefined, function(){}, Symbol('')] }); \n// '{\"x\":[10,null,null,null]}' \n\n// Standard data structures\nJSON.stringify([new Set([1]), new Map([[1, 2]]), new WeakSet([{a: 1}]), new WeakMap([[{a: 1}, 2]])]);\n// '[{},{},{},{}]'\n\n// TypedArray\nJSON.stringify([new Int8Array([1]), new Int16Array([1]), new Int32Array([1])]);\n// '[{\"0\":1},{\"0\":1},{\"0\":1}]'\nJSON.stringify([new Uint8Array([1]), new Uint8ClampedArray([1]), new Uint16Array([1]), new Uint32Array([1])]);\n// '[{\"0\":1},{\"0\":1},{\"0\":1},{\"0\":1}]'\nJSON.stringify([new Float32Array([1]), new Float64Array([1])]);\n// '[{\"0\":1},{\"0\":1}]'\n \n// toJSON()\nJSON.stringify({ x: 5, y: 6, toJSON(){ return this.x + this.y; } });\n// '11'\n\n// Symbols:\nJSON.stringify({ x: undefined, y: Object, z: Symbol('') });\n// '{}'\nJSON.stringify({ [Symbol('foo')]: 'foo' });\n// '{}'\nJSON.stringify({ [Symbol.for('foo')]: 'foo' }, [Symbol.for('foo')]);\n// '{}'\nJSON.stringify({ [Symbol.for('foo')]: 'foo' }, function(k, v) {\n if (typeof k === 'symbol') {\n return 'a symbol';\n }\n});\n// undefined\n\n// Non-enumerable properties:\nJSON.stringify( Object.create(null, { x: { value: 'x', enumerable: false }, y: { value: 'y', enumerable: true } }) );\n// '{\"y\":\"y\"}'\n replacer parameterThe replacer parameter can be either a function or an array.
As a function, it takes two parameters: the key and the value being stringified. The object in which the key was found is provided as the replacer's this parameter.
Initially, the replacer function is called with an empty string as key representing the object being stringified. It is then called for each property on the object or array being stringified.
It should return the value that should be added to the JSON string, as follows:
Number, the string corresponding to that number is used as the value for the property when added to the JSON string.String, that string is used as the property's value when adding it to the JSON string.Boolean, \"true\" or \"false\" is used as the property's value, as appropriate, when adding it to the JSON string.null, null will be added to the JSON string.replacer function on each property, unless the object is a function, in which case nothing is added to the JSON string.undefined, the property is not included (i.e., filtered out) in the output JSON string.Note: You cannot use the replacer function to remove values from an array. If you return undefined or a function then null is used instead.
Note: If you wish the replacer to distinguish an initial object from a key with an empty string property (since both would give the empty string as key and potentially an object as value), you will have to keep track of the iteration count (if it is beyond the first iteration, it is a genuine empty string key).
function replacer(key, value) {\n // Filtering out properties\n if (typeof value === 'string') {\n return undefined;\n }\n return value;\n}\n\nvar foo = {foundation: 'Mozilla', model: 'box', week: 45, transport: 'car', month: 7};\nJSON.stringify(foo, replacer);\n// '{\"week\":45,\"month\":7}'\n If replacer is an array, the array's values indicate the names of the properties in the object that should be included in the resulting JSON string.
JSON.stringify(foo, ['week', 'month']); \n// '{\"week\":45,\"month\":7}', only keep \"week\" and \"month\" properties\n space argumentThe space argument may be used to control spacing in the final string.
JSON.stringify({ a: 2 }, null, ' ');\n// '{\n// \"a\": 2\n// }'\n Using a tab character mimics standard pretty-print appearance:
JSON.stringify({ uno: 1, dos: 2 }, null, '\\t');\n// returns the string:\n// '{\n// \"uno\": 1,\n// \"dos\": 2\n// }'\n toJSON() behaviorIf an object being stringified has a property named toJSON whose value is a function, then the toJSON() method customizes JSON stringification behavior: instead of the object being serialized, the value returned by the toJSON() method when called will be serialized. JSON.stringify() calls toJSON with one parameter:
JSON.stringify() was directly called on this objectFor example:
var obj = {\n data: 'data',\n \n toJSON(key){\n if(key)\n return `Now I am a nested object under key '${key}'`;\n \n else\n return this;\n }\n};\n\nJSON.stringify(obj);\n// '{\"data\":\"data\"}'\n\nJSON.stringify({ obj })\n// '{\"obj\":\"Now I am a nested object under key 'obj'\"}'\n\nJSON.stringify([ obj ])\n// '[\"Now I am a nested object under key '0'\"]'\n JSON.stringify() when serializing circular referencesNote that since the JSON format doesn't support object references (although an IETF draft exists), a TypeError will be thrown if one attempts to encode an object with circular references.
const circularReference = {};\ncircularReference.myself = circularReference;\n\n// Serializing circular references throws \"TypeError: cyclic object value\"\nJSON.stringify(circularReference);\n To serialize circular references you can use a library that supports them (e.g. cycle.js by Douglas Crockford) or implement a solution by yourself, which will require finding and replacing (or removing) the cyclic references by serializable values.
JSON.stringify for use as JavaScriptNote that JSON is not a completely strict subset of JavaScript, with two line terminators (Line separator and Paragraph separator) which do not require escaping in JSON, but do require escaping in JavaScript.
Therefore, if the JSON is meant to be evaluated or directly utilized within JSONP, the following utility can be used:
function jsFriendlyJSONStringify (s) {\n return JSON.stringify(s).\n replace(/\\u2028/g, '\\\\u2028').\n replace(/\\u2029/g, '\\\\u2029');\n}\n\nvar s = {\n a: String.fromCharCode(0x2028),\n b: String.fromCharCode(0x2029)\n};\ntry {\n eval('(' + JSON.stringify(s) + ')');\n} catch (e) {\n console.log(e); // \"SyntaxError: unterminated string literal\"\n}\n\n// No need for a catch\neval('(' + jsFriendlyJSONStringify(s) + ')');\n\n// console.log in Firefox unescapes the Unicode if\n// logged to console, so we use alert\nalert(jsFriendlyJSONStringify(s)); // {\"a\":\"\\u2028\",\"b\":\"\\u2029\"}\n Note: Properties of non-array objects are not guaranteed to be stringified in any particular order. Do not rely on ordering of properties within the same object within the stringification.
var a = JSON.stringify({ foo: \"bar\", baz: \"quux\" })\n//'{\"foo\":\"bar\",\"baz\":\"quux\"}'\nvar b = JSON.stringify({ baz: \"quux\", foo: \"bar\" })\n//'{\"baz\":\"quux\",\"foo\":\"bar\"}'\nconsole.log(a !== b) // true\n\n// some memoization function use the JSON.stringify to serialize arguments,\n// which may missing the cache when encountering the same object like above\n JSON.stringify() with localStorage\nIn a case where you want to store an object created by your user and allowing it to be restored even after the browser has been closed, the following example is a model for the applicability of JSON.stringify():
// Creating an example of JSON\nvar session = {\n 'screens': [],\n 'state': true\n};\nsession.screens.push({ 'name': 'screenA', 'width': 450, 'height': 250 });\nsession.screens.push({ 'name': 'screenB', 'width': 650, 'height': 350 });\nsession.screens.push({ 'name': 'screenC', 'width': 750, 'height': 120 });\nsession.screens.push({ 'name': 'screenD', 'width': 250, 'height': 60 });\nsession.screens.push({ 'name': 'screenE', 'width': 390, 'height': 120 });\nsession.screens.push({ 'name': 'screenF', 'width': 1240, 'height': 650 });\n\n// Converting the JSON string with JSON.stringify()\n// then saving with localStorage in the name of session\nlocalStorage.setItem('session', JSON.stringify(session));\n\n// Example of how to transform the String generated through \n// JSON.stringify() and saved in localStorage in JSON object again\nvar restoredSession = JSON.parse(localStorage.getItem('session'));\n\n// Now restoredSession variable contains the object that was saved\n// in localStorage\nconsole.log(restoredSession);\n JSON.stringify()\nEngines implementing the well-formed JSON.stringify specfication, prevent returning ill-formed Unicode strings. Previously, JSON.stringify would output lone surrogates if the input contained any lone surrogates, which is invalid UTF-8:
JSON.stringify(\"\\uD800\"); // '\"�\"'
With this change, rather than return unpaired surrogate code points as single UTF-16 code units, JSON.stringify represents them with JSON escape sequences:
JSON.stringify(\"\\uD800\"); // \"\\ud800\"'
Unicode escape sequences are valid JSON and are well-formed in both UTF-16 and UTF-8.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'JSON.stringify' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.7. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'JSON.stringify' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'JSON.stringify' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n3.5 | \n8 | \n10.5 | \n4 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
JSON.parse()JSON.decycle and JSON.retrocycle. These allow encoding and decoding of cyclical structures and DAGs into an extended and retrocompatible JSON format.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify\n
The Intl.DateTimeFormat.prototype property represents the prototype object for the Intl.DateTimeFormat constructor.
Property attributes of Intl.DateTimeFormat.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
See DateTimeFormat for a description of Intl.DateTimeFormat instances.
Intl.DateTimeFormat instances inherit from Intl.DateTimeFormat.prototype. Modifications to the prototype object are inherited by all Intl.DateTimeFormat instances.
Intl.DateTimeFormat.prototype.constructorIntl.DateTimeFormat.Intl.DateTimeFormat.prototype.formatDateTimeFormat object.Intl.DateTimeFormat.prototype.formatToParts()Array of objects representing the date string in parts that can be used for custom locale-aware formatting.Intl.DateTimeFormat.prototype.resolvedOptions()| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/prototype\n
The Intl.DateTimeFormat.prototype.resolvedOptions() method returns a new object with properties reflecting the locale and date and time formatting options computed during initialization of this DateTimeFormat object.
dateTimeFormat.resolvedOptions()
A new object with properties reflecting the locale and date and time formatting options computed during the initialization of the given DateTimeFormat object.
The resulting object has the following properties:
localelocale.calendarnumberingSystem\"ca\" and \"nu\" or filled in as default values.timeZoneoptions argument; undefined (representing the runtime's default time zone) if none was provided. Warning: Applications should not rely on undefined being returned, as future versions may return a String value identifying the runtime’s default time zone instead.hour12options argument or filled in as a default.weekdayerayearmonthdayhourminutesecondtimeZoneNameoptions argument and the available combinations and representations for date-time formatting in the selected locale. Some of these properties may not be present, indicating that the corresponding components will not be represented in formatted output.resolvedOptions methodvar germanFakeRegion = new Intl.DateTimeFormat('de-XX', { timeZone: 'UTC' });\nvar usedOptions = germanFakeRegion.resolvedOptions();\n\nusedOptions.locale; // \"de\"\nusedOptions.calendar; // \"gregory\"\nusedOptions.numberingSystem; // \"latn\"\nusedOptions.timeZone; // \"UTC\"\nusedOptions.month; // \"numeric\"\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n24 | \n12 | \n29 | \n11 | \n15 | \n10 | \n
computed timeZone\n | \n35 | \n14 | \n53 | \nNo | \n30 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n26 | \nYes | \n56 | \n? | \n10 | \nYes | \n
computed timeZone\n | \n? | \nYes | \n? | \n56 | \n? | \n10 | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
computed timeZone\n | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/resolvedOptions\n
The toLocaleTimeString() method returns a string with a language sensitive representation of the time portion of this date. The new locales and options arguments let applications specify the language whose formatting conventions should be used and customize the behavior of the function. In older implementations, which ignore the locales and options arguments, the locale used and the form of the string returned are entirely implementation dependent.
dateObj.toLocaleTimeString([locales[, options]])
Check the Browser compatibility section to see which browsers support the locales and options arguments, and Checking for support for locales and options arguments for feature detection.
localesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page. The following Unicode extension keys are allowed:
nu\"arab\", \"arabext\", \"bali\", \"beng\", \"deva\", \"fullwide\", \"gujr\", \"guru\", \"hanidec\", \"khmr\", \"knda\", \"laoo\", \"latn\", \"limb\", \"mlym\", \"mong\", \"mymr\", \"orya\", \"tamldec\", \"telu\", \"thai\", \"tibt\".ca\"buddhist\", \"chinese\", \"coptic\", \"ethioaa\", \"ethiopic\", \"gregory\", \"hebrew\", \"indian\", \"islamic\", \"islamicc\", \"iso8601\", \"japanese\", \"persian\", \"roc\".hc\"h11\", \"h12\", \"h23\", \"h24\".optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.timeZone\"UTC\"; the default is the runtime's default time zone. Implementations may also recognize the time zone names of the IANA time zone database, such as \"Asia/Shanghai\", \"Asia/Kolkata\", \"America/New_York\".hour12true and false; the default is locale dependent. This option overrides the hc language tag and/or the hourCycle option in case both are present.hourCycle\"h11\", \"h12\", \"h23\", or \"h24\". This option overrides the hc language tag, if both are present, and the hour12 option takes precedence in case both options have been specified.formatMatcher\"basic\" and \"best fit\"; the default is \"best fit\". See the following paragraphs for information about the use of this property.The following properties describe the date-time components to use in formatted output, and their desired representations. Implementations are required to support at least the following subsets:
weekday, year, month, day, hour, minute, second\nweekday, year, month, day\nyear, month, day\nyear, month\nmonth, day\nhour, minute, second\nhour, minute\nImplementations may support other subsets, and requests will be negotiated against all available subset-representation combinations to find the best match. Two algorithms are available for this negotiation and selected by the formatMatcher property: A fully specified \"basic\" algorithm and an implementation-dependent \"best fit\" algorithm.
weekday\"narrow\", \"short\", \"long\".era\"narrow\", \"short\", \"long\".year\"numeric\", \"2-digit\".month\"numeric\", \"2-digit\", \"narrow\", \"short\", \"long\".day\"numeric\", \"2-digit\".hour\"numeric\", \"2-digit\".minute\"numeric\", \"2-digit\".second\"numeric\", \"2-digit\".timeZoneName\"short\", \"long\".The default value for each date-time component property is undefined, but if the hour, minute, second properties are all undefined, then hour, minute, and second are assumed to be \"numeric\".
A string representing the time portion of the given Date instance according to language-specific conventions.
toLocaleTimeString()\nIn basic use without specifying a locale, a formatted string in the default locale and with default options is returned.
var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));\n\n// toLocaleTimeString() without arguments depends on the implementation,\n// the default locale, and the default time zone\nconsole.log(date.toLocaleTimeString());\n// → \"7:00:00 PM\" if run in en-US locale with time zone America/Los_Angeles\n
locales and options argumentsThe locales and options arguments are not supported in all browsers yet. To check whether an implementation supports them already, you can use the requirement that illegal language tags are rejected with a RangeError exception:
function toLocaleTimeStringSupportsLocales() {\n try {\n new Date().toLocaleTimeString('i');\n } catch (e) {\n return e.name === 'RangeError';\n }\n return false;\n}\n locales\nThis example shows some of the variations in localized time formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));\n\n// formats below assume the local time zone of the locale;\n// America/Los_Angeles for the US\n\n// US English uses 12-hour time with AM/PM\nconsole.log(date.toLocaleTimeString('en-US'));\n// → \"7:00:00 PM\"\n\n// British English uses 24-hour time without AM/PM\nconsole.log(date.toLocaleTimeString('en-GB'));\n// → \"03:00:00\"\n\n// Korean uses 12-hour time with AM/PM\nconsole.log(date.toLocaleTimeString('ko-KR'));\n// → \"오후 12:00:00\"\n\n// Arabic in most Arabic speaking countries uses real Arabic digits\nconsole.log(date.toLocaleTimeString('ar-EG'));\n// → \"٧:٠٠:٠٠ م\"\n\n// when requesting a language that may not be supported, such as\n// Balinese, include a fallback language, in this case Indonesian\nconsole.log(date.toLocaleTimeString(['ban', 'id']));\n// → \"11.00.00\"\n options\nThe results provided by toLocaleTimeString() can be customized using the options argument:
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));\n\n// an application may want to use UTC and make that visible\nvar options = { timeZone: 'UTC', timeZoneName: 'short' };\nconsole.log(date.toLocaleTimeString('en-US', options));\n// → \"3:00:00 AM GMT\"\n\n// sometimes even the US needs 24-hour time\nconsole.log(date.toLocaleTimeString('en-US', { hour12: false }));\n// → \"19:00:00\"\n When formatting large numbers of dates, it is better to create an Intl.DateTimeFormat object and use the function provided by its format property.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
locales | \n24 | \n? | \n29 | \n11 | \n15 | \n10 | \n
options | \n24 | \n? | \n29 | \n11 | \n15 | \n10 | \n
IANA time zone names in timeZone option | \n24 | \n? | \n52 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
locales | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
options | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
IANA time zone names in timeZone option | \n? | \n? | \n? | \nNo | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
locales | \n? | \n
options | \n? | \n
IANA time zone names in timeZone option | \n? | \n
Intl.DateTimeFormatDate.prototype.toLocaleDateString()Date.prototype.toLocaleString()Date.prototype.toTimeString()Date.prototype.toString()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString\n
The Intl.PluralRules.prototype.select method returns a String indicating which plural rule to use for locale-aware formatting.
pluralRule.select(number)
numberThis function selects a plural rule according to the locale and formatting options of a PluralRules object.
select\n new Intl.PluralRules('ar-EG').select(0); \n// → 'zero' \n\nnew Intl.PluralRules('ar-EG').select(1); \n// → 'one'\n\nnew Intl.PluralRules('ar-EG').select(2); \n// → 'two'\n\nnew Intl.PluralRules('ar-EG').select(6); \n// → 'few'\n\nnew Intl.PluralRules('ar-EG').select(18); \n// → 'many'\n | Specification | Status | Comment |
|---|---|---|
| Intl Plural Rules Draft | Draft | Initial definition |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n63 | \nNo | \n58 | \nNo | \n50 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules/select\n
The static method Object.defineProperty() defines a new property directly on an object, or modifies an existing property on an object, and returns the object.
Note: You call this method directly on the Object constructor rather than on an instance of type Object.
Object.defineProperty(obj, prop, descriptor)
objpropSymbol of the property to be defined or modified.descriptorThe object that was passed to the function.
This method allows a precise addition to or modification of a property on an object. Normal property addition through assignment creates properties which show up during property enumeration (for...in loop or Object.keys method), whose values may be changed, and which may be deleted. This method allows these extra details to be changed from their defaults. By default, values added using Object.defineProperty() are immutable.
Property descriptors present in objects come in two main flavors: data descriptors and accessor descriptors. A data descriptor is a property that has a value, which may or may not be writable. An accessor descriptor is a property described by a getter-setter pair of functions. A descriptor must be one of these two flavors; it cannot be both.
Both data and accessor descriptors are objects. They share the following optional keys:
configurabletrue if and only if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.false\nenumerabletrue if and only if this property shows up during enumeration of the properties on the corresponding object.false\nA data descriptor also has the following optional keys:
valueundefined.\nwritabletrue if and only if the value associated with the property may be changed with an assignment operator.false\nAn accessor descriptor also has the following optional keys:
getundefined if there is no getter. When the property is accessed, this function is called without arguments and with this set to the object through which the property is accessed (this may not be the object on which the property is defined due to inheritance). The return value will be used as the value of the property.undefined.\nsetundefined if there is no setter. When the property is assigned to, this function is called with one argument (the value being assigned to the property) and with this set to the object through which the property is assigned.undefined.\nIf a descriptor has neither of value, writable, get and set keys, it is treated as a data descriptor. If a descriptor has both value or writable and get or set keys, an exception is thrown.
Bear in mind that these attributes are not necessarily the descriptor's own properties. Inherited properties will be considered as well. In order to ensure these defaults are preserved, you might freeze the Object.prototype upfront, specify all options explicitly, or point to null with Object.create(null).
// using __proto__\nvar obj = {};\nvar descriptor = Object.create(null); // no inherited properties\n// not enumerable, not configurable, not writable as defaults\ndescriptor.value = 'static';\nObject.defineProperty(obj, 'key', descriptor);\n\n// being explicit\nObject.defineProperty(obj, 'key', {\n enumerable: false,\n configurable: false,\n writable: false,\n value: 'static'\n});\n\n// recycling same object\nfunction withValue(value) {\n var d = withValue.d || (\n withValue.d = {\n enumerable: false,\n writable: false,\n configurable: false,\n value: null\n }\n );\n d.value = value;\n return d;\n}\n// ... and ...\nObject.defineProperty(obj, 'key', withValue('static'));\n\n// if freeze is available, prevents adding or\n// removing the object prototype properties\n// (value, get, set, enumerable, writable, configurable) \n(Object.freeze || Object)(Object.prototype);\n If you want to see how to use the Object.defineProperty method with a binary-flags-like syntax, see additional examples.
When the property specified doesn't exist in the object, Object.defineProperty() creates a new property as described. Fields may be omitted from the descriptor, and default values for those fields are inputted.
var o = {}; // Creates a new object\n\n// Example of an object property added\n// with defineProperty with a data property descriptor\nObject.defineProperty(o, 'a', {\n value: 37,\n writable: true,\n enumerable: true,\n configurable: true\n});\n// 'a' property exists in the o object and its value is 37\n\n// Example of an object property added\n// with defineProperty with an accessor property descriptor\nvar bValue = 38;\nObject.defineProperty(o, 'b', {\n // Using shorthand method names (ES2015 feature).\n // This is equivalent to:\n // get: function() { return bValue; },\n // set: function(newValue) { bValue = newValue; },\n get() { return bValue; },\n set(newValue) { bValue = newValue; },\n enumerable: true,\n configurable: true\n});\no.b; // 38\n// 'b' property exists in the o object and its value is 38\n// The value of o.b is now always identical to bValue,\n// unless o.b is redefined\n\n// You cannot try to mix both:\nObject.defineProperty(o, 'conflict', {\n value: 0x9f91102,\n get() { return 0xdeadbeef; }\n});\n// throws a TypeError: value appears\n// only in data descriptors,\n// get appears only in accessor descriptors\n When the property already exists, Object.defineProperty() attempts to modify the property according to the values in the descriptor and the object's current configuration. If the old descriptor had its configurable attribute set to false the property is said to be “non-configurable”. It is not possible to change any attribute of a non-configurable accessor property. For data properties, it is possible to modify the value if the property is writable, and it is possible to change writable attribute from true to false. It is not possible to switch between data and accessor property types when the property is non-configurable.
A TypeError is thrown when attempts are made to change non-configurable property attributes (except value and writable, if permitted) unless the current and new values are the same.
When the writable property attribute is set to false, the property is said to be “non-writable”. It cannot be reassigned.
var o = {}; // Creates a new object\n\nObject.defineProperty(o, 'a', {\n value: 37,\n writable: false\n});\n\nconsole.log(o.a); // logs 37\no.a = 25; // No error thrown\n// (it would throw in strict mode,\n// even if the value had been the same)\nconsole.log(o.a); // logs 37. The assignment didn't work.\n\n// strict mode\n(function() {\n 'use strict';\n var o = {};\n Object.defineProperty(o, 'b', {\n value: 2,\n writable: false\n });\n o.b = 3; // throws TypeError: \"b\" is read-only\n return o.b; // returns 2 without the line above\n}());\n As seen in the example, trying to write into the non-writable property doesn't change it but doesn't throw an error either.
The enumerable property attribute defines whether the property is picked by Object.assign() or spread operator. For non-Symbols properties it also defines whether it shows up in a for...in loop and Object.keys() or not.
var o = {};\nObject.defineProperty(o, 'a', {\n value: 1,\n enumerable: true\n});\nObject.defineProperty(o, 'b', {\n value: 2,\n enumerable: false\n});\nObject.defineProperty(o, 'c', {\n value: 3\n}); // enumerable defaults to false\no.d = 4; // enumerable defaults to true\n // when creating a property by setting it\nObject.defineProperty(o, Symbol.for('e'), {\n value: 5,\n enumerable: true\n});\nObject.defineProperty(o, Symbol.for('f'), {\n value: 6,\n enumerable: false\n});\n\nfor (var i in o) {\n console.log(i);\n}\n// logs 'a' and 'd' (in undefined order)\n\nObject.keys(o); // ['a', 'd']\n\no.propertyIsEnumerable('a'); // true\no.propertyIsEnumerable('b'); // false\no.propertyIsEnumerable('c'); // false\no.propertyIsEnumerable('d'); // true\no.propertyIsEnumerable(Symbol.for('e')); // true\no.propertyIsEnumerable(Symbol.for('f')); // false\n\nvar p = { ...o }\np.a // 1\np.b // undefined\np.c // undefined\np.d // 4\np[Symbol.for('e')] // 5\np[Symbol.for('f')] // undefined\n The configurable attribute controls at the same time whether the property can be deleted from the object and whether its attributes (other than value and writable) can be changed.
var o = {};\nObject.defineProperty(o, 'a', {\n get() { return 1; },\n configurable: false\n});\n\nObject.defineProperty(o, 'a', {\n configurable: true\n}); // throws a TypeError\nObject.defineProperty(o, 'a', {\n enumerable: true\n}); // throws a TypeError\nObject.defineProperty(o, 'a', {\n set() {}\n}); // throws a TypeError (set was undefined previously)\nObject.defineProperty(o, 'a', {\n get() { return 1; }\n}); // throws a TypeError\n// (even though the new get does exactly the same thing)\nObject.defineProperty(o, 'a', {\n value: 12\n}); // throws a TypeError\n\nconsole.log(o.a); // logs 1\ndelete o.a; // Nothing happens\nconsole.log(o.a); // logs 1\n If the configurable attribute of o.a had been true, none of the errors would be thrown and the property would be deleted at the end.
It is important to consider the way default values of attributes are applied. There is often a difference between simply using dot notation to assign a value and using Object.defineProperty(), as shown in the example below.
var o = {};\n\no.a = 1;\n// is equivalent to:\nObject.defineProperty(o, 'a', {\n value: 1,\n writable: true,\n configurable: true,\n enumerable: true\n});\n\n// On the other hand,\nObject.defineProperty(o, 'a', { value: 1 });\n// is equivalent to:\nObject.defineProperty(o, 'a', {\n value: 1,\n writable: false,\n configurable: false,\n enumerable: false\n});\n The example below shows how to implement a self-archiving object. When temperature property is set, the archive array gets a log entry.
function Archiver() {\n var temperature = null;\n var archive = [];\n\n Object.defineProperty(this, 'temperature', {\n get() {\n console.log('get!');\n return temperature;\n },\n set(value) {\n temperature = value;\n archive.push({ val: temperature });\n }\n });\n\n this.getArchive = function() { return archive; };\n}\n\nvar arc = new Archiver();\narc.temperature; // 'get!'\narc.temperature = 11;\narc.temperature = 13;\narc.getArchive(); // [{ val: 11 }, { val: 13 }]\n In this example, a getter always returns the same value.
var pattern = {\n get() {\n return 'I always return this string, ' +\n 'whatever you have assigned';\n },\n set() {\n this.myname = 'this is my name string';\n }\n};\n\nfunction TestDefineSetAndGet() {\n Object.defineProperty(this, 'myproperty', pattern);\n}\n\nvar instance = new TestDefineSetAndGet();\ninstance.myproperty = 'test';\nconsole.log(instance.myproperty);\n// I always return this string, whatever you have assigned\n\nconsole.log(instance.myname); // this is my name string\n If an accessor property is inherited, its get and set methods will be called when the property is accessed and modified on descendant objects. If these methods use a variable to store the value, this value will be shared by all objects.
function myclass() {\n}\n\nvar value;\nObject.defineProperty(myclass.prototype, \"x\", {\n get() {\n return value;\n },\n set(x) {\n value = x;\n }\n});\n\nvar a = new myclass();\nvar b = new myclass();\na.x = 1;\nconsole.log(b.x); // 1\n This can be fixed by storing the value in another property. In get and set methods, this points to the object which is used to access or modify the property.
function myclass() {\n}\n\nObject.defineProperty(myclass.prototype, \"x\", {\n get() {\n return this.stored_x;\n },\n set(x) {\n this.stored_x = x;\n }\n});\n\nvar a = new myclass();\nvar b = new myclass();\na.x = 1;\nconsole.log(b.x); // undefined\n Unlike accessor properties, value properties are always set on the object itself, not on a prototype. However, if a non-writable value property is inherited, it still prevents from modifying the property on the object.
function myclass() {\n}\n\nmyclass.prototype.x = 1;\nObject.defineProperty(myclass.prototype, \"y\", {\n writable: false,\n value: 1\n});\n\nvar a = new myclass();\na.x = 2;\nconsole.log(a.x); // 2\nconsole.log(myclass.prototype.x); // 1\na.y = 2; // Ignored, throws in strict mode\nconsole.log(a.y); // 1\nconsole.log(myclass.prototype.y); // 1\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.defineProperty' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.defineProperty' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.defineProperty' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n5 | \nYes | \n4 | \n 9\n
| \n11.6 | \n 5.1\n
| \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \n11.5 | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
length property of an Array objectIt is possible to redefine the length property of arrays, subject to the usual redefinition restrictions. (The length property is initially non-configurable, non-enumerable, and writable. Thus on an unaltered array, it's possible to change the length property's value or to make it non-writable. It is not allowed to change its enumerability or configurability, or if it is non-writable to change its value or writability.) However, not all browsers permit this redefinition.
Firefox 4 through 22 will throw a TypeError on any attempt whatsoever (whether permitted or not) to redefine the length property of an array.
Versions of Chrome which implement Object.defineProperty() in some circumstances ignore a length value different from the array's current length property. In some circumstances changing writability seems to silently not work (and not throw an exception). Also, relatedly, some array-mutating methods like Array.prototype.push don't respect a non-writable length.
Versions of Safari which implement Object.defineProperty() ignore a length value different from the array's current length property, and attempts to change writability execute without error but do not actually change the property's writability.
Only Internet Explorer 9 and later, and Firefox 23 and later, appear to fully and correctly implement redefinition of the length property of arrays. For now, don't rely on redefining the length property of an array to either work, or to work in a particular manner. And even when you can rely on it, there's really no good reason to do so.
Internet Explorer 8 implemented a Object.defineProperty() method that could only be used on DOM objects. A few things need to be noted:
Object.defineProperty() on native objects throws an error.configurable, enumerable and writable attributes should all be set to true for data descriptor and true for configurable, false for enumerable for accessor descriptor.(?) Any attempt to provide other value(?) will result in an error being thrown.Object.defineProperties()Object.propertyIsEnumerable()Object.getOwnPropertyDescriptor()Object.prototype.watch()Object.prototype.unwatch()getsetObject.create()Object.defineProperty examplesReflect.defineProperty()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty\n
The toJSON() method returns a string representation of the Date object.
dateObj.toJSON()
A string representation of the given date.
Date instances refer to a specific point in time. Calling toJSON() returns a string (using toISOString()) representing the Date object's value. This method is generally intended to, by default, usefully serialize Date objects during JSON serialization.
toJSON()\nvar jsonDate = (new Date()).toJSON();\nvar backToDate = new Date(jsonDate);\n\nconsole.log(jsonDate); //2015-10-26T07:46:36.611Z\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.toJSON' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.toJSON' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.toJSON' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n8 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toJSON\n
This is an experimental technology
Check the Browser compatibility table carefully before using this in production.
The Intl.DateTimeFormat.prototype.formatToParts() method allows locale-aware formatting of strings produced by DateTimeFormat formatters.
Intl.DateTimeFormat.prototype.formatToParts(date)
date Optional\nAn Array of objects containing the formatted date in parts.
The formatToParts() method is useful for custom formatting of date strings. It returns an Array of objects containing the locale-specific tokens from which it possible to build custom strings while preserving the locale-specific parts. The structure the formatToParts() method returns, looks like this:
[\n { type: 'day', value: '17' },\n { type: 'weekday', value: 'Monday' }\n] Possible types are the following:
\"17\".\"AM\" or \"PM\".\"BC\" or \"AD\".\"3\" or \"03\".\"/\", \",\", \"o'clock\", \"de\", etc.\"00\".\"12\".\"07\" or \"42\".\"UTC\".\"M\", \"Monday\", or \"Montag\".\"2012\" or \"96\".DateTimeFormat outputs localized, opaque strings that cannot be manipulated directly:
var date = Date.UTC(2012, 11, 17, 3, 0, 42);\n\nvar formatter = new Intl.DateTimeFormat('en-us', {\n weekday: 'long',\n year: 'numeric',\n month: 'numeric',\n day: 'numeric',\n hour: 'numeric',\n minute: 'numeric',\n second: 'numeric',\n hour12: true,\n timeZone: 'UTC'\n});\n\nformatter.format(date);\n// \"Monday, 12/17/2012, 3:00:42 AM\"\n However, in many User Interfaces there is a desire to customize the formatting of this string. The formatToParts method enables locale-aware formatting of strings produced by DateTimeFormat formatters by providing you the string in parts:
formatter.formatToParts(date);\n\n// return value: \n[ \n { type: 'weekday', value: 'Monday' }, \n { type: 'literal', value: ', ' }, \n { type: 'month', value: '12' }, \n { type: 'literal', value: '/' }, \n { type: 'day', value: '17' }, \n { type: 'literal', value: '/' }, \n { type: 'year', value: '2012' }, \n { type: 'literal', value: ', ' }, \n { type: 'hour', value: '3' }, \n { type: 'literal', value: ':' }, \n { type: 'minute', value: '00' }, \n { type: 'literal', value: ':' }, \n { type: 'second', value: '42' }, \n { type: 'literal', value: ' ' }, \n { type: 'dayPeriod', value: 'AM' } \n]\n Now the information is available separately and it can be formatted and concatenated again in a customized way. For example by using Array.prototype.map(), arrow functions, a switch statement, template literals, and Array.prototype.reduce().
var dateString = formatter.formatToParts(date).map(({type, value}) => { \n switch (type) {\n case 'dayPeriod': return `<b>${value}</b>`; \n default : return value; \n } \n}).reduce((string, part) => string + part);\n This will make the day period bold, when using the formatToParts() method.
console.log(formatter.format(date));\n// \"Monday, 12/17/2012, 3:00:42 AM\"\n\nconsole.log(dateString);\n// \"Monday, 12/17/2012, 3:00:42 <b>AM</b>\"
A polyfill for this feature is available in the proposal repository.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Internationalization API 4.0 (ECMA-402) The definition of 'Intl.DateTimeFormat.prototype.formatToParts' in that specification. | Draft | Initial definition |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 57\n
| \nYes | \n51 | \nNo | \nYes | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n57 | \nNo | \n56 | \nNo | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Intl.DateTimeFormatIntl.DateTimeFormat.prototype.formatDate.prototype.toLocaleString()Date.prototype.toLocaleDateString()Date.prototype.toLocaleTimeString()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/formatToParts\n
The Intl.PluralRules.supportedLocalesOf() method returns an array containing those of the provided locales that are supported in plural formatting without having to fall back to the runtime's default locale.
Intl.PluralRules.supportedLocalesOf(locales[, options])
localeslocales argument, see the Intl page.optionsOptional. An object that may have the following property:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.An array of strings representing a subset of the given locale tags that are supported in plural formatting without having to fall back to the runtime's default locale.
Returns an array with a subset of the language tags provided in locales. The language tags returned are those for which the runtime supports a locale in plural formatting that the locale matching algorithm used considers a match, so that it wouldn't have to fall back to the default locale.
supportedLocalesOf\nAssuming a runtime that supports Indonesian and German but not Balinese in plural formatting, supportedLocalesOf returns the Indonesian and German language tags unchanged, even though pinyin collation is neither relevant to plural formatting nor used with Indonesian, and a specialized German for Indonesia is unlikely to be supported. Note the specification of the \"lookup\" algorithm here — a \"best fit\" matcher might decide that Indonesian is an adequate match for Balinese since most Balinese speakers also understand Indonesian, and therefore return the Balinese language tag as well.
var locales = ['ban', 'id-u-co-pinyin', 'de-ID'];\nvar options = { localeMatcher: 'lookup' };\nconsole.log(Intl.PluralRules.supportedLocalesOf(locales, options).join(', '));\n// → \"id-u-co-pinyin, de-ID\"\n | Specification | Status | Comment |
|---|---|---|
| Intl Plural Rules Draft | Draft | Initial definition |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n63 | \nNo | \n58 | \nNo | \n50 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules/supportedLocalesOf\n
The toExponential() method returns a string representing the Number object in exponential notation.
numObj.toExponential([fractionDigits])
fractionDigitsA string representing the given Number object in exponential notation with one digit before the decimal point, rounded to fractionDigits digits after the decimal point.
RangeErrorfractionDigits is too small or too large. Values between 0 and 20, inclusive, will not cause a RangeError. Implementations are allowed to support larger and smaller values as well.TypeErrorNumber.If the fractionDigits argument is omitted, the number of digits after the decimal point defaults to the number of digits necessary to represent the value uniquely.
If you use the toExponential() method for a numeric literal and the numeric literal has no exponent and no decimal point, leave whitespace(s) before the dot that precedes the method call to prevent the dot from being interpreted as a decimal point.
If a number has more digits than requested by the fractionDigits parameter, the number is rounded to the nearest number represented by fractionDigits digits. See the discussion of rounding in the description of the toFixed() method, which also applies to toExponential().
toExponential\nvar numObj = 77.1234;\n\nconsole.log(numObj.toExponential()); // logs 7.71234e+1\nconsole.log(numObj.toExponential(4)); // logs 7.7123e+1\nconsole.log(numObj.toExponential(2)); // logs 7.71e+1\nconsole.log(77.1234.toExponential()); // logs 7.71234e+1\nconsole.log(77 .toExponential()); // logs 7.7e+1\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.5. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.prototype.toExponential' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.prototype.toExponential' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.prototype.toExponential' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toExponential\n
The toFixed() method formats a number using fixed-point notation.
numObj.toFixed([digits])
digitsA string representing the given number using fixed-point notation.
RangeErrordigits is too small or too large. Values between 0 and 100, inclusive, will not cause a RangeError. Implementations are allowed to support larger and smaller values as chosen.TypeErrorNumber.toFixed() returns a string representation of numObj that does not use exponential notation and has exactly digits digits after the decimal place. The number is rounded if necessary, and the fractional part is padded with zeros if necessary so that it has the specified length. If numObj is greater than 1e+21, this method simply calls Number.prototype.toString() and returns a string in exponential notation.
Floating point numbers cannot represent all decimals precisely in binary which can lead to unexpected results such as 0.1 + 0.2 === 0.3 returning false .
toFixed\nvar numObj = 12345.6789;\n\nnumObj.toFixed(); // Returns '12346': note rounding, no fractional part\nnumObj.toFixed(1); // Returns '12345.7': note rounding\nnumObj.toFixed(6); // Returns '12345.678900': note added zeros\n(1.23e+20).toFixed(2); // Returns '123000000000000000000.00'\n(1.23e-10).toFixed(2); // Returns '0.00'\n2.34.toFixed(1); // Returns '2.3'\n2.35.toFixed(1); // Returns '2.4'. Note it rounds up\n2.55.toFixed(1); // Returns '2.5'. Note it rounds down - see warning above\n-2.34.toFixed(1); // Returns -2.3 (due to operator precedence, negative number literals don't return a string...)\n(-2.34).toFixed(1); // Returns '-2.3' (...unless you use parentheses)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.5. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.prototype.toFixed' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.prototype.toFixed' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.prototype.toFixed' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed\n
The RangeError.prototype property represents the prototype the RangeError constructor.
Property attributes of RangeError.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All RangeError instances inherit from RangeError.prototype. You can use the prototype to add properties or methods to all instances.
RangeError.prototype.constructorRangeError.prototype.messageRangeError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.RangeError.prototype.nameError.RangeError.prototype.fileNameError.RangeError.prototype.lineNumberError.RangeError.prototype.columnNumberError.RangeError.prototype.stackError.Although the RangeError prototype object does not contain any methods of its own, RangeError instances do inherit some methods through the prototype chain.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Draft | Defined as NativeError.prototype. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError/prototype\n
The toLocaleDateString() method returns a string with a language sensitive representation of the date portion of this date. The new locales and options arguments let applications specify the language whose formatting conventions should be used and allow to customize the behavior of the function. In older implementations, which ignore the locales and options arguments, the locale used and the form of the string returned are entirely implementation dependent.
dateObj.toLocaleDateString([locales [, options]])
Check the Browser compatibility section to see which browsers support the locales and options arguments, and the Example: Checking for support for locales and options arguments for feature detection.
localesOptional. A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see the Intl page. The following Unicode extension keys are allowed:
nu\"arab\", \"arabext\", \"bali\", \"beng\", \"deva\", \"fullwide\", \"gujr\", \"guru\", \"hanidec\", \"khmr\", \"knda\", \"laoo\", \"latn\", \"limb\", \"mlym\", \"mong\", \"mymr\", \"orya\", \"tamldec\", \"telu\", \"thai\", \"tibt\".ca\"buddhist\", \"chinese\", \"coptic\", \"ethioaa\", \"ethiopic\", \"gregory\", \"hebrew\", \"indian\", \"islamic\", \"islamicc\", \"iso8601\", \"japanese\", \"persian\", \"roc\".hc\"h11\", \"h12\", \"h23\", \"h24\".optionsOptional. An object with some or all of the following properties:
localeMatcher\"lookup\" and \"best fit\"; the default is \"best fit\". For information about this option, see the Intl page.timeZone\"UTC\"; the default is the runtime's default time zone. Implementations may also recognize the time zone names of the IANA time zone database, such as \"Asia/Shanghai\", \"Asia/Kolkata\", \"America/New_York\".hour12true and false; the default is locale dependent. This option overrides the hc language tag and/or the hourCycle option in case both are present.hourCycle\"h11\", \"h12\", \"h23\", or \"h24\". This option overrides the hc language tag, if both are present, and the hour12 option takes precedence in case both options have been specified.formatMatcher\"basic\" and \"best fit\"; the default is \"best fit\". See the following paragraphs for information about the use of this property.The following properties describe the date-time components to use in formatted output, and their desired representations. Implementations are required to support at least the following subsets:
weekday, year, month, day, hour, minute, second\nweekday, year, month, day\nyear, month, day\nyear, month\nmonth, day\nhour, minute, second\nhour, minute\nImplementations may support other subsets, and requests will be negotiated against all available subset-representation combinations to find the best match. Two algorithms are available for this negotiation and selected by the formatMatcher property: A fully specified \"basic\" algorithm and an implementation-dependent \"best fit\" algorithm.
weekday\"narrow\", \"short\", \"long\".era\"narrow\", \"short\", \"long\".year\"numeric\", \"2-digit\".month\"numeric\", \"2-digit\", \"narrow\", \"short\", \"long\".day\"numeric\", \"2-digit\".hour\"numeric\", \"2-digit\".minute\"numeric\", \"2-digit\".second\"numeric\", \"2-digit\".timeZoneName\"short\", \"long\".The default value for each date-time component property is undefined, but if the weekday, year, month, day properties are all undefined, then year, month, and day are assumed to be \"numeric\".
A string representing the date portion of the given Date instance according to language-specific conventions.
toLocaleDateString()\nIn basic use without specifying a locale, a formatted string in the default locale and with default options is returned.
var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));\n\n// toLocaleDateString() without arguments depends on the implementation,\n// the default locale, and the default time zone\nconsole.log(date.toLocaleDateString());\n// → \"12/11/2012\" if run in en-US locale with time zone America/Los_Angeles\n
locales and options argumentsThe locales and options arguments are not supported in all browsers yet. To check whether an implementation supports them already, you can use the requirement that illegal language tags are rejected with a RangeError exception:
function toLocaleDateStringSupportsLocales() {\n try {\n new Date().toLocaleDateString('i');\n } catch (e) {\n return e.name === 'RangeError';\n }\n return false;\n}\n locales\nThis example shows some of the variations in localized date formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the locales argument:
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));\n\n// formats below assume the local time zone of the locale;\n// America/Los_Angeles for the US\n\n// US English uses month-day-year order\nconsole.log(date.toLocaleDateString('en-US'));\n// → \"12/19/2012\"\n\n// British English uses day-month-year order\nconsole.log(date.toLocaleDateString('en-GB'));\n// → \"20/12/2012\"\n\n// Korean uses year-month-day order\nconsole.log(date.toLocaleDateString('ko-KR'));\n// → \"2012. 12. 20.\"\n\n// Event for Persian, It's hard to manually convert date to Solar Hijri\nconsole.log(date.toLocaleDateString('fa-IR'));\n// → \"۱۳۹۱/۹/۳۰\"\n\n// Arabic in most Arabic speaking countries uses real Arabic digits\nconsole.log(date.toLocaleDateString('ar-EG'));\n// → \"٢٠/١٢/٢٠١٢\"\n\n// for Japanese, applications may want to use the Japanese calendar,\n// where 2012 was the year 24 of the Heisei era\nconsole.log(date.toLocaleDateString('ja-JP-u-ca-japanese'));\n// → \"24/12/20\"\n\n// when requesting a language that may not be supported, such as\n// Balinese, include a fallback language, in this case Indonesian\nconsole.log(date.toLocaleDateString(['ban', 'id']));\n// → \"20/12/2012\"\n options\nThe results provided by toLocaleDateString() can be customized using the options argument:
var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));\n\n// request a weekday along with a long date\nvar options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };\nconsole.log(date.toLocaleDateString('de-DE', options));\n// → \"Donnerstag, 20. Dezember 2012\"\n\n// an application may want to use UTC and make that visible\noptions.timeZone = 'UTC';\noptions.timeZoneName = 'short';\nconsole.log(date.toLocaleDateString('en-US', options));\n// → \"Thursday, December 20, 2012, GMT\"\n When formatting large numbers of dates, it is better to create an Intl.DateTimeFormat object and use the function provided by its format property.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
locales | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
options | \n24 | \nYes | \n29 | \n11 | \n15 | \n10 | \n
IANA time zone names in timeZone option | \n24 | \n? | \n52 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
locales | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
options | \nNo | \n26 | \n? | \n56 | \nNo | \n10 | \nYes | \n
IANA time zone names in timeZone option | \n? | \n? | \n? | \nNo | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
locales | \n? | \n
options | \n? | \n
IANA time zone names in timeZone option | \n? | \n
Intl.DateTimeFormatDate.prototype.toLocaleString()Date.prototype.toLocaleTimeString()Date.prototype.toString()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString\n
The Intl.PluralRules.prototype.resolvedOptions() method returns a new object with properties reflecting the locale and plural formatting options computed during initialization of this PluralRules object.
pluralRule.resolvedOptions()
A new object with properties reflecting the locale and plural formatting options computed during the initialization of the given PluralRules object.
The resulting object has the following properties:
localelocale.pluralCategoriesArray of plural rules used by the given language.typecardinal or ordinal).Only one of the following two groups of properties is included:
minimumIntegerDigitsminimumFractionDigitsmaximumFractionDigitsoptions argument or filled in as defaults. These properties are present only if neither minimumSignificantDigits nor maximumSignificantDigits was provided in the options argument.minimumSignificantDigitsmaximumSignificantDigitsoptions argument or filled in as defaults. These properties are present only if at least one of them was provided in the options argument.resolvedOptions methodvar de = new Intl.PluralRules('de-DE');\nvar usedOptions = de.resolvedOptions();\n\nusedOptions.locale; // \"de-DE\"\nusedOptions.maximumFractionDigits; // 3\nusedOptions.minimumFractionDigits; // 0\nusedOptions.minimumIntegerDigits; // 1\nusedOptions.pluralCategories; // Array [ \"one\", \"other\" ]\nusedOptions.type; // \"cardinal\"\n | Specification | Status | Comment |
|---|---|---|
| Intl Plural Rules Draft | Draft | Initial definition |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n63 | \nNo | \n58 | \nNo | \n50 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n63 | \n63 | \nNo | \n58 | \n50 | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/PluralRules/resolvedOptions\n
The toPrecision() method returns a string representing the Number object to the specified precision.
numObj.toPrecision([precision])
precisionA string representing a Number object in fixed-point or exponential notation rounded to precision significant digits. See the discussion of rounding in the description of the Number.prototype.toFixed() method, which also applies to toPrecision().
If the precision argument is omitted, behaves as Number.prototype.toString(). If the precision argument is a non-integer value, it is rounded to the nearest integer.
RangeErrorprecision is not between 1 and 100 (inclusive), a RangeError is thrown. Implementations are allowed to support larger and smaller values as well. ECMA-262 only requires a precision of up to 21 significant digits.toPrecision\nvar numObj = 5.123456;\n\nconsole.log(numObj.toPrecision()); // logs '5.123456'\nconsole.log(numObj.toPrecision(5)); // logs '5.1235'\nconsole.log(numObj.toPrecision(2)); // logs '5.1'\nconsole.log(numObj.toPrecision(1)); // logs '5'\n\nnumObj = 0.000123\n\nconsole.log(numObj.toPrecision()); // logs '0.000123'\nconsole.log(numObj.toPrecision(5)); // logs '0.00012300'\nconsole.log(numObj.toPrecision(2)); // logs '0.00012'\nconsole.log(numObj.toPrecision(1)); // logs '0.0001' \n\n// note that exponential notation might be returned in some circumstances\nconsole.log((1234.5).toPrecision(2)); // logs '1.2e+3'\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.5. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.prototype.toPrecision' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.prototype.toPrecision' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.prototype.toPrecision' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toPrecision\n
The DataView.prototype property represents the prototype for the DataView object.
Property attributes of DataView.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
DataView instances inherit from DataView.prototype. As with all constructors, you can change the constructor's prototype object to make changes to all DataView instances.
DataView.prototype.constructorDataView constructor.DataView.prototype.buffer Read only \nArrayBuffer referenced by this view. Fixed at construction time and thus read only.\nDataView.prototype.byteLength Read only \nArrayBuffer. Fixed at construction time and thus read only.\nDataView.prototype.byteOffset Read only \nArrayBuffer. Fixed at construction time and thus read only.\nDataView.prototype.getInt8()DataView.prototype.getUint8()DataView.prototype.getInt16()DataView.prototype.getUint16()DataView.prototype.getInt32()DataView.prototype.getUint32()DataView.prototype.getFloat32()DataView.prototype.getFloat64()DataView.prototype.setInt8()DataView.prototype.setUint8()DataView.prototype.setInt16()DataView.prototype.setUint16()DataView.prototype.setInt32()DataView.prototype.setUint32()DataView.prototype.setFloat32()DataView.prototype.setFloat64()| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/prototype\n
The buffer accessor property represents the ArrayBuffer or SharedArrayBuffer referenced by the DataView at construction time.
dataview.buffer
The buffer property is an accessor property whose set accessor function is undefined, meaning that you can only read this property. The value is established when the DataView is constructed and cannot be changed.
buffer propertyvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.buffer; // ArrayBuffer { byteLength: 8 }\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.buffer' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.buffer' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
\nSharedArrayBuffer accepted as buffer | \n60 | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
\nSharedArrayBuffer accepted as buffer | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\nSharedArrayBuffer accepted as buffer | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/buffer\n
The getFloat32() method gets a signed 32-bit float (float) at the specified byte offset from the start of the DataView.
dataview.getFloat32(byteOffset [, littleEndian])
A signed 32-bit float number.
RangeErrorbyteOffset is set such as it would read beyond the end of the view.There is no alignment constraint; multi-byte values may be fetched from any offset.
getFloat32 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.getFloat32(1); // 0\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.getFloat32' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.getFloat32' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getFloat32\n
The getInt8() method gets a signed 8-bit integer (byte) at the specified byte offset from the start of the DataView.
dataview.getInt8(byteOffset)
A signed 8-bit integer number.
RangeErrorbyteOffset is set such as it would read beyond the end of the view.There is no alignment constraint; multi-byte values may be fetched from any offset.
getInt8 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.getInt8(1); // 0\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.getInt8' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.getInt8' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getInt8\n
The normalize() method returns the Unicode Normalization Form of a given string (if the value isn't a string, it will be converted to one first).
str.normalize([form])
form\"NFC\", \"NFD\", \"NFKC\", or \"NFKD\", specifying the Unicode Normalization Form. If omitted or undefined, \"NFC\" is used. NFC — Normalization Form Canonical Composition.NFD — Normalization Form Canonical Decomposition.NFKC — Normalization Form Compatibility Composition.NFKD — Normalization Form Compatibility Decomposition.A string containing the Unicode Normalization Form of the given string.
RangeErrorRangeError is thrown if form isn't one of the values specified above.The normalize() method returns the specified Unicode Normalization Form of the string. It does not affect the value of the string itself.
normalize()\n// Initial string\n\n// U+1E9B: LATIN SMALL LETTER LONG S WITH DOT ABOVE\n// U+0323: COMBINING DOT BELOW\nvar str = '\\u1E9B\\u0323';\n\n\n// Canonically-composed form (NFC)\n\n// U+1E9B: LATIN SMALL LETTER LONG S WITH DOT ABOVE\n// U+0323: COMBINING DOT BELOW\nstr.normalize('NFC'); // '\\u1E9B\\u0323'\nstr.normalize(); // same as above\n\n\n// Canonically-decomposed form (NFD)\n\n// U+017F: LATIN SMALL LETTER LONG S\n// U+0323: COMBINING DOT BELOW\n// U+0307: COMBINING DOT ABOVE\nstr.normalize('NFD'); // '\\u017F\\u0323\\u0307'\n\n\n// Compatibly-composed (NFKC)\n\n// U+1E69: LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE\nstr.normalize('NFKC'); // '\\u1E69'\n\n\n// Compatibly-decomposed (NFKD)\n\n// U+0073: LATIN SMALL LETTER S\n// U+0323: COMBINING DOT BELOW\n// U+0307: COMBINING DOT ABOVE\nstr.normalize('NFKD'); // '\\u0073\\u0323\\u0307'\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.normalize' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.normalize' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n34 | \nYes | \n31 | \nNo | \nYes | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n34 | \nYes | \n31 | \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize\n
The byteLength accessor property represents the length (in bytes) of this view from the start of its ArrayBuffer or SharedArrayBuffer.
dataview.byteLength
The byteLength property is an accessor property whose set accessor function is undefined, meaning that you can only read this property. The value is established when an DataView is constructed and cannot be changed. If the DataView is not specifying an offset or a byteLength, the byteLength of the referenced ArrayBuffer or SharedArrayBuffer will be returned.
byteLength propertyvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.byteLength; // 8 (matches the byteLength of the buffer)\n\nvar dataview2 = new DataView(buffer, 1, 5);\ndataview2.byteLength; // 5 (as specified when constructing the DataView)\n\nvar dataview3 = new DataView(buffer, 2);\ndataview3.byteLength; // 6 (due to the offset of the constructed DataView)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.byteLength' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.byteLength' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/byteLength\n
The byteOffset accessor property represents the offset (in bytes) of this view from the start of its ArrayBuffer or SharedArrayBuffer.
dataview.byteOffset
The byteOffset property is an accessor property whose set accessor function is undefined, meaning that you can only read this property. The value is established when an DataView is constructed and cannot be changed.
byteOffset propertyvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.byteOffset; // 0 (no offset specified)\n\nvar dataview2 = new DataView(buffer, 3);\ndataview2.byteOffset; // 3 (as specified when constructing the DataView)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.byteOffset' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.byteOffset' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/byteOffset\n
The getFloat64() method gets a signed 64-bit float (double) at the specified byte offset from the start of the DataView.
dataview.getFloat64(byteOffset [, littleEndian])
A signed 64-bit float number.
RangeErrorbyteOffset is set such as it would read beyond the end of the view.There is no alignment constraint; multi-byte values may be fetched from any offset.
getFloat64 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.getFloat64(0); // 0\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.getFloat64' in that specification. | Standard | Initial definition in ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.getFloat64' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getFloat64\n
The getUint8() method gets an unsigned 8-bit integer (unsigned byte) at the specified byte offset from the start of the DataView.
dataview.getUint8(byteOffset)
An unsigned 8-bit integer number.
RangeErrorbyteOffset is set such as it would read beyond the end of the view.There is no alignment constraint; multi-byte values may be fetched from any offset.
getUint8 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.getUint8(1); // 0\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.getUint8' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.getUint8' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getUint8\n
The getInt16() method gets a signed 16-bit integer (short) at the specified byte offset from the start of the DataView.
dataview.getInt16(byteOffset [, littleEndian])
A signed 16-bit integer number.
RangeErrorbyteOffset is set such as it would read beyond the end of the view.There is no alignment constraint; multi-byte values may be fetched from any offset.
getInt16 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.getInt16(1); // 0\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.getInt16' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.getInt16' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getInt16\n
The setFloat32() method stores a signed 32-bit float (float) value at the specified byte offset from the start of the DataView.
dataview.setFloat32(byteOffset, value [, littleEndian])
RangeErrorbyteOffset is set such as it would store beyond the end of the view.setFloat32 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.setFloat32(1, 3);\ndataview.getFloat32(1); // 3\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.setFloat32' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.setFloat32' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setFloat32\n
The setFloat64() method stores a signed 64-bit float (double) value at the specified byte offset from the start of the DataView.
dataview.setFloat64(byteOffset, value [, littleEndian])
RangeErrorbyteOffset is set such as it would store beyond the end of the view.setFloat64 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.setFloat64(0, 3);\ndataview.getFloat64(0); // 3\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.setFloat64' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.setFloat64' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setFloat64\n
The setInt16() method stores a signed 16-bit integer (short) value at the specified byte offset from the start of the DataView.
dataview.setInt16(byteOffset, value [, littleEndian])
RangeErrorbyteOffset is set such as it would store beyond the end of the view.setInt16 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.setInt16(1, 3);\ndataview.getInt16(1); // 3\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.setInt16' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.setInt16' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setInt16\n
The getUint16() method gets an unsigned 16-bit integer (unsigned short) at the specified byte offset from the start of the DataView.
dataview.getUint16(byteOffset [, littleEndian])
An unsigned 16-bit integer number.
RangeErrorbyteOffset is set such as it would read beyond the end of the view.There is no alignment constraint; multi-byte values may be fetched from any offset.
getUint16 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.getUint16(1); // 0\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.getUint16' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.getUint16' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getUint16\n
The getUint32() method gets an unsigned 32-bit integer (unsigned long) at the specified byte offset from the start of the DataView.
dataview.getUint32(byteOffset [, littleEndian])
An unsigned 32-bit integer number.
RangeErrorbyteOffset is set such as it would read beyond the end of the view.There is no alignment constraint; multi-byte values may be fetched from any offset.
getUint32 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.getUint32(1); // 0\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.getUint32' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.getUint32' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getUint32\n
The setInt32() method stores a signed 32-bit integer (long) value at the specified byte offset from the start of the DataView.
dataview.setInt32(byteOffset, value [, littleEndian])
RangeErrorbyteOffset is set such as it would store beyond the end of the view.setInt32 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.setInt32(1, 3);\ndataview.getInt32(1); // 3\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.setInt32' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.setInt32' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setInt32\n
The static Atomics.isLockFree() method is used to determine whether to use locks or atomic operations. It returns true, if the given size is one of the BYTES_PER_ELEMENT property of integer TypedArray types.
Atomics.isLockFree(size)\n
sizeA Boolean indicating whether the operation is lock free.
Atomics.isLockFree(1); // true\nAtomics.isLockFree(2); // true\nAtomics.isLockFree(3); // false\nAtomics.isLockFree(4); // true\nAtomics.isLockFree(5); // false\nAtomics.isLockFree(6); // false\nAtomics.isLockFree(7); // false\nAtomics.isLockFree(8); // false
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.isLockFree' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree\n
The setUint8() method stores an unsigned 8-bit integer (byte) value at the specified byte offset from the start of the DataView.
dataview.setUint8(byteOffset, value)
RangeErrorbyteOffset is set such as it would store beyond the end of the view.setUint8 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.setUint8(1, 3);\ndataview.getUint8(1); // 3\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.setUint8' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.setUint8' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setUint8\n
The getInt32() method gets a signed 32-bit integer (long) at the specified byte offset from the start of the DataView.
dataview.getInt32(byteOffset [, littleEndian])
A signed 32-bit integer number.
RangeErrorbyteOffset is set such as it would read beyond the end of the view.There is no alignment constraint; multi-byte values may be fetched from any offset.
getInt32 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.getInt32(1); // 0\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.getInt32' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.getInt32' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/getInt32\n
The setInt8() method stores a signed 8-bit integer (byte) value at the specified byte offset from the start of the DataView.
dataview.setInt8(byteOffset, value)
RangeErrorbyteOffset is set such as it would store beyond the end of the view.setInt8 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.setInt8(1, 3);\ndataview.getInt8(1); // 3\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.setInt8' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.setInt8' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setInt8\n
The setUint16() method stores an unsigned 16-bit integer (unsigned short) value at the specified byte offset from the start of the DataView.
dataview.setUint16(byteOffset, value [, littleEndian])
RangeErrorbyteOffset is set such as it would store beyond the end of the view.setUint16 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.setUint16(1, 3);\ndataview.getUint16(1); // 3\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.setUint16' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.setUint16' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setUint16\n
The setUint32() method stores an unsigned 32-bit integer (unsigned long) value at the specified byte offset from the start of the DataView.
dataview.setUint32(byteOffset, value [, littleEndian])
RangeErrorbyteOffset is set such as it would store beyond the end of the view.setUint32 methodvar buffer = new ArrayBuffer(8);\nvar dataview = new DataView(buffer);\ndataview.setUint32(1, 3);\ndataview.getUint32(1); // 3\n
| Specification | Status | Comment |
|---|---|---|
| Typed Array Specification | Obsolete | Superseded by ECMAScript 2015. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'DataView.prototype.setUint32' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'DataView.prototype.setUint32' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n9 | \n12 | \n15 | \n10 | \n12.1 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4 | \nYes | \nYes | \n15 | \n12 | \n4.2 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView/setUint32\n
The ReferenceError.prototype property represents the prototype for the ReferenceError constructor.
Property attributes of ReferenceError.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All ReferenceError instances inherit from ReferenceError.prototype. You can use the prototype to add properties or methods to all instances.
ReferenceError.prototype.constructorReferenceError.prototype.messageReferenceError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.ReferenceError.prototype.nameError.ReferenceError.prototype.fileNameError.ReferenceError.prototype.lineNumberError.ReferenceError.prototype.columnNumberError.ReferenceError.prototype.stackError.Although the ReferenceError prototype object does not contain any methods of its own, ReferenceError instances do inherit some methods through the prototype chain.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Draft | Defined as NativeError.prototype. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype\n
The static Atomics.add() method adds a given value at a given position in the array and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.
Atomics.add(typedArray, index, value)\n
typedArrayInt8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array.indextypedArray to add a value to.valueThe old value at the given position (typedArray[index]).
TypeError, if typedArray is not one of the allowed integer types.TypeError, if typedArray is not a shared typed array type.RangeError, if index is out of bounds in the typedArray.var sab = new SharedArrayBuffer(1024);\nvar ta = new Uint8Array(sab);\n\nAtomics.add(ta, 0, 12); // returns 0, the old value\nAtomics.load(ta, 0); // 12
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.add' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/add\n
The static Atomics.load() method returns a value at a given position in the array.
Atomics.load(typedArray, index)\n
typedArrayInt8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array.indextypedArray to load from.\nThe value at the given position (typedArray[index]).
TypeError, if typedArray is not one of the allowed integer types.TypeError, if typedArray is not a shared typed array type.RangeError, if index is out of bounds in the typedArray.var sab = new SharedArrayBuffer(1024);\nvar ta = new Uint8Array(sab);\n\nAtomics.add(ta, 0, 12);\nAtomics.load(ta, 0); // 12
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.load' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/load\n
The Number.NaN property represents Not-A-Number. Equivalent of NaN.
You do not have to create a Number object to access this static property (use Number.NaN).
Property attributes of Number.NaN\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.NaN' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.NaN' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.NaN' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/NaN\n
The static Atomics.and() method computes a bitwise AND with a given value at a given position in the array, and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.
Atomics.and(typedArray, index, value)\n
typedArrayInt8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array.indextypedArray to compute the bitwise AND.valueThe old value at the given position (typedArray[index]).
TypeError, if typedArray is not one of the allowed integer types.TypeError, if typedArray is not a shared typed array type.RangeError, if index is out of bounds in the typedArray.The bitwise AND operation only yields 1, if both a and b are 1. The truth table for the AND operation is:
a | b | a & b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
For example, a bitwise AND of 5 & 1 results in 0001 which is 1 in decimal.
5 0101\n1 0001\n ----\n1 0001
var sab = new SharedArrayBuffer(1024);\nvar ta = new Uint8Array(sab);\nta[0] = 5;\n\nAtomics.and(ta, 0, 1); // returns 0, the old value\nAtomics.load(ta, 0); // 1\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.and' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/and\n
The static Atomics.compareExchange() method exchanges a given replacement value at a given position in the array, if a given expected value equals the old value. It returns the old value at that position whether it was equal to the expected value or not. This atomic operation guarantees that no other write happens until the modified value is written back.
Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)\n
typedArrayInt8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array.indextypedArray to exchange a value.expectedValueThe old value at the given position (typedArray[index]).
TypeError, if typedArray is not one of the allowed integer types.TypeError, if typedArray is not a shared typed array type.RangeError, if index is out of bounds in the typedArray.var sab = new SharedArrayBuffer(1024);\nvar ta = new Uint8Array(sab);\nta[0] = 7;\n\nAtomics.compareExchange(ta, 0, 7, 12); // returns 7, the old value\nAtomics.load(ta, 0); // 12
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.compareExchange' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange\n
The static Atomics.sub() method substracts a given value at a given position in the array and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.
Atomics.sub(typedArray, index, value)\n
typedArrayInt8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array.indextypedArray to subtract a value from.valueThe old value at the given position (typedArray[index]).
TypeError, if typedArray is not one of the allowed integer types.TypeError, if typedArray is not a shared typed array type.RangeError, if index is out of bounds in the typedArray.var sab = new SharedArrayBuffer(1024);\nvar ta = new Uint8Array(sab);\nta[0] = 48;\n\nAtomics.sub(ta, 0, 12); // returns 48, the old value\nAtomics.load(ta, 0); // 36\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.sub' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/sub\n
The Map[@@toStringTag] property has an initial value of \"Map\".
Property attributes of Map.prototype[@@toStringTag]\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
Map[Symbol.toStringTag]
Object.prototype.toString.call(new Map()) // \"[object Map]\"\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype[@@toStringTag]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype[@@toStringTag]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n44 | \nNo | \nNo | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n44 | \n44 | \nNo | \nNo | \nNo | \nNo | \n4.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@toStringTag\n
The static Atomics.store() method stores a given value at the given position in the array and returns that value.
Atomics.store(typedArray, index, value)\n
typedArrayInt8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array.indextypedArray to store a value in.valueThe value that has been stored.
TypeError, if typedArray is not one of the allowed integer types.TypeError, if typedArray is not a shared typed array type.RangeError, if index is out of bounds in the typedArray.var buffer = new ArrayBuffer(4); // common buffer\nvar float32 = new Float32Array(buffer); // floating point\nvar uint32 = new Uint32Array(buffer); // IEEE754 representation\n\nfloat32[0] = 0.5;\nconsole.log(\"0x\" + uint32[0].toString(16));\n\nuint32[0] = 0x3f000000; /// IEEE754 32-bit representation of 0.5\nconsole.log(float32[0]);\n\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.store' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/store\n
The static Atomics.wait() method verifies that a given position in an Int32Array still contains a given value and if so sleeps, awaiting a wakeup or a timeout. It returns a string which is either \"ok\", \"not-equal\", or \"timed-out\".
Note: This operation only works with a shared Int32Array and may not be allowed on the main thread.
Atomics.wait(typedArray, index, value[, timeout])\n
typedArrayInt32Array.indextypedArray to wait on.valuetimeout Optional\nInfinity, if no time is provided.A String which is either \"ok\", \"not-equal\", or \"timed-out\".
TypeError, if typedArray is not a shared Int32Array.RangeError, if index is out of bounds in the typedArray.Given a shared Int32Array:
var sab = new SharedArrayBuffer(1024);\nvar int32 = new Int32Array(sab);\n
A reading thread is sleeping and waiting on location 0 which is expected to be 0. As long as that is true, it will not go on. However, once the writing thread has stored a new value, it will be woken up by the writing thread and return the new value (123).
Atomics.wait(int32, 0, 0);\nconsole.log(int32[0]); // 123
A writing thread stores a new value and wakes up the waiting thread once it has written:
console.log(int32[0]); // 0;\nAtomics.store(int32, 0, 123); \nAtomics.wake(int32, 0, 1);
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.wait' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/wait\n
The Number.isNaN() method determines whether the passed value is NaN and its type is Number. It is a more robust version of the original, global isNaN().
Number.isNaN(value)
valueNaN.true if the given value is NaN and its type is Number; otherwise, false.
Due to both equality operators, == and ===, evaluating to false when checking if NaN is NaN, the function Number.isNaN() has become necessary. This situation is unlike all other possible value comparisons in JavaScript.
In comparison to the global isNaN() function, Number.isNaN() doesn't suffer the problem of forcefully converting the parameter to a number. This means it is now safe to pass values that would normally convert to NaN, but aren't actually the same value as NaN. This also means that only values of the type number, that are also NaN, return true.
Number.isNaN(NaN); // true\nNumber.isNaN(Number.NaN); // true\nNumber.isNaN(0 / 0); // true\n\n// e.g. these would have been true with global isNaN()\nNumber.isNaN('NaN'); // false\nNumber.isNaN(undefined); // false\nNumber.isNaN({}); // false\nNumber.isNaN('blabla'); // false\n\n// These all return false\nNumber.isNaN(true);\nNumber.isNaN(null);\nNumber.isNaN(37);\nNumber.isNaN('37');\nNumber.isNaN('37.37');\nNumber.isNaN('');\nNumber.isNaN(' ');\n The following works because NaN is the only value in javascript which is not equal to itself.
Number.isNaN = Number.isNaN || function(value) { \n return value !== value;\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.isnan' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.isnan' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n25 | \nYes | \n15 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n15 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN\n
The size accessor property returns the number of elements in a Map object.
The value of size is an integer representing how many entries the Map object has. A set accessor function for size is undefined; you can not change this property.
size\nvar myMap = new Map();\nmyMap.set('a', 'alpha');\nmyMap.set('b', 'beta');\nmyMap.set('g', 'gamma');\n\nmyMap.size // 3\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.size' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.size' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n 19\n
| \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n 19\n
| \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size\n
The Map[@@species] accessor property returns the Map constructor.
Map[Symbol.species]\n
The species accessor property returns the default constructor for Map objects. Subclass constructors may over-ride it to change the constructor assignment.
The species property returns the default constructor function, which is the Map constructor for Map objects:
Map[Symbol.species]; // function Map()
In a derived collection object (e.g. your custom map MyMap), the MyMap species is the MyMap constructor. However, you might want to overwrite this, in order to return parent Map objects in your derived class methods:
class MyMap extends Map {\n // Overwrite MyMap species to the parent Map constructor\n static get [Symbol.species]() { return Map; }\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'get Map [ @@species ]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'get Map [ @@species ]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n51 | \n13 | \n41 | \nNo | \n38 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n51 | \n51 | \n13 | \n41 | \n38 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.5.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@species\n
The get() method returns a specified element from a Map object.
myMap.get(key);
Map object.Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
get methodvar myMap = new Map();\nmyMap.set('bar', 'foo');\n\nmyMap.get('bar'); // Returns \"foo\".\nmyMap.get('baz'); // Returns undefined.\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.get' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.get' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get\n
The static Atomics.exchange() method stores a given value at a given position in the array and returns the old value at that position. This atomic operation guarantees that no other write happens between the read of the old value and the write of the new value.
Atomics.exchange(typedArray, index, value)\n
typedArrayInt8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array.indextypedArray to exchange a value.valueThe old value at the given position (typedArray[index]).
TypeError, if typedArray is not one of the allowed integer types.TypeError, if typedArray is not a shared typed array type.RangeError, if index is out of bounds in the typedArray.var sab = new SharedArrayBuffer(1024);\nvar ta = new Uint8Array(sab);\n\nAtomics.exchange(ta, 0, 12); // returns 0, the old value\nAtomics.load(ta, 0); // 12
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.exchange' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/exchange\n
The static Atomics.or() method computes a bitwise OR with a given value at a given position in the array, and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.
Atomics.or(typedArray, index, value)\n
typedArrayInt8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array.indextypedArray to compute the bitwise OR.valueThe old value at the given position (typedArray[index]).
TypeError, if typedArray is not one of the allowed integer types.TypeError, if typedArray is not a shared typed array type.RangeError, if index is out of bounds in the typedArray.The bitwise OR operation yields 1, if either a or b are 1. The truth table for the OR operation is:
a | b | a | b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
For example, a bitwise OR of 5 & 1 results in 0101 which is 5 in decimal.
5 0101\n1 0001\n ----\n5 0101\n
var sab = new SharedArrayBuffer(1024);\nvar ta = new Uint8Array(sab);\nta[0] = 2;\n\nAtomics.or(ta, 0, 1); // returns 2, the old value\nAtomics.load(ta, 0); // 3
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.or' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/or\n
The clear() method removes all elements from a Map object.
myMap.clear();
clear methodvar myMap = new Map();\nmyMap.set('bar', 'baz');\nmyMap.set(1, 'foo');\n\nmyMap.size; // 2\nmyMap.has('bar'); // true\n\nmyMap.clear();\n\nmyMap.size; // 0\nmyMap.has('bar') // false\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.clear' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.clear' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n19 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n19 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear\n
The delete() method removes the specified element from a Map object.
myMap.delete(key);
keyMap object.true if an element in the Map object existed and has been removed, or false if the element does not exist.
delete methodvar myMap = new Map();\nmyMap.set('bar', 'foo');\n\nmyMap.delete('bar'); // Returns true. Successfully removed.\nmyMap.has('bar'); // Returns false. The \"bar\" element is no longer present.\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.delete' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.delete' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete\n
The Map.prototype property represents the prototype for the Map constructor.
Property attributes of Map.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Map instances inherit from Map.prototype. You can use the constructor's prototype object to add properties or methods to all Map instances.
Map.prototype.constructorMap function by default.Map.prototype.sizeMap object.Map.prototype.clear()Map object.Map.prototype.delete(key)true if an element in the Map object existed and has been removed, or false if the element does not exist. Map.prototype.has(key) will return false afterwards.Map.prototype.entries()Iterator object that contains[key, value] for each element in the Map object in insertion order.Map.prototype.forEach(callbackFn[, thisArg])Map object, in insertion order. If a thisArg parameter is provided to forEach, it will be used as the this value for each callback.Map.prototype.get(key)key, or undefined if there is none.Map.prototype.has(key)key in the Map object or not.Map.prototype.keys()Iterator object that contains the keys for each element in the Map object in insertion order.Map.prototype.set(key, value)key in the Map object. Returns the Map object.Map.prototype.values()Iterator object that contains the values for each element in the Map object in insertion order.Map.prototype[@@iterator]()Iterator object that contains[key, value] for each element in the Map object in insertion order.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/prototype\n
The has() method returns a boolean indicating whether an element with the specified key exists or not.
myMap.has(key);
Map object.true if an element with the specified key exists in the Map object; otherwise false.has methodvar myMap = new Map();\nmyMap.set('bar', \"foo\");\n\nmyMap.has('bar'); // returns true\nmyMap.has('baz'); // returns false\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.has' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.has' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has\n
The static Atomics.notify() method notifies up some agents that are sleeping in the wait queue.
Note: This operation works with a shared Int32Array only.
Atomics.notify(typedArray, index, count)\n
typedArrayInt32Array.indextypedArray to wake up on.count+Infinity.A number of woken up agents.
TypeError, if typedArray is not a shared Int32Array.RangeError, if index is out of bounds in the typedArray.Given a shared Int32Array:
var sab = new SharedArrayBuffer(1024);\nvar int32 = new Int32Array(sab);\n
A reading thread is sleeping and waiting on location 0 which is expected to be 0. As long as that is true, it will not go on. However, once the writing thread has stored a new value, it will be notified by the writing thread and return the new value (123).
Atomics.wait(int32, 0, 0);\nconsole.log(int32[0]); // 123
A writing thread stores a new value and notifies the waiting thread once it has written:
console.log(int32[0]); // 0;\nAtomics.store(int32, 0, 123); \nAtomics.notify(int32, 0, 1);
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.notify' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 63\n
| \nNo | \nNo | \n10.1 — ?\n
| \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 63\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 8.10.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/notify\n
The forEach() method executes a provided function once per each key/value pair in the Map object, in insertion order.
myMap.forEach(callback[, thisArg])
callbackthisArgthis when executing callback.The forEach method executes the provided callback once for each key of the map which actually exist. It is not invoked for keys which have been deleted. However, it is executed for values which are present but have the value undefined.
callback is invoked with three arguments:
Map\nIf a thisArg parameter is provided to forEach, it will be passed to callback when invoked, for use as its this value. Otherwise, the value undefined will be passed for use as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
Each value is visited once, except in the case when it was deleted and re-added before forEach has finished. callback is not invoked for values deleted before being visited. New values added before forEach has finished will be visited.
forEach executes the callback function once for each element in the Map object; it does not return a value.
Map objectThe following code logs a line for each element in an Map object:
function logMapElements(value, key, map) {\n console.log(`m[${key}] = ${value}`);\n}\nnew Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(logMapElements);\n// logs:\n// \"m[foo] = 3\"\n// \"m[bar] = [object Object]\"\n// \"m[baz] = undefined\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.forEach' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.forEach' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n25 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n25 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach\n
The initial value of the @@iterator property is the same function object as the initial value of the entries method.
myMap[Symbol.iterator]
The map iterator function, which is the entries() function by default.
[@@iterator]()\nconst myMap = new Map();\nmyMap.set('0', 'foo');\nmyMap.set(1, 'bar');\nmyMap.set({}, 'baz');\n\nconst mapIter = myMap[Symbol.iterator]();\n\nconsole.log(mapIter.next().value); // [\"0\", \"foo\"]\nconsole.log(mapIter.next().value); // [1, \"bar\"]\nconsole.log(mapIter.next().value); // [Object, \"baz\"]\n [@@iterator]() with for..of\nconst myMap = new Map();\nmyMap.set('0', 'foo');\nmyMap.set(1, 'bar');\nmyMap.set({}, 'baz');\n\nfor (const entry of myMap) {\n console.log(entry);\n}\n// [\"0\", \"foo\"]\n// [1, \"bar\"]\n// [{}, \"baz\"]\n\nfor (const [key, value] of myMap) {\n console.log(`${key}: ${value}`);\n}\n// 0: foo\n// 1: bar\n// [Object]: baz\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype[@@iterator]()' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype[@@iterator]()' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n 36\n
| \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n 36\n
| \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@iterator\n
The static Atomics.xor() method computes a bitwise XOR with a given value at a given position in the array, and returns the old value at that position. This atomic operation guarantees that no other write happens until the modified value is written back.
Atomics.xor(typedArray, index, value)\n
typedArrayInt8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array.indextypedArray to compute the bitwise XOR.valueThe old value at the given position (typedArray[index]).
TypeError, if typedArray is not one of the allowed integer types.TypeError, if typedArray is not a shared typed array type.RangeError, if index is out of bounds in the typedArray.The bitwise XOR operation yields 1, if a and b are different. The truth table for the XOR operation is:
a | b | a ^ b |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
For example, a bitwise XOR of 5 & 1 results in 0100 which is 4 in decimal.
5 0101\n1 0001\n ----\n4 0100\n
var sab = new SharedArrayBuffer(1024);\nvar ta = new Uint8Array(sab);\nta[0] = 5;\n\nAtomics.xor(ta, 0, 1); // returns 5, the old value\nAtomics.load(ta, 0); // 4
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Atomics.xor' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics/xor\n
The entries() method returns a new Iterator object that contains the [key, value] pairs for each element in the Map object in insertion order.
myMap.entries()
A new Map iterator object.
entries()\nvar myMap = new Map();\nmyMap.set('0', 'foo');\nmyMap.set(1, 'bar');\nmyMap.set({}, 'baz');\n\nvar mapIter = myMap.entries();\n\nconsole.log(mapIter.next().value); // [\"0\", \"foo\"]\nconsole.log(mapIter.next().value); // [1, \"bar\"]\nconsole.log(mapIter.next().value); // [Object, \"baz\"]\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.entries' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.entries' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n20 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n20 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries\n
The set() method adds or updates an element with a specified key and value to a Map object.
myMap.set(key, value);
Map object.Map object.The Map object.
set methodvar myMap = new Map();\n\n// Add new elements to the map\nmyMap.set('bar', 'foo');\nmyMap.set(1, 'foobar');\n\n// Update an element in the map\nmyMap.set('bar', 'baz');\n set method with chainingSince the set() method returns back the same Map object, you can chain the method call like below:
// Add new elements to the map with chaining. \nmyMap.set('bar', 'foo')\n .set(1, 'foobar')\n .set(2, 'baz');\n\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.set' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.set' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11\n
| \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set\n
The values() method returns a new Iterator object that contains the values for each element in the Map object in insertion order.
myMap.values()
A new Map iterator object.
values()\nvar myMap = new Map();\nmyMap.set('0', 'foo');\nmyMap.set(1, 'bar');\nmyMap.set({}, 'baz');\n\nvar mapIter = myMap.values();\n\nconsole.log(mapIter.next().value); // \"foo\"\nconsole.log(mapIter.next().value); // \"bar\"\nconsole.log(mapIter.next().value); // \"baz\" | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.values' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.values' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n20 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n20 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values\n
The Promise.prototype property represents the prototype for the Promise constructor.
Property attributes of Promise.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Promise instances inherit from Promise.prototype. You can use the constructor's prototype object to add properties or methods to all Promise instances.
Promise.prototype.constructorPromise function by default.Promise.prototype.catch(onRejected)Promise.prototype.then(onFulfilled, onRejected)onFulfilled or onRejected is not a function).Promise.prototype.finally(onFinally)| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Promise.prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Promise.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/prototype\n
The Promise.race(iterable) method returns a promise that resolves or rejects as soon as one of the promises in the iterable resolves or rejects, with the value or reason from that promise.
Promise.race(iterable);
A pending Promise that asynchronously yields the value of first promise in the given iterable to resolve or reject.
The race function returns a Promise that is settled the same way (and takes the same value) as the first promise that settles amongst the promises of the iterable passed as argument.
If the iterable passed is empty, the promise returned will be forever pending.
If the iterable contains one or more non-promise value and/or an already resolved/rejected promise, then Promise.race will resolve to the first of these values found in the iterable.
Promise.raceThis following example demonstrates the asynchronicity of Promise.race:
// we are passing as argument an array of promises that are already resolved,\n// to trigger Promise.race as soon as possible\nvar resolvedPromisesArray = [Promise.resolve(33), Promise.resolve(44)];\n\nvar p = Promise.race(resolvedPromisesArray);\n// immediately logging the value of p\nconsole.log(p);\n\n// using setTimeout we can execute code after the stack is empty\nsetTimeout(function(){\n console.log('the stack is now empty');\n console.log(p);\n});\n\n// logs, in order:\n// Promise { <state>: \"pending\" }\n// the stack is now empty\n// Promise { <state>: \"fulfilled\", <value>: 33 } An empty iterable causes the returned promise to be forever pending:
var foreverPendingPromise = Promise.race([]);\nconsole.log(foreverPendingPromise);\nsetTimeout(function(){\n console.log('the stack is now empty');\n console.log(foreverPendingPromise);\n});\n\n// logs, in order:\n// Promise { <state>: \"pending\" }\n// the stack is now empty\n// Promise { <state>: \"pending\" }\n If the iterable contains one or more non-promise value and/or an already resolved/rejected promise, then Promise.race will resolve to the first of these values found in the array:
var foreverPendingPromise = Promise.race([]);\nvar alreadyResolvedProm = Promise.resolve(666);\n\nvar arr = [foreverPendingPromise, alreadyResolvedProm, \"non-Promise value\"];\nvar arr2 = [foreverPendingPromise, \"non-Promise value\", Promise.resolve(666)];\nvar p = Promise.race(arr);\nvar p2 = Promise.race(arr2);\n\nconsole.log(p);\nconsole.log(p2);\nsetTimeout(function(){\n console.log('the stack is now empty');\n console.log(p);\n console.log(p2);\n});\n\n// logs, in order:\n// Promise { <state>: \"pending\" } \n// Promise { <state>: \"pending\" } \n// the stack is now empty\n// Promise { <state>: \"fulfilled\", <value>: 666 }\n// Promise { <state>: \"fulfilled\", <value>: \"non-Promise value\" }\n Promise.race – examples with setTimeout\nvar p1 = new Promise(function(resolve, reject) { \n setTimeout(() => resolve('one'), 500); \n});\nvar p2 = new Promise(function(resolve, reject) { \n setTimeout(() => resolve('two'), 100); \n});\n\nPromise.race([p1, p2])\n.then(function(value) {\n console.log(value); // \"two\"\n // Both resolve, but p2 is faster\n});\n\nvar p3 = new Promise(function(resolve, reject) { \n setTimeout(() => resolve('three'), 100);\n});\nvar p4 = new Promise(function(resolve, reject) { \n setTimeout(() => reject(new Error('four')), 500); \n});\n\nPromise.race([p3, p4])\n.then(function(value) {\n console.log(value); // \"three\"\n // p3 is faster, so it resolves\n}, function(reason) {\n // Not called\n});\n\nvar p5 = new Promise(function(resolve, reject) { \n setTimeout(() => resolve('five'), 500); \n});\nvar p6 = new Promise(function(resolve, reject) { \n setTimeout(() => reject(new Error('six')), 100);\n});\n\nPromise.race([p5, p6])\n.then(function(value) {\n // Not called\n}, function(error) {\n console.log(error.message); // \"six\"\n // p6 is faster, so it rejects\n});\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Promise.race' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Promise.race' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race\n
The Promise.resolve(value) method returns a Promise object that is resolved with the given value. If the value is a promise, that promise is returned; if the value is a thenable (i.e. has a \"then\" method), the returned promise will \"follow\" that thenable, adopting its eventual state; otherwise the returned promise will be fulfilled with the value. This function flattens nested layers of promise-like objects (e.g. a promise that resolves to a promise that resolves to something) into a single layer.
Warning: Do not call Promise.resolve on a thenable that resolves to itself. This will cause infinite recursion as it tries to flatten what seems to be an infinitely nested promise. An example would be using it along with the async Pipe in Angular. Find more on that here.
Promise.resolve(value);\nPromise.resolve(promise);\nPromise.resolve(thenable); \n
Promise. Can also be a Promise or a thenable to resolve.A Promise that is resolved with the given value, or the promise passed as value, if the value was a promise object.
The static Promise.resolve function returns a Promise that is resolved.
Promise.resolve methodPromise.resolve('Success').then(function(value) {\n console.log(value); // \"Success\"\n}, function(value) {\n // not called\n});\n var p = Promise.resolve([1,2,3]);\np.then(function(v) {\n console.log(v[0]); // 1\n});\n Promise\nvar original = Promise.resolve(33);\nvar cast = Promise.resolve(original);\ncast.then(function(value) {\n console.log('value: ' + value);\n});\nconsole.log('original === cast ? ' + (original === cast));\n\n// logs, in order:\n// original === cast ? true\n// value: 33\n The inverted order of the logs is due to the fact that the then handlers are called asynchronously. See how then works here.
// Resolving a thenable object\nvar p1 = Promise.resolve({ \n then: function(onFulfill, onReject) { onFulfill('fulfilled!'); }\n});\nconsole.log(p1 instanceof Promise) // true, object casted to a Promise\n\np1.then(function(v) {\n console.log(v); // \"fulfilled!\"\n }, function(e) {\n // not called\n});\n\n// Thenable throws before callback\n// Promise rejects\nvar thenable = { then: function(resolve) {\n throw new TypeError('Throwing');\n resolve('Resolving');\n}};\n\nvar p2 = Promise.resolve(thenable);\np2.then(function(v) {\n // not called\n}, function(e) {\n console.log(e); // TypeError: Throwing\n});\n\n// Thenable throws after callback\n// Promise resolves\nvar thenable = { then: function(resolve) {\n resolve('Resolving');\n throw new TypeError('Throwing');\n}};\n\nvar p3 = Promise.resolve(thenable);\np3.then(function(v) {\n console.log(v); // \"Resolving\"\n}, function(e) {\n // not called\n});\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Promise.resolve' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Promise.resolve' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/resolve\n
The keys() method returns a new Iterator object that contains the keys for each element in the Map object in insertion order.
myMap.keys()
A new Map iterator object.
keys()\nvar myMap = new Map();\nmyMap.set('0', 'foo');\nmyMap.set(1, 'bar');\nmyMap.set({}, 'baz');\n\nvar mapIter = myMap.keys();\n\nconsole.log(mapIter.next().value); // \"0\"\nconsole.log(mapIter.next().value); // 1\nconsole.log(mapIter.next().value); // Object\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Map.prototype.keys' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Map.prototype.keys' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n20 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n20 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys\n
The catch() method returns a Promise and deals with rejected cases only. It behaves the same as calling Promise.prototype.then(undefined, onRejected) (in fact, calling obj.catch(onRejected) internally calls obj.then(undefined, onRejected)). This means, that you have to provide onRejected function even if you want to fallback to undefined result value - for example obj.catch(() => {}).
p.catch(onRejected);\n\np.catch(function(reason) {\n // rejection\n});\n Function called when the Promise is rejected. This function has one argument: reasoncatch() is rejected if onRejected throws an error or returns a Promise which is itself rejected; otherwise, it is resolved.Internally calls Promise.prototype.then on the object upon which is called, passing the parameters undefined and the onRejected handler received; then returns the value of that call (which is a Promise).
The examples below are throwing strings. This is considered bad practice. Always throw an instance of Error. Otherwise the part doing the catching would have to make checks to see if the argument was a string or an error, and you might lose valuable information like stack traces
Demonstration of the internal call:
// overriding original Promise.prototype.then/catch just to add some logs\n(function(Promise){\n var originalThen = Promise.prototype.then;\n var originalCatch = Promise.prototype.catch;\n \n Promise.prototype.then = function(){\n console.log('> > > > > > called .then on %o with arguments: %o', this, arguments);\n return originalThen.apply(this, arguments);\n };\n Promise.prototype.catch = function(){\n console.log('> > > > > > called .catch on %o with arguments: %o', this, arguments);\n return originalCatch.apply(this, arguments);\n };\n\n})(this.Promise);\n\n\n\n// calling catch on an already resolved promise\nPromise.resolve().catch(function XXX(){});\n\n// logs:\n// > > > > > > called .catch on Promise{} with arguments: Arguments{1} [0: function XXX()]\n// > > > > > > called .then on Promise{} with arguments: Arguments{2} [0: undefined, 1: function XXX()]\n The catch method can be useful for error handling in your promise composition.
catch methodvar p1 = new Promise(function(resolve, reject) {\n resolve('Success');\n});\n\np1.then(function(value) {\n console.log(value); // \"Success!\"\n throw 'oh, no!';\n}).catch(function(e) {\n console.log(e); // \"oh, no!\"\n}).then(function(){\n console.log('after a catch the chain is restored');\n}, function () {\n console.log('Not fired due to the catch');\n});\n\n// The following behaves the same as above\np1.then(function(value) {\n console.log(value); // \"Success!\"\n return Promise.reject('oh, no!');\n}).catch(function(e) {\n console.log(e); // \"oh, no!\"\n}).then(function(){\n console.log('after a catch the chain is restored');\n}, function () {\n console.log('Not fired due to the catch');\n});\n // Throwing an error will call the catch method most of the time\nvar p1 = new Promise(function(resolve, reject) {\n throw 'Uh-oh!';\n});\n\np1.catch(function(e) {\n console.log(e); // \"Uh-oh!\"\n});\n\n// Errors thrown inside asynchronous functions will act like uncaught errors\nvar p2 = new Promise(function(resolve, reject) {\n setTimeout(function() {\n throw 'Uncaught Exception!';\n }, 1000);\n});\n\np2.catch(function(e) {\n console.log(e); // This is never called\n});\n\n// Errors thrown after resolve is called will be silenced\nvar p3 = new Promise(function(resolve, reject) {\n resolve();\n throw 'Silenced Exception!';\n});\n\np3.catch(function(e) {\n console.log(e); // This is never called\n}); //Create a promise which would not call onReject\nvar p1 = Promise.resolve(\"calling next\");\n\nvar p2 = p1.catch(function (reason) {\n //This is never called\n console.log(\"catch p1!\");\n console.log(reason);\n});\n\np2.then(function (value) {\n console.log(\"next promise's onFulfilled\"); /* next promise's onFulfilled */\n console.log(value); /* calling next */\n}, function (reason) {\n console.log(\"next promise's onRejected\");\n console.log(reason);\n}); | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Promise.prototype.catch' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Promise.prototype.catch' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch\n
The handler.apply() method is a trap for a function call.
var p = new Proxy(target, {\n apply: function(target, thisArg, argumentsList) {\n }\n});\n The following parameters are passed to the apply method. this is bound to the handler.
targetthisArgargumentsListThe apply method can return any value.
The handler.apply method is a trap for a function call.
This trap can intercept these operations:
proxy(...args)Function.prototype.apply() and Function.prototype.call()\nReflect.apply()If the following invariants are violated, the proxy will throw a TypeError:
The target must be a callable itself. That is, it must be a function object.
The following code traps a function call.
var p = new Proxy(function() {}, {\n apply: function(target, thisArg, argumentsList) {\n console.log('called: ' + argumentsList.join(', '));\n return argumentsList[0] + argumentsList[1] + argumentsList[2];\n }\n});\n\nconsole.log(p(1, 2, 3)); // \"called: 1, 2, 3\"\n // 6\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[Call]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[Call]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/apply\n
The handler.construct() method is a trap for the new operator. In order for the new operation to be valid on the resulting Proxy object, the target used to initialize the proxy must itself have a [[Construct]] internal method (i.e. new target must be valid).
var p = new Proxy(target, {\n construct: function(target, argumentsList, newTarget) {\n }\n});\n The following parameters are passed to the construct method. this is bound to the handler.
targetargumentsListnewTargetp above.The construct method must return an object.
The handler.construct() method is a trap for the new operator.
This trap can intercept these operations:
new proxy(...args)Reflect.construct()If the following invariants are violated, the proxy will throw a TypeError:
Object.The following code traps the new operator.
var p = new Proxy(function() {}, {\n construct: function(target, argumentsList, newTarget) {\n console.log('called: ' + argumentsList.join(', '));\n return { value: argumentsList[0] * 10 };\n }\n});\n\nconsole.log(new p(1).value); // \"called: 1\"\n // 10\n The following code violates the invariant.
var p = new Proxy(function() {}, {\n construct: function(target, argumentsList, newTarget) {\n return 1;\n }\n});\n\nnew p(); // TypeError is thrown\n The following code improperly initializes the proxy. The target in Proxy initialization must itself be a valid constructor for the new operator.
var p = new Proxy({}, {\n construct: function(target, argumentsList, newTarget) {\n return {};\n }\n});\n\nnew p(); // TypeError is thrown, \"p\" is not a constructor\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[Construct]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[Construct]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
Proxyhandlernew operator.Reflect.construct()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/construct\n
The handler.deleteProperty() method is a trap for the delete operator.
var p = new Proxy(target, {\n deleteProperty: function(target, property) {\n }\n});\n The following parameters are passed to the deleteProperty method. this is bound to the handler.
targetpropertySymbol of the property to delete.The deleteProperty method must return a Boolean indicating whether or not the property has been successfully deleted.
The handler.deleteProperty() method is a trap for the delete operator.
This trap can intercept these operations:
delete proxy[foo] and delete proxy.foo\nReflect.deleteProperty()If the following invariants are violated, the proxy will throw a TypeError:
The following code traps the delete operator.
var p = new Proxy({}, {\n deleteProperty: function(target, prop) {\n if (prop in target){\n delete target[prop]\n console.log('property removed: ' + prop)\n return true\n }\n else {\n console.log('property not found: ' + prop)\n return false\n }\n }\n})\n\nvar result\n\np.a = 10\nconsole.log('a' in p) // true\n\nresult = delete p.a // \"property removed: a\"\nconsole.log(result) // true\nconsole.log('a' in p) // false\n\nresult = delete p.a // \"property not found: a\"\nconsole.log(result) // false\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[Delete]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[Delete]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
Proxyhandlerdelete operatorReflect.deleteProperty()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/deleteProperty\n
The Promise.all(iterable) method returns a single Promise that resolves when all of the promises in the iterable argument have resolved or when the iterable argument contains no promises. It rejects with the reason of the first promise that rejects.
Promise.all(iterable);
Promise if the iterable passed is empty.Promise if the iterable passed contains no promises. Note, Google Chrome 58 returns an already resolved promise in this case.Promise in all other cases. This returned promise is then resolved/rejected asynchronously (as soon as the stack is empty) when all the promises in the given iterable have resolved, or if any of the promises reject. See the example about \"Asynchronicity or synchronicity of Promise.all\" below. Returned values will be in order of the Promises passed, regardless of completion order.This method can be useful for aggregating the results of multiple promises.
Fulfillment:
If an empty iterable is passed, then this method returns (synchronously) an already resolved promise.
If all of the passed-in promises fulfill, or are not promises, the promise returned by Promise.all is fulfilled asynchronously.
In all cases, the returned promise is fulfilled with an array containing all the values of the iterable passed as argument (also non-promise values).
Rejection:
If any of the passed-in promises reject, Promise.all asynchronously rejects with the value of the promise that rejected, whether or not the other promises have resolved.
Promise.all\nPromise.all waits for all fulfillments (or the first rejection).
var p1 = Promise.resolve(3);\nvar p2 = 1337;\nvar p3 = new Promise((resolve, reject) => {\n setTimeout(() => {\n resolve(\"foo\");\n }, 100);\n}); \n\nPromise.all([p1, p2, p3]).then(values => { \n console.log(values); // [3, 1337, \"foo\"] \n}); If the iterable contains non-promise values, they will be ignored, but still counted in the returned promise array value (if the promise is fulfilled):
// this will be counted as if the iterable passed is empty, so it gets fulfilled\nvar p = Promise.all([1,2,3]);\n// this will be counted as if the iterable passed contains only the resolved promise with value \"444\", so it gets fulfilled\nvar p2 = Promise.all([1,2,3, Promise.resolve(444)]);\n// this will be counted as if the iterable passed contains only the rejected promise with value \"555\", so it gets rejected\nvar p3 = Promise.all([1,2,3, Promise.reject(555)]);\n\n// using setTimeout we can execute code after the stack is empty\nsetTimeout(function() {\n console.log(p);\n console.log(p2);\n console.log(p3);\n});\n\n// logs\n// Promise { <state>: \"fulfilled\", <value>: Array[3] }\n// Promise { <state>: \"fulfilled\", <value>: Array[4] }\n// Promise { <state>: \"rejected\", <reason>: 555 } Promise.all\nThis following example demonstrates the asynchronicity (or synchronicity, if the iterable passed is empty) of Promise.all:
// we are passing as argument an array of promises that are already resolved,\n// to trigger Promise.all as soon as possible\nvar resolvedPromisesArray = [Promise.resolve(33), Promise.resolve(44)];\n\nvar p = Promise.all(resolvedPromisesArray);\n// immediately logging the value of p\nconsole.log(p);\n\n// using setTimeout we can execute code after the stack is empty\nsetTimeout(function() {\n console.log('the stack is now empty');\n console.log(p);\n});\n\n// logs, in order:\n// Promise { <state>: \"pending\" } \n// the stack is now empty\n// Promise { <state>: \"fulfilled\", <value>: Array[2] }\n The same thing happens if Promise.all rejects:
var mixedPromisesArray = [Promise.resolve(33), Promise.reject(44)];\nvar p = Promise.all(mixedPromisesArray);\nconsole.log(p);\nsetTimeout(function() {\n console.log('the stack is now empty');\n console.log(p);\n});\n\n// logs\n// Promise { <state>: \"pending\" } \n// the stack is now empty\n// Promise { <state>: \"rejected\", <reason>: 44 }\n But, Promise.all resolves synchronously if and only if the iterable passed is empty:
var p = Promise.all([]); // will be immediately resolved\nvar p2 = Promise.all([1337, \"hi\"]); // non-promise values will be ignored, but the evaluation will be done asynchronously\nconsole.log(p);\nconsole.log(p2)\nsetTimeout(function() {\n console.log('the stack is now empty');\n console.log(p2);\n});\n\n// logs\n// Promise { <state>: \"fulfilled\", <value>: Array[0] }\n// Promise { <state>: \"pending\" }\n// the stack is now empty\n// Promise { <state>: \"fulfilled\", <value>: Array[2] }\n Promise.all fail-fast behaviourPromise.all is rejected if any of the elements are rejected. For example, if you pass in four promises that resolve after a timeout and one promise that rejects immediately, then Promise.all will reject immediately.
var p1 = new Promise((resolve, reject) => { \n setTimeout(() => resolve('one'), 1000); \n}); \nvar p2 = new Promise((resolve, reject) => { \n setTimeout(() => resolve('two'), 2000); \n});\nvar p3 = new Promise((resolve, reject) => {\n setTimeout(() => resolve('three'), 3000);\n});\nvar p4 = new Promise((resolve, reject) => {\n setTimeout(() => resolve('four'), 4000);\n});\nvar p5 = new Promise((resolve, reject) => {\n reject(new Error('reject'));\n});\n\n\n// Using .catch:\nPromise.all([p1, p2, p3, p4, p5])\n.then(values => { \n console.log(values);\n})\n.catch(error => { \n console.log(error.message)\n});\n\n//From console: \n//\"reject\"\n\n It is possible to change this behaviour by handling possible rejections:
var p1 = new Promise((resolve, reject) => { \n setTimeout(() => resolve('p1_delayed_resolvement'), 1000); \n}); \n\nvar p2 = new Promise((resolve, reject) => {\n reject(new Error('p2_immediate_rejection'));\n});\n\nPromise.all([\n p1.catch(error => { return error }),\n p2.catch(error => { return error }),\n]).then(values => { \n console.log(values[0]) // \"p1_delayed_resolvement\"\n console.log(values[1]) // \"Error: p2_immediate_rejection\"\n})\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Promise.all' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Promise.all' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all\n
The finally() method returns a Promise. When the promise is settled, whether fulfilled or rejected, the specified callback function is executed. This provides a way for code that must be executed once the Promise has been dealt with to be run whether the promise was fulfilled successfully or rejected.
This lets you avoid duplicating code in both the promise's then() and catch() handlers.
p.finally(onFinally);\n\np.finally(function() {\n // settled (fulfilled or rejected)\n});\n onFinallyFunction called when the Promise is settled.Returns a Promise whose finally handler is set to the specified function, onFinally.
The finally() method can be useful if you want to do some processing or cleanup once the promise is settled, regardless of its outcome.
The finally() method is very similar to calling .then(onFinally, onFinally) however there are couple of differences:
finally callback will not receive any argument, since there's no reliable means of determining if the promise was fulfilled or rejected. This use case is for precisely when you do not care about the rejection reason, or the fulfillment value, and so there's no need to provide it.Promise.resolve(2).then(() => {}, () => {}) (which will be resolved with undefined), Promise.resolve(2).finally(() => {}) will be resolved with 2.Promise.reject(3).then(() => {}, () => {}) (which will be fulfilled with undefined), Promise.reject(3).finally(() => {}) will be rejected with 3.Note: A throw (or returning a rejected promise) in the finally callback will reject the new promise with the rejection reason specified when calling throw().
let isLoading = true;\n\nfetch(myRequest).then(function(response) {\n var contentType = response.headers.get(\"content-type\");\n if(contentType && contentType.includes(\"application/json\")) {\n return response.json();\n }\n throw new TypeError(\"Oops, we haven't got JSON!\");\n })\n .then(function(json) { /* process your JSON further */ })\n .catch(function(error) { console.log(error); /* this line can also throw, e.g. when console = {} */ })\n .finally(function() { isLoading = false; });\n\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Promise.prototype.finally' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n63 | \n18 | \n58 | \nNo | \n50 | \n11.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n63 | \n63 | \nNo | \n58 | \n50 | \n11.1 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n10.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/finally\n
The then() method returns a Promise. It takes up to two arguments: callback functions for the success and failure cases of the Promise.
If one or both arguments are omitted or are provided non-functions, then then will be missing the handler(s), but will not generate any errors. If the Promise that then is called on adopts a state (fulfillment or rejection) for which then has no handler, a new Promise is created with no additional handlers, simply adopting the final state of the original Promise on which then was called.
p.then(onFulfilled[, onRejected]);\n\np.then((value) => {\n // fulfillment\n}, (reason) => {\n // rejection\n});\n onFulfilledFunction called if the Promise is fulfilled. This function has one argument, the fulfillment value. If it is not a function, it is internally replaced with an \"Identity\" function (it returns the received argument).onRejected Optional\nFunction called if the Promise is rejected. This function has one argument, the rejection reason. If it is not a function, it is internally replaced with a \"Thrower\" function (it throws an error it received as argument).Once a Promise is fulfilled or rejected, the respective handler function (onFulfilled or onRejected) will be called asynchronously (scheduled in the current thread loop). The behavior of the handler function follows a specific set of rules. If a handler function:
then gets resolved with the returned value as its value;then gets resolved with an undefined value;then gets rejected with the thrown error as its value;then gets resolved with that promise's value as its value;then gets rejected with that promise's value as its value;then will be subsequent to the resolution/rejection of the promise returned by the handler. Also, the value of the promise returned by then will be the same as the value of the promise returned by the handler.Following, an example to demonstrate the asynchronicity of the then method.
// using a resolved promise, the 'then' block will be triggered instantly, \n// but its handlers will be triggered asynchronously as demonstrated by the console.logs\nconst resolvedProm = Promise.resolve(33);\n\nlet thenProm = resolvedProm.then((value)=>{\n console.log(\"this gets called after the end of the main stack. the value received and returned is: \" + value);\n return value;\n});\n// instantly logging the value of thenProm\nconsole.log(thenProm);\n\n// using setTimeout we can postpone the execution of a function to the moment the stack is empty\nsetTimeout(()=>{\n console.log(thenProm);\n});\n\n\n// logs, in order:\n// Promise {[[PromiseStatus]]: \"pending\", [[PromiseValue]]: undefined}\n// \"this gets called after the end of the main stack. the value received and returned is: 33\"\n// Promise {[[PromiseStatus]]: \"resolved\", [[PromiseValue]]: 33} As the then and Promise.prototype.catch() methods return promises, they can be chained — an operation called composition.
then methodvar p1 = new Promise( (resolve, reject) => {\n resolve('Success!');\n // or\n // reject(new Error(\"Error!\"));\n} );\n\np1.then( value => {\n console.log(value); // Success!\n}, reason => {\n console.log(reason); // Error!\n} );\n The then method returns a Promise which allows for method chaining.
If the function passed as handler to then returns a Promise, an equivalent Promise will be exposed to the subsequent then in the method chain. The below snippet simulates asynchronous code with the setTimeout function.
Promise.resolve('foo')\n // 1. Receive \"foo\", concatenate \"bar\" to it, and resolve that to the next then\n .then(function(string) {\n return new Promise(function(resolve, reject) {\n setTimeout(function() {\n string += 'bar';\n resolve(string);\n }, 1);\n });\n })\n // 2. receive \"foobar\", register a callback function to work on that string\n // and print it to the console, but not before returning the unworked on\n // string to the next then\n .then(function(string) {\n setTimeout(function() {\n string += 'baz';\n console.log(string);\n }, 1)\n return string;\n })\n // 3. print helpful messages about how the code in this section will be run\n // before the string is actually processed by the mocked asynchronous code in the\n // previous then block. \n .then(function(string) {\n console.log(\"Last Then: oops... didn't bother to instantiate and return \" +\n \"a promise in the prior then so the sequence may be a bit \" +\n \"surprising\");\n\n // Note that `string` will not have the 'baz' bit of it at this point. This \n // is because we mocked that to happen asynchronously with a setTimeout function\n console.log(string);\n });\n\n// logs, in order:\n// Last Then: oops... didn't bother to instantiate and return a promise in the prior then so the sequence may be a bit surprising\n// foobar\n// foobarbaz When a value is simply returned from within a then handler, it will effectively return Promise.resolve(<value returned by whichever handler was called>).
var p2 = new Promise(function(resolve, reject) {\n resolve(1);\n});\n\np2.then(function(value) {\n console.log(value); // 1\n return value + 1;\n}).then(function(value) {\n console.log(value + ' - A synchronous value works');\n});\n\np2.then(function(value) {\n console.log(value); // 1\n});\n A then call will return a rejected promise if the function throws an error or returns a rejected Promise.
Promise.resolve()\n .then( () => {\n // Makes .then() return a rejected promise\n throw new Error('Oh no!');\n })\n .then( () => { \n console.log( 'Not called.' );\n }, error => {\n console.error( 'onRejected function called: ' + error.message );\n }); In all other cases, a resolving Promise is returned. In the following example, the first then() will return 42 wrapped resolving Promise even though the previous Promise in the chain was rejected.
Promise.reject()\n .then( () => 99, () => 42 ) // onRejected returns 42 which is wrapped in a resolving Promise\n .then( solution => console.log( 'Resolved with ' + solution ) ); // Resolved with 42
In practice, it is often desirable to catch rejected promises rather than use then's two case syntax, as demonstrated below.
Promise.resolve()\n .then( () => {\n // Makes .then() return a rejected promise\n throw new Error('Oh no!');\n })\n .catch( error => {\n console.error( 'onRejected function called: ' + error.message );\n })\n .then( () => {\n console.log( \"I am always called even if the prior then's promise rejects\" );\n });
You can also use chaining to implement one function with a Promise-based API on top of another such function.
function fetch_current_data() {\n // The fetch() API returns a Promise. This function\n // exposes a similar API, except the fulfillment\n // value of this function's Promise has had more\n // work done on it.\n return fetch('current-data.json').then((response) => {\n if (response.headers.get('content-type') != 'application/json') {\n throw new TypeError();\n }\n var j = response.json();\n // maybe do something with j\n return j; // fulfillment value given to user of\n // fetch_current_data().then()\n });\n}\n If onFulfilled returns a promise, the return value of then will be resolved/rejected by the promise.
function resolveLater(resolve, reject) {\n setTimeout(function () {\n resolve(10);\n }, 1000);\n}\nfunction rejectLater(resolve, reject) {\n setTimeout(function () {\n reject(new Error('Error'));\n }, 1000);\n}\n\nvar p1 = Promise.resolve('foo');\nvar p2 = p1.then(function() {\n // Return promise here, that will be resolved to 10 after 1 second\n return new Promise(resolveLater);\n});\np2.then(function(v) {\n console.log('resolved', v); // \"resolved\", 10\n}, function(e) {\n // not called\n console.log('rejected', e);\n});\n\nvar p3 = p1.then(function() {\n // Return promise here, that will be rejected with 'Error' after 1 second\n return new Promise(rejectLater);\n});\np3.then(function(v) {\n // not called\n console.log('resolved', v);\n}, function(e) {\n console.log('rejected', e); // \"rejected\", 'Error'\n});\n window.setImmediate style promise-based polyfillUsing a Function.prototype.bind() Reflect.apply (Reflect.apply()) method to create a (non-cancellable) setImmediate-style function.
const nextTick = (()=>{\n const noop = () => {}; // literally\n const nextTickPromise = () => Promise.resolve().then(noop);\n\n const rfab = Reflect.apply.bind; // (thisArg, fn, thisArg, [...args])\n const nextTick = (fn, ...args) => (\n fn !== undefined\n ? Promise.resolve(args).then(rfab(null, fn, null))\n : nextTickPromise(),\n undefined\n );\n nextTick.ntp = nextTickPromise;\n\n return nextTick;\n})();\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Promise.prototype.then' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Promise.prototype.then' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then\n
The handler.defineProperty() method is a trap for Object.defineProperty().
var p = new Proxy(target, {\n defineProperty: function(target, property, descriptor) {\n }\n});\n The following parameters are passed to the defineProperty method. this is bound to the handler.
targetpropertySymbol of the property whose description is to be retrieved.descriptorThe defineProperty method must return a Boolean indicating whether or not the property has been successfully defined.
The handler.defineProperty() method is a trap for Object.defineProperty().
This trap can intercept these operations:
If the following invariants are violated, the proxy will throw a TypeError:
Object.defineProperty(target, prop, descriptor) will not throw an exception.false return value from the defineProperty handler will throw a TypeError exception.The following code traps Object.defineProperty().
var p = new Proxy({}, {\n defineProperty: function(target, prop, descriptor) {\n console.log('called: ' + prop);\n return true;\n }\n});\n\nvar desc = { configurable: true, enumerable: true, value: 10 };\nObject.defineProperty(p, 'a', desc); // \"called: a\"\n When calling Object.defineProperty() or Reflect.defineProperty(), the descriptor passed to defineProperty trap has one restriction - only following properties are usable, nonstandard properties will be ignored:
enumerableconfigurablewritablevaluegetsetvar p = new Proxy({}, {\n defineProperty(target, prop, descriptor) {\n console.log(descriptor);\n return Reflect.defineProperty(target, prop, descriptor);\n }\n});\n\nObject.defineProperty(p, 'name', {\n value: 'proxy',\n type: 'custom'\n}); // { value: 'proxy' }\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[DefineOwnProperty]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[DefineOwnProperty]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/defineProperty\n
The handler.get() method is a trap for getting a property value.
var p = new Proxy(target, {\n get: function(target, property, receiver) {\n }\n});\n The following parameters are passed to the get method. this is bound to the handler.
targetpropertySymbol of the property to get. receiverThe get method can return any value.
The handler.get method is a trap for getting a property value.
This trap can intercept these operations:
proxy[foo]and proxy.bar\nObject.create(proxy)[foo]\nReflect.get()If the following invariants are violated, the proxy will throw a TypeError:
The following code traps getting a property value.
var p = new Proxy({}, {\n get: function(target, property, receiver) {\n console.log('called: ' + property);\n return 10;\n }\n});\n\nconsole.log(p.a); // \"called: a\"\n // 10\n The following code violates an invariant.
var obj = {};\nObject.defineProperty(obj, 'a', { \n configurable: false, \n enumerable: false, \n value: 10, \n writable: false \n});\n\nvar p = new Proxy(obj, {\n get: function(target, property) {\n return 20;\n }\n});\n\np.a; // TypeError is thrown\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[Get]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[Get]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get\n
The handler.getOwnPropertyDescriptor() method is a trap for Object.getOwnPropertyDescriptor().
var p = new Proxy(target, {\n getOwnPropertyDescriptor: function(target, prop) {\n }\n});\n The following parameters are passed to the getOwnPropertyDescriptor method. this is bound to the handler.
targetpropThe getOwnPropertyDescriptor method must return an object or undefined.
The handler.getOwnPropertyDescriptor() method is a trap for Object.getOwnPropertyDescriptor().
This trap can intercept these operations:
If the following invariants are violated, the proxy will throw a TypeError:
getOwnPropertyDescriptor must return an object or undefined.Object.getOwnPropertyDescriptor(target) can be applied to the target object using Object.defineProperty and will not throw an exception.The following code traps Object.getOwnPropertyDescriptor().
var p = new Proxy({ a: 20}, {\n getOwnPropertyDescriptor: function(target, prop) {\n console.log('called: ' + prop);\n return { configurable: true, enumerable: true, value: 10 };\n }\n});\n\nconsole.log(Object.getOwnPropertyDescriptor(p, 'a').value); // \"called: a\"\n // 10\n The following code violates an invariant.
var obj = { a: 10 };\nObject.preventExtensions(obj);\nvar p = new Proxy(obj, {\n getOwnPropertyDescriptor: function(target, prop) {\n return undefined;\n }\n});\n\nObject.getOwnPropertyDescriptor(p, 'a'); // TypeError is thrown\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[GetOwnProperty]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[GetOwnProperty]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor\n
The Proxy.revocable() method is used to create a revocable Proxy object.
Proxy.revocable(target, handler);\n
targetProxy. It can be any sort of object, including a native array, a function or even another proxy.handlerA newly created revocable Proxy object is returned.
A revocable Proxy is an object with following two properties {proxy: proxy, revoke: revoke}.
proxynew Proxy(target, handler) call.revokeproxy.If the revoke() function gets called, the proxy becomes unusable: Any trap to a handler will throw a TypeError. Once a proxy is revoked, it will remain revoked and can be garbage collected. Calling revoke() again has no effect.
var revocable = Proxy.revocable({}, {\n get: function(target, name) {\n return \"[[\" + name + \"]]\";\n }\n});\nvar proxy = revocable.proxy;\nconsole.log(proxy.foo); // \"[[foo]]\"\n\nrevocable.revoke();\n\nconsole.log(proxy.foo); // TypeError is thrown\nproxy.foo = 1 // TypeError again\ndelete proxy.foo; // still TypeError\ntypeof proxy // \"object\", typeof doesn't trigger any trap\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Proxy Revocation Functions' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Proxy Revocation Functions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n34 | \nNo | \nYes | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n34 | \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/revocable\n
The Promise.reject(reason) method returns a Promise object that is rejected with the given reason.
Promise.reject(reason);
Promise rejected.A Promise that is rejected with the given reason.
The static Promise.reject function returns a Promise that is rejected. For debugging purposes and selective error catching, it is useful to make reason an instanceof Error.
Promise.reject(new Error('fail')).then(function() {\n // not called\n}, function(error) {\n console.log(error); // Stacktrace\n}); | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Promise.reject' in that specification. | Standard | Initial definition in an ECMA standard. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Promise.reject' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n32 | \nYes | \n29 | \nNo | \n19 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n4.4.3 | \n32 | \nYes | \n29 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject\n
The handler.getPrototypeOf() method is a trap for the [[GetPrototypeOf]] internal method.
var p = new Proxy(obj, {\n getPrototypeOf(target) {\n ...\n }\n});\n The following parameter is passed to the getPrototypeOf method. this is bound to the handler.
targetThe getPrototypeOf method must return an object or null.
This trap can intercept these operations:
Object.getPrototypeOf()Reflect.getPrototypeOf()__proto__Object.prototype.isPrototypeOf()instanceofIf the following invariants are violated, the proxy will throw a TypeError:
getPrototypeOf method must return an object or null.target is not extensible, Object.getPrototypeOf(proxy) method must return the same value as Object.getPrototypeOf(target).var obj = {};\nvar proto = {};\nvar handler = {\n getPrototypeOf(target) {\n console.log(target === obj); // true\n console.log(this === handler); // true\n return proto;\n }\n};\n\nvar p = new Proxy(obj, handler);\nconsole.log(Object.getPrototypeOf(p) === proto); // true\n var obj = {};\nvar p = new Proxy(obj, {\n getPrototypeOf(target) {\n return Array.prototype;\n }\n});\nconsole.log(\n Object.getPrototypeOf(p) === Array.prototype, // true\n Reflect.getPrototypeOf(p) === Array.prototype, // true\n p.__proto__ === Array.prototype, // true\n Array.prototype.isPrototypeOf(p), // true\n p instanceof Array // true\n);\n var obj = {};\nvar p = new Proxy(obj, {\n getPrototypeOf(target) {\n return 'foo';\n }\n});\nObject.getPrototypeOf(p); // TypeError: \"foo\" is not an object or null\n\nvar obj = Object.preventExtensions({});\nvar p = new Proxy(obj, {\n getPrototypeOf(target) {\n return {};\n }\n});\nObject.getPrototypeOf(p); // TypeError: expected same prototype value\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[GetPrototypeOf]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[GetPrototypeOf]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nNo | \nNo | \n49 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nNo | \nNo | \n49 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getPrototypeOf\n
The handler.isExtensible() method is a trap for Object.isExtensible().
var p = new Proxy(target, {\n isExtensible: function(target) {\n }\n});\n The following parameter is passed to the isExtensible method. this is bound to the handler.
targetThe isExtensible method must return a boolean value.
The handler.isExtensible() method is a trap for Object.isExtensible().
This trap can intercept these operations:
If the following invariants are violated, the proxy will throw a TypeError:
Object.isExtensible(proxy) must return the same value as Object.isExtensible(target).The following code traps Object.isExtensible().
var p = new Proxy({}, {\n isExtensible: function(target) {\n console.log('called');\n return true;\n }\n});\n\nconsole.log(Object.isExtensible(p)); // \"called\"\n // true\n The following code violates the invariant.
var p = new Proxy({}, {\n isExtensible: function(target) {\n return false;\n }\n});\n\nObject.isExtensible(p); // TypeError is thrown\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[IsExtensible]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[IsExtensible]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n? | \n? | \n31 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n31 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/isExtensible\n
The handler.ownKeys() method is a trap for Reflect.ownKeys().
var p = new Proxy(target, {\n ownKeys: function(target) {\n }\n});\n The following parameter is passed to the ownKeys method. this is bound to the handler.
targetThe ownKeys method must return an enumerable object.
The handler.ownKeys() method is a trap for Reflect.ownKeys().
This trap can intercept these operations:
If the following invariants are violated, the proxy will throw a TypeError:
ownKeys must be an array.String or a Symbol.The following code traps Object.getOwnPropertyNames().
var p = new Proxy({}, {\n ownKeys: function(target) {\n console.log('called');\n return ['a', 'b', 'c'];\n }\n});\n\nconsole.log(Object.getOwnPropertyNames(p)); // \"called\"\n // [ 'a', 'b', 'c' ] The following code violates an invariant.
var obj = {};\nObject.defineProperty(obj, 'a', { \n configurable: false, \n enumerable: true, \n value: 10 }\n);\n\nvar p = new Proxy(obj, {\n ownKeys: function(target) {\n return [123, 12.5, true, false, undefined, null, {}, []];\n }\n});\n\nconsole.log(Object.getOwnPropertyNames(p)); \n\n// TypeError: proxy [[OwnPropertyKeys]] must return an array \n// with only string and symbol elements\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[OwnPropertyKeys]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[OwnPropertyKeys]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n 18\n
| \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n 18\n
| \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/ownKeys\n
The handler.preventExtensions() method is a trap for Object.preventExtensions().
var p = new Proxy(target, {\n preventExtensions: function(target) {\n }\n});\n The following parameter is passed to the preventExtensions method. this is bound to the handler.
targetThe preventExtensions method must return a boolean value.
The handler.preventExtensions() method is a trap for Object.preventExtensions().
This trap can intercept these operations:
If the following invariants are violated, the proxy will throw a TypeError:
Object.preventExtensions(proxy) only returns true if Object.isExtensible(proxy) is false.The following code traps Object.preventExtensions().
var p = new Proxy({}, {\n preventExtensions: function(target) {\n console.log('called');\n Object.preventExtensions(target);\n return true;\n }\n});\n\nconsole.log(Object.preventExtensions(p)); // \"called\"\n // false\n The following code violates the invariant.
var p = new Proxy({}, {\n preventExtensions: function(target) {\n return true;\n }\n});\n\nObject.preventExtensions(p); // TypeError is thrown\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[PreventExtensions]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[PreventExtensions]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n22 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n22 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/preventExtensions\n
The handler.set() method is a trap for setting a property value.
var p = new Proxy(target, {\n set: function(target, property, value, receiver) {\n }\n});\n The following parameters are passed to the set method. this is bound to the handler.
targetpropertySymbol of the property to set. valuereceiverset handler can also be called indirectly, via the prototype chain or various other ways.obj.name = \"jen\", and obj is not a proxy, and has no own property .name, but it has a proxy on its prototype chain. That proxy's set handler will be called, and obj will be passed as the receiver.The set method should return a boolean value. Return true to indicate that assignment succeeded. If the set method returns false, and the assignment happened in strict-mode code, a TypeError will be thrown.
The handler.set method is a trap for setting property value.
This trap can intercept these operations:
proxy[foo] = bar and proxy.foo = bar\nObject.create(proxy)[foo] = bar\nReflect.set()If the following invariants are violated, the proxy will throw a TypeError:
undefined as its [[Set]] attribute.false return value from the set handler will throw a TypeError exception.The following code traps setting a property value.
var p = new Proxy({}, {\n set: function(target, prop, value, receiver) {\n target[prop] = value;\n console.log('property set: ' + prop + ' = ' + value);\n return true;\n }\n})\n\nconsole.log('a' in p); // false\n\np.a = 10; // \"property set: a = 10\"\nconsole.log('a' in p); // true\nconsole.log(p.a); // 10\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[Set]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[Set]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set\n
The handler.has() method is a trap for the in operator.
var p = new Proxy(target, {\n has: function(target, prop) {\n }\n});\n The following parameters are passed to has method. this is bound to the handler.
targetpropSymbol of the property to check for existence.The has method must return a boolean value.
The handler.has method is a trap for the in operator.
This trap can intercept these operations:
foo in proxy\nfoo in Object.create(proxy)\nwith check: with(proxy) { (foo); }\nReflect.has()If the following invariants are violated, the proxy will throw a TypeError:
The following code traps the in operator.
var p = new Proxy({}, {\n has: function(target, prop) {\n console.log('called: ' + prop);\n return true;\n }\n});\n\nconsole.log('a' in p); // \"called: a\"\n // true\n The following code violates an invariant.
var obj = { a: 10 };\nObject.preventExtensions(obj);\nvar p = new Proxy(obj, {\n has: function(target, prop) {\n return false;\n }\n});\n\n'a' in p; // TypeError is thrown\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[HasProperty]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[HasProperty]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
Proxyhandlerin operatorReflect.has()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/has\n
The handler.setPrototypeOf() method is a trap for Object.setPrototypeOf().
var p = new Proxy(target, {\n setPrototypeOf: function(target, prototype) {\n }\n});\n The following parameters are passed to the setPrototypeOf method. this is bound to the handler.
targetprototypenull.The setPrototypeOf method returns true if the [[Prototype]] was successfully changed, otherwise false.
The handler.setPrototypeOf method is a trap for Object.setPrototypeOf().
This trap can intercept these operations:
If the following invariants are violated, the proxy will throw a TypeError:
target is not extensible, the prototype parameter must be the same value as Object.getPrototypeOf(target).If you want to disallow setting a new prototype for your object, your handler's setPrototypeOf method can either return false, or it can throw an exception.
The former approach means that any operation that performs such mutation, that throws an exception on failure to mutate, will have to create the exception itself. For example, Object.setPrototypeOf() will create and throw a TypeError itself. If the mutation is performed by an operation that doesn't ordinarily throw in case of failure, such as Reflect.setPrototypeOf(), no exception will be thrown.
var handlerReturnsFalse = {\n setPrototypeOf(target, newProto) {\n return false;\n }\n};\n\nvar newProto = {}, target = {};\n\nvar p1 = new Proxy(target, handlerReturnsFalse);\nObject.setPrototypeOf(p1, newProto); // throws a TypeError\nReflect.setPrototypeOf(p1, newProto); // returns false\n The latter approach will cause any operation that attempts to mutate, to throw. This approach is required if you want even non-throwing operations to throw on failure, or you want to throw a custom exception value.
var handlerThrows = {\n setPrototypeOf(target, newProto) {\n throw new Error('custom error');\n }\n}; \n\nvar newProto = {}, target = {};\n\nvar p2 = new Proxy(target, handlerThrows);\nObject.setPrototypeOf(p2, newProto); // throws new Error(\"custom error\")\nReflect.setPrototypeOf(p2, newProto); // throws new Error(\"custom error\") | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of '[[SetPrototypeOf]]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of '[[SetPrototypeOf]]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n? | \n? | \n49 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n49 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/setPrototypeOf\n
The Object.getOwnPropertySymbols() method returns an array of all symbol properties found directly upon a given object.
Object.getOwnPropertySymbols(obj)
objAn array of all symbol properties found directly upon the given object.
Similar to Object.getOwnPropertyNames(), you can get all symbol properties of a given object as an array of symbols. Note that Object.getOwnPropertyNames() itself does not contain the symbol properties of an object and only the string properties.
As all objects have no own symbol properties initially, Object.getOwnPropertySymbols() returns an empty array unless you have set symbol properties on your object.
var obj = {};\nvar a = Symbol('a');\nvar b = Symbol.for('b');\n\nobj[a] = 'localSymbol';\nobj[b] = 'globalSymbol';\n\nvar objectSymbols = Object.getOwnPropertySymbols(obj);\n\nconsole.log(objectSymbols.length); // 2\nconsole.log(objectSymbols); // [Symbol(a), Symbol(b)]\nconsole.log(objectSymbols[0]); // Symbol(a)\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.getOwnPropertySymbols' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.getOwnPropertySymbols' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n36 | \nNo | \n25 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \nYes | \n36 | \n25 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols\n
The static Reflect.apply() method calls a target function with arguments as specified.
Reflect.apply(target, thisArgument, argumentsList)\n
this provided for the call to target.target should be called.The result of calling the given target function with the specified this value and arguments.
A TypeError, if the target is not callable.
In ES5, you typically use the Function.prototype.apply() method to call a function with a given this value and arguments provided as an array (or an array-like object).
Function.prototype.apply.call(Math.floor, undefined, [1.75]);
With Reflect.apply this becomes less verbose and easier to understand.
Reflect.apply()\nReflect.apply(Math.floor, undefined, [1.75]); \n// 1;\n\nReflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);\n// \"hello\"\n\nReflect.apply(RegExp.prototype.exec, /ab/, ['confabulation']).index;\n// 4\n\nReflect.apply(''.charAt, 'ponies', [3]);\n// \"i\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.apply' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.apply' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/apply\n
The static Reflect.deleteProperty() method allows to delete properties. It is like the delete operator as a function.
Reflect.deleteProperty(target, propertyKey)\n
targetpropertyKeyA Boolean indicating whether or not the property was successfully deleted.
A TypeError, if target is not an Object.
The Reflect.deleteProperty method allows you to delete a property on an object. It returns a Boolean indicating whether or not the property was successfully deleted. It is almost identical to the non-strict delete operator.
Reflect.deleteProperty()\nvar obj = { x: 1, y: 2 };\nReflect.deleteProperty(obj, 'x'); // true\nobj; // { y: 2 }\n\nvar arr = [1, 2, 3, 4, 5];\nReflect.deleteProperty(arr, '3'); // true\narr; // [1, 2, 3, , 5]\n\n// Returns true if no such property exists\nReflect.deleteProperty({}, 'foo'); // true\n\n// Returns false if a property is unconfigurable\nReflect.deleteProperty(Object.freeze({foo: 1}), 'foo'); // false\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.deleteProperty' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.deleteProperty' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/deleteProperty\n
The Object.getOwnPropertyNames() method returns an array of all properties (including non-enumerable properties except for those which use Symbol) found directly upon a given object.
Object.getOwnPropertyNames(obj)
objAn array of strings that correspond to the properties found directly upon the given object.
Object.getOwnPropertyNames() returns an array whose elements are strings corresponding to the enumerable and non-enumerable properties found directly upon obj. The ordering of the enumerable properties in the array is consistent with the ordering exposed by a for...in loop (or by Object.keys()) over the properties of the object. The ordering of the non-enumerable properties in the array, and among the enumerable properties, is not defined.
Object.getOwnPropertyNames()\nvar arr = ['a', 'b', 'c'];\nconsole.log(Object.getOwnPropertyNames(arr).sort()); \n// logs [\"0\", \"1\", \"2\", \"length\"]\n\n// Array-like object\nvar obj = { 0: 'a', 1: 'b', 2: 'c' };\nconsole.log(Object.getOwnPropertyNames(obj).sort()); \n// logs [\"0\", \"1\", \"2\"]\n\n// Logging property names and values using Array.forEach\nObject.getOwnPropertyNames(obj).forEach(\n function (val, idx, array) {\n console.log(val + ' -> ' + obj[val]);\n }\n);\n// logs\n// 0 -> a\n// 1 -> b\n// 2 -> c\n\n// non-enumerable property\nvar my_obj = Object.create({}, {\n getFoo: {\n value: function() { return this.foo; },\n enumerable: false\n }\n});\nmy_obj.foo = 1;\n\nconsole.log(Object.getOwnPropertyNames(my_obj).sort()); \n// logs [\"foo\", \"getFoo\"]\n If you want only the enumerable properties, see Object.keys() or use a for...in loop (although note that this will return enumerable properties not only found directly upon that object but also along the prototype chain for the object unless the latter is filtered with hasOwnProperty()).
Items on the prototype chain are not listed:
function ParentClass() {}\nParentClass.prototype.inheritedMethod = function() {};\n\nfunction ChildClass() {\n this.prop = 5;\n this.method = function() {};\n}\nChildClass.prototype = new ParentClass;\nChildClass.prototype.prototypeMethod = function() {};\n\nconsole.log(\n Object.getOwnPropertyNames(\n new ChildClass() // [\"prop\", \"method\"]\n )\n);\n This uses the Array.prototype.filter() function to remove the enumerable keys (obtained with Object.keys()) from a list of all keys (obtained with Object.getOwnPropertyNames()) leaving only the non-enumerable keys.
var target = myObject;\nvar enum_and_nonenum = Object.getOwnPropertyNames(target);\nvar enum_only = Object.keys(target);\nvar nonenum_only = enum_and_nonenum.filter(function(key) {\n var indexInEnum = enum_only.indexOf(key);\n if (indexInEnum == -1) {\n // Not found in enum_only keys,\n // meaning that the key is non-enumerable,\n // so return true so we keep this in the filter\n return true;\n } else {\n return false;\n }\n});\n\nconsole.log(nonenum_only);\n In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. In ES2015, a non-object argument will be coerced to an object.
Object.getOwnPropertyNames('foo');\n// TypeError: \"foo\" is not an object (ES5 code)\n\nObject.getOwnPropertyNames('foo');\n// [\"0\", \"1\", \"2\", \"length\"] (ES2015 code)\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.getOwnPropertyNames' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.getOwnPropertyNames' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.getOwnPropertyNames' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n5 | \nYes | \n4 | \n9 | \n12 | \n5 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Prior to Firefox 28, Object.getOwnPropertyNames did not see unresolved properties of Error objects. This has been fixed in later versions (bug 724768).
Object.prototype.hasOwnProperty()Object.prototype.propertyIsEnumerable()Object.create()Object.keys()Array.forEach()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames\n
The static Reflect.defineProperty() method is like Object.defineProperty() but returns a Boolean.
Reflect.defineProperty(target, propertyKey, attributes)\n
targetpropertyKeyattributesA Boolean indicating whether or not the property was successfully defined.
A TypeError, if target is not an Object.
The Reflect.defineProperty method allows precise addition to or modification of a property on an object. For more details see the Object.defineProperty which is similar. Object.defineProperty returns the object or throws a TypeError if the property has not been successfully defined. Reflect.defineProperty, however, simply returns a Boolean indicating whether or not the property was successfully defined.
Reflect.defineProperty()\nvar obj = {};\nReflect.defineProperty(obj, 'x', {value: 7}); // true\nobj.x; // 7\n With Object.defineProperty, which returns an object if successful, or throws a TypeError otherwise, you would use a try...catch block to catch any error that occurred while defining a property. Because Reflect.defineProperty returns a Boolean success status, you can just use an if...else block here:
if (Reflect.defineProperty(target, property, attributes)) {\n // success\n} else {\n // failure\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.defineProperty' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.defineProperty' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/defineProperty\n
The static Reflect.getPrototypeOf() method is almost the same method as Object.getPrototypeOf(). It returns the prototype (i.e. the value of the internal [[Prototype]] property) of the specified object.
Reflect.getPrototypeOf(target)\n
targetThe prototype of the given object. If there are no inherited properties, null is returned.
A TypeError, if target is not an Object.
The Reflect.getPrototypeOf method returns the prototype (i.e. the value of the internal [[Prototype]] property) of the specified object.
Reflect.getPrototypeOf()\nReflect.getPrototypeOf({}); // Object.prototype\nReflect.getPrototypeOf(Object.prototype); // null\nReflect.getPrototypeOf(Object.create(null)); // null\n Object.getPrototypeOf()\n// Same result for Objects\nObject.getPrototypeOf({}); // Object.prototype\nReflect.getPrototypeOf({}); // Object.prototype\n\n// Both throw in ES5 for non-Objects\nObject.getPrototypeOf('foo'); // Throws TypeError\nReflect.getPrototypeOf('foo'); // Throws TypeError\n\n// In ES2015 only Reflect throws, Object coerces non-Objects\nObject.getPrototypeOf('foo'); // String.prototype\nReflect.getPrototypeOf('foo'); // Throws TypeError\n\n// To mimic the Object ES2015 behavior you need to coerce\nReflect.getPrototypeOf(Object('foo')); // String.prototype\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.getPrototypeOf' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.getPrototypeOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getPrototypeOf\n
The static Reflect.has() method works like the in operator as a function.
Reflect.has(target, propertyKey)\n
targetpropertyKeyA Boolean indicating whether or not the target has the property.
A TypeError, if target is not an Object.
The Reflect.has method allows you to check if a property is in an object. It works like the in operator as a function.
Reflect.has()\nReflect.has({x: 0}, 'x'); // true\nReflect.has({x: 0}, 'y'); // false\n\n// returns true for properties in the prototype chain \nReflect.has({x: 0}, 'toString');\n\n// Proxy with .has() handler method\nobj = new Proxy({}, {\n has(t, k) { return k.startsWith('door'); }\n});\nReflect.has(obj, 'doorbell'); // true\nReflect.has(obj, 'dormitory'); // false\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.has' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.has' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/has\n
The static Reflect.isExtensible() method determines if an object is extensible (whether it can have new properties added to it). It is similar to Object.isExtensible(), but with some differences.
Reflect.isExtensible(target)\n
targetA Boolean indicating whether or not the target is extensible.
A TypeError, if target is not an Object.
The Reflect.isExtensible method allows you determine if an object is extensible (whether it can have new properties added to it). It is the same method as Object.isExtensible().
Reflect.isExtensible()\nSee also Object.isExtensible().
// New objects are extensible. \nvar empty = {};\nReflect.isExtensible(empty); // === true \n\n// ...but that can be changed. \nReflect.preventExtensions(empty); \nReflect.isExtensible(empty); // === false \n\n// Sealed objects are by definition non-extensible. \nvar sealed = Object.seal({}); \nReflect.isExtensible(sealed); // === false \n\n// Frozen objects are also by definition non-extensible. \nvar frozen = Object.freeze({}); \nReflect.isExtensible(frozen); // === false\n Object.isExtensible()\nIf the first argument to this method is not an object (a primitive), then it will cause a TypeError. With Object.isExtensible(), a non-object first argument will be coerced to an object at first.
Reflect.isExtensible(1);\n// TypeError: 1 is not an object\n\nObject.isExtensible(1);\n// false\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.isExtensible' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.isExtensible' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/isExtensible\n
The static Reflect.preventExtensions() method prevents new properties from ever being added to an object (i.e. prevents future extensions to the object). It is similar to Object.preventExtensions(), but with some differences.
Reflect.preventExtensions(target)\n
targetA Boolean indicating whether or not the target was successfully set to prevent extensions.
A TypeError, if target is not an Object.
The Reflect.preventExtensions method allows you to prevent new properties from ever being added to an object (i.e. prevents future extensions to the object). It is the same method as Object.preventExtensions().
Reflect.preventExtensions()\nSee also Object.preventExtensions().
// Objects are extensible by default.\nvar empty = {};\nReflect.isExtensible(empty); // === true\n\n// ...but that can be changed.\nReflect.preventExtensions(empty);\nReflect.isExtensible(empty); // === false\n Object.preventExtensions()\nIf the first argument to this method is not an object (a primitive), then it will cause a TypeError. With Object.preventExtensions(), a non-object first argument will be coerced to an object at first.
Reflect.preventExtensions(1);\n// TypeError: 1 is not an object\n\nObject.preventExtensions(1);\n// 1\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.preventExtensions' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.preventExtensions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/preventExtensions\n
The proxy's handler object is a placeholder object which contains traps for proxies.
All traps are optional. If a trap has not been defined, the default behavior is to forward the operation to the target.
handler.getPrototypeOf()Object.getPrototypeOf.handler.setPrototypeOf()Object.setPrototypeOf.handler.isExtensible()Object.isExtensible.handler.preventExtensions()Object.preventExtensions.handler.getOwnPropertyDescriptor()Object.getOwnPropertyDescriptor.handler.defineProperty()Object.defineProperty.handler.has()in operator.handler.get()handler.set()handler.deleteProperty()delete operator.handler.ownKeys()Object.getOwnPropertyNames and Object.getOwnPropertySymbols.handler.apply()handler.construct()new operator.Some non-standard traps are obsolete and have been removed.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Proxy Object Internal Methods and Internal Slots' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Proxy Object Internal Methods and Internal Slots' in that specification. | Draft | The enumerate handler has been removed. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
apply | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
construct | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
defineProperty | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
deleteProperty | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
\nenumerate \n | \nNo | \nNo | \n37 — 47 | \nNo | \nNo | \nNo | \n
get | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
getOwnPropertyDescriptor | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
getPrototypeOf | \nNo | \nNo | \n49 | \nNo | \nNo | \nNo | \n
has | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
isExtensible | \n? | \n? | \n31 | \nNo | \n? | \n? | \n
ownKeys | \n49 | \n12 | \n 18\n
| \nNo | \n36 | \n10 | \n
preventExtensions | \n49 | \n12 | \n22 | \nNo | \n36 | \n10 | \n
set | \n49 | \n12 | \n18 | \nNo | \n36 | \n10 | \n
setPrototypeOf | \n? | \n? | \n49 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
apply | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
construct | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
defineProperty | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
deleteProperty | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
\nenumerate \n | \nNo | \nNo | \nNo | \n37 — 47 | \nNo | \nNo | \nNo | \n
get | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
getOwnPropertyDescriptor | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
getPrototypeOf | \nNo | \nNo | \nNo | \n49 | \nNo | \nNo | \nNo | \n
has | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
isExtensible | \n? | \n? | \n? | \n31 | \n? | \n? | \n? | \n
ownKeys | \n49 | \n49 | \nYes | \n 18\n
| \n36 | \n10 | \n5.0 | \n
preventExtensions | \n49 | \n49 | \nYes | \n22 | \n36 | \n10 | \n5.0 | \n
set | \n49 | \n49 | \nYes | \n18 | \n36 | \n10 | \n5.0 | \n
setPrototypeOf | \n? | \n? | \n? | \n49 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
apply | \n6.0.0 | \n
construct | \n6.0.0 | \n
defineProperty | \n6.0.0 | \n
deleteProperty | \n6.0.0 | \n
\nenumerate \n | \nNo | \n
get | \n6.0.0 | \n
getOwnPropertyDescriptor | \n6.0.0 | \n
getPrototypeOf | \n6.0.0 | \n
has | \n6.0.0 | \n
isExtensible | \n6.0.0 | \n
ownKeys | \n6.0.0 | \n
preventExtensions | \n6.0.0 | \n
set | \n6.0.0 | \n
setPrototypeOf | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler\n
The Object.preventExtensions() method prevents new properties from ever being added to an object (i.e. prevents future extensions to the object).
Object.preventExtensions(obj)
objThe object being made non-extensible.
An object is extensible if new properties can be added to it. Object.preventExtensions() marks an object as no longer extensible, so that it will never have properties beyond the ones it had at the time it was marked as non-extensible. Note that the properties of a non-extensible object, in general, may still be deleted. Attempting to add new properties to a non-extensible object will fail, either silently or by throwing a TypeError (most commonly, but not exclusively, when in strict mode).
Object.preventExtensions() only prevents addition of own properties. Properties can still be added to the object prototype.
This method makes the [[prototype]] of the target immutable; any [[prototype]] re-assignment will throw a TypeError. This behavior is specific to the internal [[prototype]] property, other properties of the target object will remain mutable.
There is no way to make an object extensible again once it has been made non-extensible.
// Object.preventExtensions returns the object\n// being made non-extensible.\nvar obj = {};\nvar obj2 = Object.preventExtensions(obj);\nobj === obj2; // true\n\n// Objects are extensible by default.\nvar empty = {};\nObject.isExtensible(empty); // === true\n\n// ...but that can be changed.\nObject.preventExtensions(empty);\nObject.isExtensible(empty); // === false\n\n// Object.defineProperty throws when adding\n// a new property to a non-extensible object.\nvar nonExtensible = { removable: true };\nObject.preventExtensions(nonExtensible);\nObject.defineProperty(nonExtensible, 'new', {\n value: 8675309\n}); // throws a TypeError\n\n// In strict mode, attempting to add new properties\n// to a non-extensible object throws a TypeError.\nfunction fail() {\n 'use strict';\n // throws a TypeError\n nonExtensible.newProperty = 'FAIL';\n}\nfail();\n A non-extensible object's prototype is immutable:
var fixed = Object.preventExtensions({}); \n// throws a 'TypeError'.\nfixed.__proto__ = { oh: 'hai' }; In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. In ES2015, a non-object argument will be treated as if it was a non-extensible ordinary object, simply return it.
Object.preventExtensions(1);\n// TypeError: 1 is not an object (ES5 code)\n\nObject.preventExtensions(1);\n// 1 (ES2015 code)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.preventExtensions' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.preventExtensions' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.preventExtensions' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
| ES2015 behavior for non-object argument | \n44 | \n? | \n35 | \n11 | \n31 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| ES2015 behavior for non-object argument | \nYes | \nYes | \n? | \n35 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| ES2015 behavior for non-object argument | \nYes | \n
Object.isExtensible()Object.seal()Object.isSealed()Object.freeze()Object.isFrozen()Reflect.preventExtensions()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/preventExtensions\n
The Object.getPrototypeOf() method returns the prototype (i.e. the value of the internal [[Prototype]] property) of the specified object.
Object.getPrototypeOf(obj)
The prototype of the given object. If there are no inherited properties, null is returned.
var proto = {};\nvar obj = Object.create(proto);\nObject.getPrototypeOf(obj) === proto; // true\n In ES5, it will throw a TypeError exception if the obj parameter isn't an object. In ES2015, the parameter will be coerced to an Object.
Object.getPrototypeOf('foo');\n// TypeError: \"foo\" is not an object (ES5 code)\nObject.getPrototypeOf('foo');\n// String.prototype (ES2015 code)\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.getPrototypeOf' in that specification. | Standard | Initial definition. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.getPrototypeOf' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.getPrototypeOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n5 | \nYes | \n3.5 | \n9 | \n12.1 | \n5 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Even though older Opera versions don't support Object.getPrototypeOf() yet, Opera supports the non-standard __proto__ property since Opera 10.50.
Object.prototype.isPrototypeOf()Object.setPrototypeOf()Object.prototype.__proto__Reflect.getPrototypeOf()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf\n
The Object.isExtensible() method determines if an object is extensible (whether it can have new properties added to it).
Object.isExtensible(obj)
objA Boolean indicating whether or not the given object is extensible.
Objects are extensible by default: they can have new properties added to them, and (in engines that support __proto__ their __proto__ property) can be modified. An object can be marked as non-extensible using Object.preventExtensions(), Object.seal(), or Object.freeze().
// New objects are extensible.\nvar empty = {};\nObject.isExtensible(empty); // === true\n\n// ...but that can be changed.\nObject.preventExtensions(empty);\nObject.isExtensible(empty); // === false\n\n// Sealed objects are by definition non-extensible.\nvar sealed = Object.seal({});\nObject.isExtensible(sealed); // === false\n\n// Frozen objects are also by definition non-extensible.\nvar frozen = Object.freeze({});\nObject.isExtensible(frozen); // === false\n In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. In ES2015, a non-object argument will be treated as if it was a non-extensible ordinary object, simply return false.
Object.isExtensible(1);\n// TypeError: 1 is not an object (ES5 code)\n\nObject.isExtensible(1);\n// false (ES2015 code)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.isExtensible' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.isExtensible' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.isExtensible' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Object.preventExtensions()Object.seal()Object.isSealed()Object.freeze()Object.isFrozen()Reflect.isExtensible()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible\n
The Object.getOwnPropertyDescriptor() method returns a property descriptor for an own property (that is, one directly present on an object and not in the object's prototype chain) of a given object.
Object.getOwnPropertyDescriptor(obj, prop)
objpropSymbol of the property whose description is to be retrieved.A property descriptor of the given property if it exists on the object, undefined otherwise.
This method permits examination of the precise description of a property. A property in JavaScript consists of either a string-valued name or a Symbol and a property descriptor. Further information about property descriptor types and their attributes can be found in Object.defineProperty().
A property descriptor is a record with some of the following attributes:
valuewritabletrue if and only if the value associated with the property may be changed (data descriptors only).getundefined if there is no getter (accessor descriptors only).setundefined if there is no setter (accessor descriptors only).configurabletrue if and only if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.enumerabletrue if and only if this property shows up during enumeration of the properties on the corresponding object.var o, d;\n\no = { get foo() { return 17; } };\nd = Object.getOwnPropertyDescriptor(o, 'foo');\n// d is {\n// configurable: true,\n// enumerable: true,\n// get: /*the getter function*/,\n// set: undefined\n// }\n\no = { bar: 42 };\nd = Object.getOwnPropertyDescriptor(o, 'bar');\n// d is {\n// configurable: true,\n// enumerable: true,\n// value: 42,\n// writable: true\n// }\n\no = { [Symbol.for('baz')]: 73 }\nd = Object.getOwnPropertyDescriptor(o, Symbol.for('baz')); \n// d is {\n// configurable: true,\n// enumerable: true,\n// value: 73,\n// writable: true\n// }\n\no = {};\nObject.defineProperty(o, 'qux', {\n value: 8675309,\n writable: false,\n enumerable: false\n});\nd = Object.getOwnPropertyDescriptor(o, 'qux');\n// d is {\n// value: 8675309,\n// writable: false,\n// enumerable: false,\n// configurable: false\n// }\n In ES5, if the first argument to this method is not an object (a primitive), then it will cause a TypeError. In ES2015, a non-object first argument will be coerced to an object at first.
Object.getOwnPropertyDescriptor('foo', 0);\n// TypeError: \"foo\" is not an object // ES5 code\n\nObject.getOwnPropertyDescriptor('foo', 0);\n// Object returned by ES2015 code: {\n// configurable: false,\n// enumerable: true,\n// value: \"f\",\n// writable: false\n// }\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.getOwnPropertyDescriptor' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.getOwnPropertyDescriptor' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.getOwnPropertyDescriptor' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n5 | \nYes | \n4 | \n8 | \n12 | \n5 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor\n
The static Reflect.construct() method acts like the new operator, but as a function. It is equivalent to calling new target(...args). It gives also the added option to specify a different prototype.
Reflect.construct(target, argumentsList[, newTarget])\n
targetargumentsListtarget should be called.newTarget Optional\nnew.target operator. If newTarget is not present, it is target.A new instance of target (or newTarget, if present), initialized by target as a constructor with the given arguments.
A TypeError, if target or newTarget are not constructors.
Reflect.construct allows you to invoke a constructor with a variable number of arguments (which would also be possible by using the spread operator combined with the new operator).
var obj = new Foo(...args);\nvar obj = Reflect.construct(Foo, args);\n
Reflect.construct() vs Object.create()\nPrior to the introduction of Reflect, objects could be constructed using an arbitrary combination of constructor and prototype by using Object.create().
function OneClass() {\n this.name = 'one';\n}\n\nfunction OtherClass() {\n this.name = 'other';\n}\n\n// Calling this:\nvar obj1 = Reflect.construct(OneClass, args, OtherClass);\n\n// ...has the same result as this:\nvar obj2 = Object.create(OtherClass.prototype);\nOneClass.apply(obj2, args);\n\nconsole.log(obj1.name); // 'one'\nconsole.log(obj2.name); // 'one'\n\nconsole.log(obj1 instanceof OneClass); // false\nconsole.log(obj2 instanceof OneClass); // false\n\nconsole.log(obj1 instanceof OtherClass); // true\nconsole.log(obj2 instanceof OtherClass); // true\n However, while the end result is the same, there is one important difference in the process. When using Object.create() and Function.prototype.apply(), the new.target operator will point to undefined within the function used as the constructor, since the new keyword is not being used to create the object.
When invoking Reflect.construct(), on the other hand, the new.target operator will point to the newTarget parameter if supplied, or target if not.
function OneClass() {\n console.log('OneClass');\n console.log(new.target);\n}\nfunction OtherClass() {\n console.log('OtherClass');\n console.log(new.target);\n}\n\nvar obj1 = Reflect.construct(OneClass, args);\n// Output:\n// OneClass\n// function OneClass { ... }\n\nvar obj2 = Reflect.construct(OneClass, args, OtherClass);\n// Output:\n// OneClass\n// function OtherClass { ... }\n\nvar obj3 = Object.create(OtherClass.prototype);\nOneClass.apply(obj2, args);\n// Output:\n// OneClass\n// undefined Reflect.construct()\nvar d = Reflect.construct(Date, [1776, 6, 4]);\nd instanceof Date; // true\nd.getFullYear(); // 1776\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.construct' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.construct' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/construct\n
The static Reflect.get() method works like getting a property from an object (target[propertyKey]) as a function.
Reflect.get(target, propertyKey[, receiver])\n
targetpropertyKeythis provided for the call to target if a getter is encountered. When used with Proxy, it can be an object that inherits from the target.The value of the property.
A TypeError, if target is not an Object.
The Reflect.get method allows you to get a property on an object. It is like the property accessor syntax as a function.
Reflect.get()\n// Object\nvar obj = { x: 1, y: 2 };\nReflect.get(obj, 'x'); // 1\n\n// Array\nReflect.get(['zero', 'one'], 1); // \"one\"\n\n// Proxy with a get handler\nvar x = {p: 1};\nvar obj = new Proxy(x, {\n get(t, k, r) { return k + 'bar'; }\n});\nReflect.get(obj, 'foo'); // \"foobar\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.get' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.get' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/get\n
The static Reflect.ownKeys() method returns an array of the target object's own property keys.
Reflect.ownKeys(target)\n
targetAn Array of the target object's own property keys.
A TypeError, if target is not an Object.
The Reflect.ownKeys method returns an array of the target object's own property keys. Its return value is equivalent to Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))
Reflect.ownKeys()\nReflect.ownKeys({z: 3, y: 2, x: 1}); // [ \"z\", \"y\", \"x\" ]\nReflect.ownKeys([]); // [\"length\"]\n\nvar sym = Symbol.for('comet');\nvar sym2 = Symbol.for('meteor');\nvar obj = {[sym]: 0, 'str': 0, '773': 0, '0': 0,\n [sym2]: 0, '-1': 0, '8': 0, 'second str': 0};\nReflect.ownKeys(obj);\n// [ \"0\", \"8\", \"773\", \"str\", \"-1\", \"second str\", Symbol(comet), Symbol(meteor) ]\n// Indexes in numeric order, \n// strings in insertion order, \n// symbols in insertion order\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.ownKeys' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.ownKeys' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/ownKeys\n
The static Reflect.getOwnPropertyDescriptor() method is similar to Object.getOwnPropertyDescriptor(). It returns a property descriptor of the given property if it exists on the object, undefined otherwise.
Reflect.getOwnPropertyDescriptor(target, propertyKey)\n
targetpropertyKeyA property descriptor object if the property exists in the given target object; otherwise, undefined.
A TypeError, if target is not an Object.
The Reflect.getOwnPropertyDescriptor method returns a property descriptor of the given property if it exists on the object, undefined otherwise. The only difference to Object.getOwnPropertyDescriptor() is how non-object targets are handled.
Reflect.getOwnPropertyDescriptor()\nReflect.getOwnPropertyDescriptor({x: 'hello'}, 'x');\n// {value: \"hello\", writable: true, enumerable: true, configurable: true}\n\nReflect.getOwnPropertyDescriptor({x: 'hello'}, 'y');\n// undefined\n\nReflect.getOwnPropertyDescriptor([], 'length');\n// {value: 0, writable: true, enumerable: false, configurable: false}\n Object.getOwnPropertyDescriptor()\nIf the first argument to this method is not an object (a primitive), then it will cause a TypeError. With Object.getOwnPropertyDescriptor, a non-object first argument will be coerced to an object at first.
Reflect.getOwnPropertyDescriptor('foo', 0);\n// TypeError: \"foo\" is not non-null object\n\nObject.getOwnPropertyDescriptor('foo', 0);\n// { value: \"f\", writable: false, enumerable: true, configurable: false } | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.getOwnPropertyDescriptor' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.getOwnPropertyDescriptor' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getOwnPropertyDescriptor\n
The static Reflect.setPrototypeOf() method is the same method as Object.setPrototypeOf(). It sets the prototype (i.e., the internal [[Prototype]] property) of a specified object to another object or to null.
Reflect.setPrototypeOf(target, prototype)\n
targetprototypenull).A Boolean indicating whether or not the prototype was successfully set.
A TypeError, if target is not an Object or if prototype is neither an object nor null.
The Reflect.setPrototypeOf method changes the prototype (i.e. the value of the internal [[Prototype]] property) of the specified object.
Reflect.setPrototypeOf()\nReflect.setPrototypeOf({}, Object.prototype); // true\n\n// It can change an object's [[Prototype]] to null.\nReflect.setPrototypeOf({}, null); // true\n\n// Returns false if target is not extensible.\nReflect.setPrototypeOf(Object.freeze({}), null); // false\n\n// Returns false if it cause a prototype chain cycle.\nvar target = {};\nvar proto = Object.create(target);\nReflect.setPrototypeOf(target, proto); // false\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.setPrototypeOf' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.setPrototypeOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/setPrototypeOf\n
The static Reflect.set() method works like setting a property on an object.
Reflect.set(target, propertyKey, value[, receiver])\n
targetpropertyKeythis provided for the call to target if a setter is encountered.A Boolean indicating whether or not setting the property was successful.
A TypeError, if target is not an Object.
The Reflect.set method allows you to set a property on an object. It does property assignment and is like the property accessor syntax as a function.
Reflect.set()\n// Object\nvar obj = {};\nReflect.set(obj, 'prop', 'value'); // true\nobj.prop; // \"value\"\n\n// Array\nvar arr = ['duck', 'duck', 'duck'];\nReflect.set(arr, 2, 'goose'); // true\narr[2]; // \"goose\"\n\n// It can truncate an array.\nReflect.set(arr, 'length', 1); // true\narr; // [\"duck\"];\n\n// With just one argument, propertyKey and value are \"undefined\".\nvar obj = {};\nReflect.set(obj); // true\nReflect.getOwnPropertyDescriptor(obj, 'undefined');\n// { value: undefined, writable: true, enumerable: true, configurable: true }\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Reflect.set' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Reflect.set' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n12 | \n42 | \nNo | \n36 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n42 | \n36 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/set\n
The Number.EPSILON property represents the difference between 1 and the smallest floating point number greater than 1.
You do not have to create a Number object to access this static property (use Number.EPSILON).
Property attributes of Number.EPSILON\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The EPSILON property has a value of approximately 2.2204460492503130808472633361816E-16, or 2-52.
x = 0.2;\ny = 0.3;\nz = 0.1;\nequal = (Math.abs(x - y + z) < Number.EPSILON);\n
if (Number.EPSILON === undefined) {\n Number.EPSILON = Math.pow(2, -52);\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.EPSILON' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.EPSILON' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n25 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Number object it belongs to.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON\n
The Object.defineProperties() method defines new or modifies existing properties directly on an object, returning the object.
Object.defineProperties(obj, props)
objpropsObject.defineProperty() for more details). Descriptors have the following keys:configurabletrue if and only if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.false\nenumerabletrue if and only if this property shows up during enumeration of the properties on the corresponding object.false\nvalueundefined.\nwritabletrue if and only if the value associated with the property may be changed with an assignment operator.false\ngetundefined if there is no getter. The function's return value will be used as the value of the property.undefined.\nsetundefined if there is no setter. The function will receive as its only argument the new value being assigned to the property.undefined.\nThe object that was passed to the function.
Object.defineProperties, in essence, defines all properties corresponding to the enumerable own properties of props on the object obj object.
var obj = {};\nObject.defineProperties(obj, {\n 'property1': {\n value: true,\n writable: true\n },\n 'property2': {\n value: 'Hello',\n writable: false\n }\n // etc. etc.\n});\n Assuming a pristine execution environment with all names and properties referring to their initial values, Object.defineProperties is almost completely equivalent (note the comment in isCallable) to the following reimplementation in JavaScript:
function defineProperties(obj, properties) {\n function convertToDescriptor(desc) {\n function hasProperty(obj, prop) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n }\n\n function isCallable(v) {\n // NB: modify as necessary if other values than functions are callable.\n return typeof v === 'function';\n }\n\n if (typeof desc !== 'object' || desc === null)\n throw new TypeError('bad desc');\n\n var d = {};\n\n if (hasProperty(desc, 'enumerable'))\n d.enumerable = !!desc.enumerable;\n if (hasProperty(desc, 'configurable'))\n d.configurable = !!desc.configurable;\n if (hasProperty(desc, 'value'))\n d.value = desc.value;\n if (hasProperty(desc, 'writable'))\n d.writable = !!desc.writable;\n if (hasProperty(desc, 'get')) {\n var g = desc.get;\n\n if (!isCallable(g) && typeof g !== 'undefined')\n throw new TypeError('bad get');\n d.get = g;\n }\n if (hasProperty(desc, 'set')) {\n var s = desc.set;\n if (!isCallable(s) && typeof s !== 'undefined')\n throw new TypeError('bad set');\n d.set = s;\n }\n\n if (('get' in d || 'set' in d) && ('value' in d || 'writable' in d))\n throw new TypeError('identity-confused descriptor');\n\n return d;\n }\n\n if (typeof obj !== 'object' || obj === null)\n throw new TypeError('bad obj');\n\n properties = Object(properties);\n\n var keys = Object.keys(properties);\n var descs = [];\n\n for (var i = 0; i < keys.length; i++)\n descs.push([keys[i], convertToDescriptor(properties[keys[i]])]);\n\n for (var i = 0; i < descs.length; i++)\n Object.defineProperty(obj, descs[i][0], descs[i][1]);\n\n return obj;\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.defineProperties' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5 |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.defineProperties' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.defineProperties' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n5 | \nYes | \n4 | \n9 | \n11.6 | \n5 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \n11.5 | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties\n
The SyntaxError.prototype property represents the prototype for the SyntaxError constructor.
All SyntaxError instances inherit from SyntaxError.prototype. You can use the prototype to add properties or methods to all instances.
SyntaxError.prototype.constructorSyntaxError.prototype.messageSyntaxError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.SyntaxError.prototype.nameError.SyntaxError.prototype.fileNameError.SyntaxError.prototype.lineNumberError.SyntaxError.prototype.columnNumberError.SyntaxError.prototype.stackError.Although the SyntaxError prototype object does not contain any methods of its own, SyntaxError instances do inherit some methods through the prototype chain.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Draft | Defined as NativeError.prototype. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype\n
The Number.MIN_SAFE_INTEGER constant represents the minimum safe integer in JavaScript (-(253 - 1)).
Property attributes of Number.MIN_SAFE_INTEGER\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The MIN_SAFE_INTEGER constant has a value of -9007199254740991 (-9,007,199,254,740,991 or about -9 quadrillion). The reasoning behind that number is that JavaScript uses double-precision floating-point format numbers as specified in IEEE 754 and can only safely represent numbers between -(253 - 1) and 253 - 1. See Number.isSafeInteger() for more information.
Because MIN_SAFE_INTEGER is a static property of Number, you always use it as Number.MIN_SAFE_INTEGER, rather than as a property of a Number object you created.
Number.MIN_SAFE_INTEGER // -9007199254740991\n-(Math.pow(2, 53) - 1) // -9007199254740991\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.MIN_SAFE_INTEGER' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.MIN_SAFE_INTEGER' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n34 | \nYes | \n31 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n31 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER\n
The Number.MAX_VALUE property represents the maximum numeric value representable in JavaScript.
Property attributes of Number.MAX_VALUE\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The MAX_VALUE property has a value of approximately 1.79E+308, or 21024. Values larger than MAX_VALUE are represented as \"Infinity\".
Because MAX_VALUE is a static property of Number, you always use it as Number.MAX_VALUE, rather than as a property of a Number object you created. Calling it on the object you created(rather than Number itself), will result in undefined value.
MAX_VALUE\nThe following code multiplies two numeric values. If the result is less than or equal to MAX_VALUE, the func1 function is called; otherwise, the func2 function is called.
if (num1 * num2 <= Number.MAX_VALUE) {\n func1();\n} else {\n func2();\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.MAX_VALUE' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.MAX_VALUE' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.MAX_VALUE' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Number.MIN_VALUENumber object it belongs to\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE\n
The URIError.prototype property represents the prototype for the URIError constructor.
All URIError instances inherit from URIError.prototype. You can use the prototype to add properties or methods to all instances.
URIError.prototype.constructorURIError.prototype.messageURIError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.URIError.prototype.nameError.URIError.prototype.fileNameError.URIError.prototype.lineNumberError.URIError.prototype.columnNumberError.URIError.prototype.stackError.Although the URIError prototype object does not contain any methods of its own, URIError instances do inherit some methods through the prototype chain.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Initial definition |
| ECMAScript 5.1 (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Draft | Defined as NativeError.prototype. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError/prototype\n
The Number.MIN_VALUE property represents the smallest positive numeric value representable in JavaScript.
Property attributes of Number.MIN_VALUE\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The MIN_VALUE property is the number closest to 0, not the most negative number, that JavaScript can represent.
MIN_VALUE has a value of approximately 5e-324. Values smaller than MIN_VALUE (\"underflow values\") are converted to 0.
Because MIN_VALUE is a static property of Number, you always use it as Number.MIN_VALUE, rather than as a property of a Number object you created.
MIN_VALUE\nThe following code divides two numeric values. If the result is greater than or equal to MIN_VALUE, the func1 function is called; otherwise, the func2 function is called.
if (num1 / num2 >= Number.MIN_VALUE) {\n func1();\n} else {\n func2();\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.MIN_VALUE' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.MIN_VALUE' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.MIN_VALUE' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE\n
The TypeError.prototype property represents the prototype for the TypeError constructor.
All TypeError instances inherit from TypeError.prototype. You can use the prototype to add properties or methods to all instances.
TypeError.prototype.constructorTypeError.prototype.messageTypeError should provide its own message property, in SpiderMonkey, it inherits Error.prototype.message.TypeError.prototype.nameError.TypeError.prototype.fileNameError.TypeError.prototype.lineNumberError.TypeError.prototype.columnNumberError.TypeError.prototype.stackError.Although the TypeError prototype object does not contain any methods of its own, TypeError instances do inherit some methods through the prototype chain.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Initial definition |
| ECMAScript 5.1 (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'NativeError.prototype' in that specification. | Standard | Defined as NativeError.prototype. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'NativeError.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError/prototype\n
The Number.isInteger() method determines whether the passed value is an integer.
Number.isInteger(value)
valueA Boolean indicating whether or not the given value is an integer.
If the target value is an integer, return true, otherwise return false. If the value is NaN or infinite, return false.
Number.isInteger(0); // true\nNumber.isInteger(1); // true\nNumber.isInteger(-100000); // true\nNumber.isInteger(99999999999999999999999); // true\n\nNumber.isInteger(0.1); // false\nNumber.isInteger(Math.PI); // false\n\nNumber.isInteger(NaN); // false\nNumber.isInteger(Infinity); // false\nNumber.isInteger(-Infinity); // false\nNumber.isInteger('10'); // false\nNumber.isInteger(true); // false\nNumber.isInteger(false); // false\nNumber.isInteger([1]); // false\n Number.isInteger = Number.isInteger || function(value) {\n return typeof value === 'number' && \n isFinite(value) && \n Math.floor(value) === value;\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.isInteger' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.isInteger' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n16 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n16 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Number object it belongs to.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger\n
The Number.isSafeInteger() method determines whether the provided value is a number that is a safe integer.
A safe integer is an integer that
For example, 253 - 1 is a safe integer: it can be exactly represented, and no other integer rounds to it under any IEEE-754 rounding mode. In contrast, 253 is not a safe integer: it can be exactly represented in IEEE-754, but the integer 253 + 1 can't be directly represented in IEEE-754 but instead rounds to 253 under round-to-nearest and round-to-zero rounding. The safe integers consist of all integers from -(253 - 1) inclusive to 253 - 1 inclusive (± 9007199254740991 or ± 9,007,199,254,740,991).
Handling values larger or smaller than ~9 quadrillion with full precision requires using an arbitrary precision arithmetic library. See What Every Programmer Needs to Know about Floating Point Arithmetic for more information on floating point representations of numbers.
Number.isSafeInteger(testValue)\n
testValueA Boolean indicating whether or not the given value is a number that is a safe integer.
Number.isSafeInteger(3); // true\nNumber.isSafeInteger(Math.pow(2, 53)); // false\nNumber.isSafeInteger(Math.pow(2, 53) - 1); // true\nNumber.isSafeInteger(NaN); // false\nNumber.isSafeInteger(Infinity); // false\nNumber.isSafeInteger('3'); // false\nNumber.isSafeInteger(3.1); // false\nNumber.isSafeInteger(3.0); // true\n Number.isSafeInteger = Number.isSafeInteger || function (value) {\n return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.isSafeInteger' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.isSafeInteger' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n32 | \nNo | \nYes | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n32 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Number object it belongs to.Number.MIN_SAFE_INTEGERNumber.MAX_SAFE_INTEGER\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger\n
The Number.parseInt() method parses a string argument and returns an integer of the specified radix or base.
Number.parseInt(string,[ radix ])
stringstring argument is not a string, then it is converted to a string (using the ToString abstract operation). Leading whitespace in the string argument is ignored.radixAn integer number parsed from the given string. If the first character cannot be converted to a number, NaN is returned.
This method has the same functionality as the global parseInt() function:
Number.parseInt === parseInt; // true
and is part of ECMAScript 2015 (its purpose is modularization of globals). Please see parseInt() for more detail and examples.
if (Number.parseInt === undefined) {\n Number.parseInt = window.parseInt;\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.parseInt' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.parseInt' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n25 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Number object it belongs to.parseInt() method.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/parseInt\n
The toString() method returns a string representing the specified Number object.
numObj.toString([radix])
radixA string representing the specified Number object.
RangeErrortoString() is given a radix less than 2 or greater than 36, a RangeError is thrown.The Number object overrides the toString() method of the Object object; it does not inherit Object.prototype.toString(). For Number objects, the toString() method returns a string representation of the object in the specified radix.
The toString() method parses its first argument, and attempts to return a string representation in the specified radix (base). For radixes above 10, the letters of the alphabet indicate numerals greater than 9. For example, for hexadecimal numbers (base 16), a through f are used.
If the radix is not specified, the preferred radix is assumed to be 10.
If the numObj is negative, the sign is preserved. This is the case even if the radix is 2; the string returned is the positive binary representation of the numObj preceded by a - sign, not the two's complement of the numObj.
If the numObj is not a whole number, the 'dot' sign is used to separate the decimal places.
toString\nvar count = 10;\n\nconsole.log(count.toString()); // displays '10'\nconsole.log((17).toString()); // displays '17'\nconsole.log((17.2).toString()); // displays '17.2'\n\nvar x = 6;\n\nconsole.log(x.toString(2)); // displays '110'\nconsole.log((254).toString(16)); // displays 'fe'\n\nconsole.log((-10).toString(2)); // displays '-1010'\nconsole.log((-0xff).toString(2)); // displays '-11111111'\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.prototype.tostring' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.prototype.tostring' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.prototype.tostring' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString\n
The Number.prototype property represents the prototype for the Number constructor.
Property attributes of Number.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All Number instances inherit from Number.prototype. The prototype object of the Number constructor can be modified to affect all Number instances.
Number.prototype.constructorNumber object.Number.prototype.toExponential()Number.prototype.toFixed()Number.prototype.toLocaleString()Object.prototype.toLocaleString() method.Number.prototype.toPrecision()Number.prototype.toSource() \nNumber object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.Number.prototype.toString()Object.prototype.toString() method.Number.prototype.valueOf()Object.prototype.valueOf() method.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/prototype\n
The valueOf() method returns the wrapped primitive value of a Number object.
numObj.valueOf()
A number representing the primitive value of the specified Number object.
This method is usually called internally by JavaScript and not explicitly in web code.
valueOf\nvar numObj = new Number(10);\nconsole.log(typeof numObj); // object\n\nvar num = numObj.valueOf();\nconsole.log(num); // 10\nconsole.log(typeof num); // number\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Number.prototype.valueOf' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.prototype.valueOf' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.prototype.valueOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/valueOf\n
The size accessor property returns the number of elements in a Set object.
The value of size is an integer representing how many entries the Set object has. A set accessor function for size is undefined; you cannot change this property.
size\nvar mySet = new Set();\nmySet.add(1);\nmySet.add(5);\nmySet.add('some text')\n\nmySet.size; // 3\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype.size' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype.size' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n 19\n
| \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n 19\n
| \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/size\n
The Set[@@species] accessor property returns the Set constructor.
Set[Symbol.species]\n
The species accessor property returns the default constructor for Set objects. Subclass constructors may over-ride it to change the constructor assignment.
The species property returns the default constructor function, which is the Set constructor for Set objects:
Set[Symbol.species]; // function Set()
In a derived collection object (e.g. your custom set MySet), the MySet species is the MySet constructor. However, you might want to overwrite this, in order to return parent Set objects in your derived class methods:
class MySet extends Set {\n // Overwrite MySet species to the parent Set constructor\n static get [Symbol.species]() { return Set; }\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'get Set [ @@species ]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'get Set [ @@species ]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n51 | \n13 | \n41 | \nNo | \n38 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n51 | \n51 | \n13 | \n41 | \n38 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.5.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/@@species\n
The clear() method removes all elements from a Set object.
mySet.clear();
clear methodvar mySet = new Set();\nmySet.add(1);\nmySet.add('foo');\n\nmySet.size; // 2\nmySet.has('foo'); // true\n\nmySet.clear();\n\nmySet.size; // 0\nmySet.has('bar') // false\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype.clear' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype.clear' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n19 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n19 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/clear\n
The delete() method removes the specified element from a Set object.
mySet.delete(value);
Set object.true if an element in the Set object has been removed successfully; otherwise false.
delete methodvar mySet = new Set();\nmySet.add('foo');\n\nmySet.delete('bar'); // Returns false. No \"bar\" element found to be deleted.\nmySet.delete('foo'); // Returns true. Successfully removed.\n\nmySet.has('foo'); // Returns false. The \"foo\" element is no longer present.\n Let's checkout below how to delete an Object from a Set.
var setObj = new Set(); // Create a New Set.\n\nsetObj.add({x: 10, y: 20}); // Add object in the set.\n\nsetObj.add({x: 20, y: 30}); // Add object in the set.\n\n// Delete any point with `x > 10`.\nsetObj.forEach(function(point){\n if(point.x > 10){\n setObj.delete(point)\n }\n})\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype.delete' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype.delete' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/delete\n
The Number.parseFloat() method parses a string argument and returns a floating point number. This method behaves identically to the global function parseFloat() and is part of ECMAScript 2015 (its purpose is modularization of globals).
Number.parseFloat(string)
valueA floating point number parsed from the given value. If the value cannot be converted to a number, NaN is returned.
Please see parseFloat() for more details and examples.
if (Number.parseFloat === void 0) {\n Number.parseFloat = parseFloat;\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Number.parseFloat' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Number.parseFloat' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n25 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Number object it belongs to.parseFloat() method.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/parseFloat\n
The Set.prototype property represents the prototype for the Set constructor.
Property attributes of Set.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Set instances inherit from Set.prototype. You can use the constructor's prototype object to add properties or methods to all Set instances.
Set.prototype.constructorSet function by default.Set.prototype.sizeSet object.Set.prototype.add(value)Set object. Returns the Set object.Set.prototype.clear()Set object.Set.prototype.delete(value)value and returns the value that Set.prototype.has(value) would have previously returned. Set.prototype.has(value) will return false afterwards.Set.prototype.entries()Iterator object that contains[value, value] for each element in the Set object, in insertion order. This is kept similar to the Map object, so that each entry has the same value for its key and value here.Set.prototype.forEach(callbackFn[, thisArg])callbackFn once for each value present in the Set object, in insertion order. If a thisArg parameter is provided to forEach, it will be used as the this value for each callback.Set.prototype.has(value)Set object or not.Set.prototype.keys()values() function and returns a new Iterator object that contains the values for each element in the Set object in insertion order.Set.prototype.values()Iterator object that contains the values for each element in the Set object in insertion order.Set.prototype[@@iterator]()Iterator object that contains the values for each element in the Set object in insertion order.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/prototype\n
The add() method appends a new element with a specified value to the end of a Set object.
mySet.add(value);
Set object.The Set object.
add methodvar mySet = new Set();\n\nmySet.add(1);\nmySet.add(5).add('some text'); // chainable\n\nconsole.log(mySet);\n// Set [1, 5, \"some text\"]\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype.add' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype.add' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11\n
| \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/add\n
The entries() method returns a new Iterator object that contains[value, value] for each element in the Set object, in insertion order. For Set objects there is no key like in Map objects. However, to keep the API similar to the Map object, each entry has the same value for its key and value here, so that an array [value, value] is returned.
mySet.entries()
A new Iterator object that contains an array of [value, value] for each element in the given Set, in insertion order.
entries()\nvar mySet = new Set();\nmySet.add('foobar');\nmySet.add(1);\nmySet.add('baz');\n\nvar setIter = mySet.entries();\n\nconsole.log(setIter.next().value); // [\"foobar\", \"foobar\"]\nconsole.log(setIter.next().value); // [1, 1]\nconsole.log(setIter.next().value); // [\"baz\", \"baz\"]\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype.entries' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype.entries' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n24 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n24 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries\n
The forEach() method executes a provided function once for each value in the Set object, in insertion order.
mySet.forEach(function callback(value1, value2, Set) { \n //your iterator\n}[, thisArg]) callbackvalue1, value2SetthisArgthis when executing callback.The forEach() method executes the provided callback once for each value which actually exists in the Set object. It is not invoked for values which have been deleted. However, it is executed for values which are present but have the value undefined.
callback is invoked with three arguments:
Set\nThere are no keys in Set objects. However, the first two arguments are both values contained in the Set, so that the callback function is consistent with the forEach() methods for Map and Array.
If a thisArg parameter is provided to forEach(), it will be passed to callback when invoked, for use as its this value. Otherwise, the value undefined will be passed for use as its this value. The this value ultimately observable by callback is determined according to the usual rules for determining the this seen by a function.
Each value is visited once, except in the case when it was deleted and re-added before forEach() has finished. callback is not invoked for values deleted before being visited. New values added before forEach() has finished will be visited.
forEach() executes the callback function once for each element in the Set object; it does not return a value.
Set objectThe following code logs a line for each element in a Set object:
function logSetElements(value1, value2, set) {\n console.log('s[' + value1 + '] = ' + value2);\n}\n\nnew Set(['foo', 'bar', undefined]).forEach(logSetElements);\n\n// logs:\n// \"s[foo] = foo\"\n// \"s[bar] = bar\"\n// \"s[undefined] = undefined\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype.forEach' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype.forEach' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n25 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n25 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/forEach\n
The has() method returns a boolean indicating whether an element with the specified value exists in a Set object or not.
mySet.has(value);
Set object.Returns true if an element with the specified value exists in the Set object; otherwise false.
Note: Technically speaking, has() uses the sameValueZero algorithm to determine whether the given element is found.
has methodvar mySet = new Set();\nmySet.add('foo');\n\nmySet.has('foo'); // returns true\nmySet.has('bar'); // returns false\n\nvar set1 = new Set();\nvar obj1 = {'key1': 1};\nset1.add(obj1);\n\nset1.has(obj1); // returns true\nset1.has({'key1': 1}); // returns false because they are different object references\nset1.add({'key1': 1}); // now set1 contains 2 entries\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype.has' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype.has' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n13 | \n11 | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n14 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/has\n
The values() method returns a new Iterator object that contains the values for each element in the Set object in insertion order.
The keys() method is an alias for this method (for similarity with Map objects); it behaves exactly the same and returns values of Set elements.
mySet.values();\n
A new Iterator object containing the values for each element in the given Set, in insertion order.
values()\nvar mySet = new Set();\nmySet.add('foo');\nmySet.add('bar');\nmySet.add('baz');\n\nvar setIter = mySet.values();\n\nconsole.log(setIter.next().value); // \"foo\"\nconsole.log(setIter.next().value); // \"bar\"\nconsole.log(setIter.next().value); // \"baz\" | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype.values' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype.values' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n24 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n38 | \n38 | \n12 | \n24 | \n25 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/values\n
The Array.isArray() method determines whether the passed value is an Array.
Array.isArray([1, 2, 3]); // true\nArray.isArray({foo: 123}); // false\nArray.isArray('foobar'); // false\nArray.isArray(undefined); // false\n Array.isArray(value)
valuetrue if the value is an Array; otherwise, false.
If the value is an Array, true is returned; otherwise, false is.
See the article “Determining with absolute accuracy whether or not a JavaScript object is an array” for more details. Given a TypedArray instance, false is always returned.
// all following calls return true\nArray.isArray([]);\nArray.isArray([1]);\nArray.isArray(new Array());\nArray.isArray(new Array('a', 'b', 'c', 'd'));\nArray.isArray(new Array(3));\n// Little known fact: Array.prototype itself is an array:\nArray.isArray(Array.prototype); \n\n// all following calls return false\nArray.isArray();\nArray.isArray({});\nArray.isArray(null);\nArray.isArray(undefined);\nArray.isArray(17);\nArray.isArray('Array');\nArray.isArray(true);\nArray.isArray(false);\nArray.isArray({ __proto__: Array.prototype });\n instanceof vs isArray\nWhen checking for Array instance, Array.isArray is preferred over instanceof because it works through iframes.
var iframe = document.createElement('iframe');\ndocument.body.appendChild(iframe);\nxArray = window.frames[window.frames.length-1].Array;\nvar arr = new xArray(1,2,3); // [1,2,3]\n\n// Correctly checking for Array\nArray.isArray(arr); // true\n// Considered harmful, because doesn't work through iframes\narr instanceof Array; // false\n Running the following code before any other code will create Array.isArray() if it's not natively available.
if (!Array.isArray) {\n Array.isArray = function(arg) {\n return Object.prototype.toString.call(arg) === '[object Array]';\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.isArray' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.isArray' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.isArray' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n5 | \nYes | \n4 | \n9 | \n10.5 | \n5 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray\n
The initial value of the @@iterator property is the same function object as the initial value of the values property.
mySet[Symbol.iterator]
The Set iterator function, which is the values() function by default.
[@@iterator]()\nvar mySet = new Set();\nmySet.add('0');\nmySet.add(1);\nmySet.add({});\n\nvar setIter = mySet[Symbol.iterator]();\n\nconsole.log(setIter.next().value); // \"0\"\nconsole.log(setIter.next().value); // 1\nconsole.log(setIter.next().value); // Object\n [@@iterator]() with for..of\nvar mySet = new Set();\nmySet.add('0');\nmySet.add(1);\nmySet.add({});\n\nfor (var v of mySet) {\n console.log(v);\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Set.prototype[@@iterator]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Set.prototype[@@iterator]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n 36\n
| \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n 36\n
| \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/@@iterator\n
The concat() method is used to merge two or more arrays. This method does not change the existing arrays, but instead returns a new array.
var new_array = old_array.concat([value1[, value2[, ...[, valueN]]]])
valueN Optional\nvalueN is undefined, concat returns a shallow copy of the existing array on which it is called. See the description below for more details.A new Array instance.
The concat method creates a new array consisting of the elements in the object on which it is called, followed in order by, for each argument, the elements of that argument (if the argument is an array) or the argument itself (if the argument is not an array). It does not recurse into nested array arguments.
The concat method does not alter this or any of the arrays provided as arguments but instead returns a shallow copy that contains copies of the same elements combined from the original arrays. Elements of the original arrays are copied into the new array as follows:
concat copies object references into the new array. Both the original and new array refer to the same object. That is, if a referenced object is modified, the changes are visible to both the new and original arrays. This includes elements of array arguments that are also arrays.String, Number, and Boolean objects): concat copies the values of strings and numbers into the new array.Note: Concatenating array(s)/value(s) will leave the originals untouched. Furthermore, any operation on the new array (except operations on elements which are object references) will have no effect on the original arrays, and vice versa.
The following code concatenates two arrays:
var alpha = ['a', 'b', 'c'];\nvar numeric = [1, 2, 3];\n\nalpha.concat(numeric);\n// result in ['a', 'b', 'c', 1, 2, 3]\n
The following code concatenates three arrays:
var num1 = [1, 2, 3],\n num2 = [4, 5, 6],\n num3 = [7, 8, 9];\n\nvar nums = num1.concat(num2, num3);\n\nconsole.log(nums); \n// results in [1, 2, 3, 4, 5, 6, 7, 8, 9]\n
The following code concatenates three values to an array:
var alpha = ['a', 'b', 'c'];\n\nvar alphaNumeric = alpha.concat(1, [2, 3]);\n\nconsole.log(alphaNumeric); \n// results in ['a', 'b', 'c', 1, 2, 3]\n
The following code concatenates nested arrays and demonstrates retention of references:
var num1 = [[1]];\nvar num2 = [2, [3]];\n\nvar nums = num1.concat(num2);\n\nconsole.log(nums);\n// results in [[1], 2, [3]]\n\n// modify the first element of num1\nnum1[0].push(4);\n\nconsole.log(nums);\n// results in [[1, 4], 2, [3]]\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.concat' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.concat' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.concat' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
push / pop — add/remove elements from the end of the arrayunshift / shift — add/remove elements from the beginning of the arraysplice — add/remove elements from the specified location of the arrayString.prototype.concat()Symbol.isConcatSpreadable – control flattening.\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat\n
This is an experimental technology
Check the Browser compatibility table carefully before using this in production.
The flat() method creates a new array with all sub-array elements concatenated into it recursively up to the specified depth.
var newArray = arr.flat([depth]);
depth Optional\nA new array with the sub-array elements concatenated into it.
var arr1 = [1, 2, [3, 4]];\narr1.flat(); \n// [1, 2, 3, 4]\n\nvar arr2 = [1, 2, [3, 4, [5, 6]]];\narr2.flat();\n// [1, 2, 3, 4, [5, 6]]\n\nvar arr3 = [1, 2, [3, 4, [5, 6]]];\narr3.flat(2);\n// [1, 2, 3, 4, 5, 6]\n
The flat method removes empty slots in arrays:
var arr4 = [1, 2, , 4, 5];\narr4.flat();\n// [1, 2, 4, 5]\n
reduce and concat\nvar arr1 = [1, 2, [3, 4]];\narr1.flat();\n\n//to flat single level array\narr1.reduce((acc, val) => acc.concat(val), []);// [1, 2, 3, 4]\n\n//or\nconst flatSingle = arr => [].concat(...arr);\n
//to enable deep level flatten use recursion with reduce and concat\nvar arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];\n\nfunction flattenDeep(arr1) {\n return arr1.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);\n}\nflattenDeep(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]\n //non recursive flatten deep using a stack\nvar arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];\nfunction flatten(input) {\n const stack = [...input];\n const res = [];\n while (stack.length) {\n // pop value from stack\n const next = stack.pop();\n if (Array.isArray(next)) {\n // push back array items, won't modify the original input\n stack.push(...next);\n } else {\n res.push(next);\n }\n }\n //reverse to restore input order\n return res.reverse();\n}\nflatten(arr1);// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]\n | Specification | Status | Comment |
|---|---|---|
Array.prototype.flat proposal | Candidate (3) |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \n69 | \nNo | \n62 | \nNo | \n56 | \n12 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \n69 | \n69 | \nNo | \n62 | \n56 | \n12 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat\n
The length property of an object which is an instance of type Array sets or returns the number of elements in that array. The value is an unsigned, 32-bit integer that is always numerically greater than the highest index in the array.
The value of the length property is an integer with a positive sign and a value less than 2 to the 32nd power (232).
var namelistA = new Array(4294967296); //2 to the 32nd power = 4294967296 \nvar namelistC = new Array(-100) //negative sign\n\nconsole.log(namelistA.length); //RangeError: Invalid array length \nconsole.log(namelistC.length); //RangeError: Invalid array length \n\n\n\nvar namelistB = []; \nnamelistB.length = Math.pow(2,32)-1; //set array length less than 2 to the 32nd power \nconsole.log(namelistB.length); \n\n//4294967295\n
You can set the length property to truncate an array at any time. When you extend an array by changing its length property, the number of actual elements increases; for example, if you set length to 3 when it is currently 2, the array now contains 3 elements, which causes the third element to be undefined.
var arr = [1, 2, 3];\nprintEntries(arr);\n\narr.length = 5; // set array length to 5 while currently 3.\nprintEntries(arr);\n\nfunction printEntries(arr) {\n var length = arr.length;\n for (var i = 0; i < length; i++) {\n console.log(arr[i]);\n }\n console.log('=== printed ===');\n}\n\n// 1\n// 2\n// 3\n// === printed ===\n// 1\n// 2\n// 3\n// undefined\n// undefined\n// === printed === But, the length property does not necessarily indicate the number of defined values in the array. See also Relationship between length and numerical properties.
Property attributes of Array.length\n | |
|---|---|
| Writable | yes |
| Enumerable | no |
| Configurable | no |
Writable: If this attribute set to false, the value of the property cannot be changed.Configurable: If this attribute set to false, any attempts to delete the property or change its attributes (Writable, Configurable, or Enumerable) will fail.Enumerable: If this attribute set to true, the property will be iterated over during for or for..in loops.In the following example, the array numbers is iterated through by looking at the length property. The value in each element is then doubled.
var numbers = [1, 2, 3, 4, 5];\nvar length = numbers.length;\nfor (var i = 0; i < length; i++) {\n numbers[i] *= 2;\n}\n// numbers is now [2, 4, 6, 8, 10]\n The following example shortens the array numbers to a length of 3 if the current length is greater than 3.
var numbers = [1, 2, 3, 4, 5];\n\nif (numbers.length > 3) {\n numbers.length = 3;\n}\n\nconsole.log(numbers); // [1, 2, 3]\nconsole.log(numbers.length); // 3\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.length' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.length' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.length' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length\n
The @@unscopable symbol property contains property names that were not included in the ECMAScript standard prior to the ES2015 version. These properties are excluded from with statement bindings.
arr[Symbol.unscopables]
The default array properties that are excluded from with bindings are: copyWithin, entries, fill, find, findIndex, includes, keys, and values.
See Symbol.unscopables for how to set unscopables for your own objects.
Property attributes of Array.prototype[@@unscopables]\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
The following code works fine in ES5 and below. However, in ECMAScript 2015 and later, the Array.prototype.keys() method was introduced. That means that inside with environments, \"keys\" would now be the method and not the variable. This is where now the built-in @@unscopables Array.prototype[@@unscopables] symbol property comes into play and prevents that some of the Array methods are being scoped into the with statement.
var keys = [];\n\nwith (Array.prototype) {\n keys.push('something');\n}\n\nObject.keys(Array.prototype[Symbol.unscopables]); \n// [\"copyWithin\", \"entries\", \"fill\", \"find\", \"findIndex\", \n// \"includes\", \"keys\", \"values\"] | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype[@@unscopables]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype[@@unscopables]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/@@unscopables\n
The splice() method changes the contents of an array by removing existing elements and/or adding new elements.
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])\n
startdeleteCount Optional\ndeleteCount is omitted, or if its value is larger than array.length - start (that is, if it is greater than the number of elements left in the array, starting at start), then all of the elements from start through the end of the array will be deleted.deleteCount is 0 or negative, no elements are removed. In this case, you should specify at least one new element (see below).item1, item2, ... Optional\nstart index. If you don't specify any elements, splice() will only remove elements from the array.An array containing the deleted elements. If only one element is removed, an array of one element is returned. If no elements are removed, an empty array is returned.
If you specify a different number of elements to insert than the number you're removing, the array will have a different length at the end of the call.
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];\nvar removed = myFish.splice(2, 0, 'drum');\n\n// myFish is [\"angel\", \"clown\", \"drum\", \"mandarin\", \"sturgeon\"] \n// removed is [], no elements removed\n
var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];\nvar removed = myFish.splice(3, 1);\n\n// removed is [\"mandarin\"]\n// myFish is [\"angel\", \"clown\", \"drum\", \"sturgeon\"] \n
var myFish = ['angel', 'clown', 'drum', 'sturgeon'];\nvar removed = myFish.splice(2, 1, 'trumpet');\n\n// myFish is [\"angel\", \"clown\", \"trumpet\", \"sturgeon\"]\n// removed is [\"drum\"]
var myFish = ['angel', 'clown', 'trumpet', 'sturgeon'];\nvar removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');\n\n// myFish is [\"parrot\", \"anemone\", \"blue\", \"trumpet\", \"sturgeon\"] \n// removed is [\"angel\", \"clown\"]
var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon'];\nvar removed = myFish.splice(myFish.length - 3, 2);\n\n// myFish is [\"parrot\", \"anemone\", \"sturgeon\"] \n// removed is [\"blue\", \"trumpet\"]
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];\nvar removed = myFish.splice(-2, 1);\n\n// myFish is [\"angel\", \"clown\", \"sturgeon\"] \n// removed is [\"mandarin\"]
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];\nvar removed = myFish.splice(2);\n\n// myFish is [\"angel\", \"clown\"] \n// removed is [\"mandarin\", \"sturgeon\"]
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.splice' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.splice' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.splice' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
push() / pop() — add/remove elements from the end of the arrayunshift() / shift() — add/remove elements from the beginning of the arrayconcat() — returns a new array comprised of this array joined with other array(s) and/or value(s)\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice\n
This is an experimental technology
Check the Browser compatibility table carefully before using this in production.
The flatMap() method first maps each element using a mapping function, then flattens the result into a new array. It is identical to a map followed by a flat of depth 1, but flatMap is often quite useful, as merging both into one method is slightly more efficient.
var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {\n // return element for new_array\n}[, thisArg]) callbackcurrentValueindexOptional\narrayOptional\nmap was called upon.thisArgOptional\nthis when executing callback.A new array with each element being the result of the callback function and flattened to a depth of 1.
See Array.prototype.map() for a detailed description of the callback function. The flatMap method is identical to a map followed by a call to flat of depth 1.
map and flatMap\nlet arr1 = [1,2, 3, 4];\n\narr1.map(x => [x * 2]); \n// [[2], [4], [6], [8]]\n\narr1.flatMap(x => [x * 2]);\n// [2, 4, 6, 8]\n\n// only one level is flattened\narr1.flatMap(x => [[x * 2]]);\n// [[2], [4], [6], [8]]\n
While the above could have been achieved by using map itself, here is an example showing usecase of flatMap better.
Let's generate a list of words from a list of sentences.
let arr1 = [\"it's Sunny in\", \"\", \"California\"];\n\narr1.map(x => x.split(\" \"));\n// [[\"it's\",\"Sunny\",\"in\"],[\"\"],[\"California\"]]\n\narr1.flatMap(x => x.split(\" \"));\n// [\"it's\",\"Sunny\",\"in\", \"\", \"California\"] Notice, the output list length can be different from the input list length.
reduce and concat\nvar arr1 = [1,2, 3, 4];\n\narr1.flatMap(x => [x * 2]);\n// is equivalent to\narr1.reduce((acc, x) => acc.concat([x * 2]), []);\n// [2, 4, 6, 8]\n
| Specification | Status | Comment |
|---|---|---|
Array.prototype.flatMap proposal | Candidate (3) |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \n69 | \nNo | \n62 | \nNo | \n56 | \n12 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \n69 | \n69 | \nNo | \n62 | \n56 | \n12 | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatMap\n
The pop() method removes the last element from an array and returns that element. This method changes the length of the array.
arr.pop()
The removed element from the array; undefined if the array is empty.
The pop method removes the last element from an array and returns that value to the caller.
pop is intentionally generic; this method can be called or applied to objects resembling arrays. Objects which do not contain a length property reflecting the last in a series of consecutive, zero-based numerical properties may not behave in any meaningful manner.
If you call pop() on an empty array, it returns undefined.
The following code creates the myFish array containing four elements, then removes its last element.
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];\n\nvar popped = myFish.pop();\n\nconsole.log(myFish); // ['angel', 'clown', 'mandarin' ] \n\nconsole.log(popped); // 'sturgeon'
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.pop' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.pop' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.pop' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Array.prototype.push()Array.prototype.shift()Array.prototype.unshift()Array.prototype.concat()Array.prototype.splice()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop\n
The push() method adds one or more elements to the end of an array and returns the new length of the array.
arr.push(element1[, ...[, elementN]])
elementNThe new length property of the object upon which the method was called.
The push method appends values to an array.
push is intentionally generic. This method can be used with call() or apply() on objects resembling arrays. The push method relies on a length property to determine where to start inserting the given values. If the length property cannot be converted into a number, the index used is 0. This includes the possibility of length being nonexistent, in which case length will also be created.
Although strings are native, Array-like objects, they are not suitable in applications of this method, as strings are immutable. Similarly for the native, Array-like object arguments.
The following code creates the sports array containing two elements, then appends two elements to it. The total variable contains the new length of the array.
var sports = ['soccer', 'baseball'];\nvar total = sports.push('football', 'swimming');\n\nconsole.log(sports); // ['soccer', 'baseball', 'football', 'swimming']\nconsole.log(total); // 4\n This example uses apply() to push all elements from a second array.
Do not use this method if the second array (moreVegs in the example) is very large, because the maximum number of parameters that one function can take is limited in practice. See apply() for more details.
var vegetables = ['parsnip', 'potato'];\nvar moreVegs = ['celery', 'beetroot'];\n\n// Merge the second array into the first one\n// Equivalent to vegetables.push('celery', 'beetroot');\nArray.prototype.push.apply(vegetables, moreVegs);\n\nconsole.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']\n As mentioned above, push is intentionally generic, and we can use that to our advantage. Array.prototype.push can work on an object just fine, as this example shows. Note that we don't create an array to store a collection of objects. Instead, we store the collection on the object itself and use call on Array.prototype.push to trick the method into thinking we are dealing with an array, and it just works, thanks to the way JavaScript allows us to establish the execution context however we please.
var obj = {\n length: 0,\n\n addElem: function addElem(elem) {\n // obj.length is automatically incremented \n // every time an element is added.\n [].push.call(this, elem);\n }\n};\n\n// Let's add some empty objects just to illustrate.\nobj.addElem({});\nobj.addElem({});\nconsole.log(obj.length);\n// → 2\n Note that although obj is not an array, the method push successfully incremented obj's length property just like if we were dealing with an actual array.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.push' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.push' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.push' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push\n
The initial value of the @@iterator property is the same function object as the initial value of the values() property.
arr[Symbol.iterator]()
The initial value given by the values() iterator. By default, using arr[Symbol.iterator] will return the values() function.
for...of loopvar arr = ['w', 'y', 'k', 'o', 'p'];\nvar eArr = arr[Symbol.iterator]();\n// your browser must support for..of loop\n// and let-scoped variables in for loops\n// const and var could also be used\nfor (let letter of eArr) {\n console.log(letter);\n}\n var arr = ['w', 'y', 'k', 'o', 'p'];\nvar eArr = arr[Symbol.iterator]();\nconsole.log(eArr.next().value); // w\nconsole.log(eArr.next().value); // y\nconsole.log(eArr.next().value); // k\nconsole.log(eArr.next().value); // o\nconsole.log(eArr.next().value); // p\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype[@@iterator]()' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype[@@iterator]()' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n? | \n 36\n
| \nNo | \n25 | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n? | \n 36\n
| \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Array.prototype.keys()Array.prototype.entries()Array.prototype.forEach()Array.prototype.every()Array.prototype.some()Array.prototype.values()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/@@iterator\n
The exec() method executes a search for a match in a specified string. Returns a result array, or null.
If you are executing a match simply to find true or false, use the RegExp.prototype.test() method or the String.prototype.search() method.
regexObj.exec(str)
strIf the match succeeds, the exec() method returns an array and updates properties of the regular expression object. The returned array has the matched text as the first item, and then one item for each capturing parenthesis that matched containing the text that was captured.
If the match fails, the exec() method returns null.
Consider the following example:
// Match \"quick brown\" followed by \"jumps\", ignoring characters in between\n// Remember \"brown\" and \"jumps\"\n// Ignore case\nvar re = /quick\\s(brown).+?(jumps)/ig;\nvar result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog');\n The following table shows the results for this script:
| Object | Property/Index | Description | Example |
|---|---|---|---|
result | [0] | The full string of characters matched | \"Quick Brown Fox Jumps\" |
[1], ...[n] | The parenthesized substring matches, if any. The number of possible parenthesized substrings is unlimited. | result[1] === \"Brown\" | |
index | The 0-based index of the match in the string. | 4 | |
input | The original string that was matched against. | \"The Quick Brown Fox Jumps Over The Lazy Dog\" | |
re | lastIndex | The index at which to start the next match. If g is absent, this will always be 0. | 25 |
ignoreCase | Indicates if the i flag was used to ignore case. | true | |
global | Indicates if the g flag was used for a global match. | true | |
multiline | Indicates if the m flag was used to search across multiple lines. | false | |
source | The text of the pattern. | \"quick\\s(brown).+?(jumps)\" |
If your regular expression uses the \"g\" flag, you can use the exec() method multiple times to find successive matches in the same string. When you do so, the search starts at the substring of str specified by the regular expression's lastIndex property (test() will also advance the lastIndex property). Note that the lastIndex property will not be reset when searching a different string it will start its search at its existing lastIndex .
For example, assume you have this script:
var myRe = /ab*/g;\nvar str = 'abbcdefabh';\nvar myArray;\nwhile ((myArray = myRe.exec(str)) !== null) {\n var msg = 'Found ' + myArray[0] + '. ';\n msg += 'Next match starts at ' + myRe.lastIndex;\n console.log(msg);\n}\n This script displays the following text:
Found abb. Next match starts at 3\nFound ab. Next match starts at 9\n
Note: Do not place the regular expression literal (or RegExp constructor) within the while condition or it will create an infinite loop if there is a match due to the lastIndex property being reset upon each iteration. Also be sure that the global flag (\"g\") is set or an infinite loop will occur here also.
exec() with RegExp literalsYou can also use exec() without creating a RegExp object:
var matches = /(hello \\S+)/.exec('This is a hello world!');\nconsole.log(matches[1]);\n This will log a message containing 'hello world!'.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp.exec' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.exec' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.exec' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
RegExp\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec\n
The shift() method removes the first element from an array and returns that removed element. This method changes the length of the array.
arr.shift()
The removed element from the array; undefined if the array is empty.
The shift method removes the element at the zeroeth index and shifts the values at consecutive indexes down, then returns the removed value. If the length property is 0, undefined is returned.
shift is intentionally generic; this method can be called or applied to objects resembling arrays. Objects which do not contain a length property reflecting the last in a series of consecutive, zero-based numerical properties may not behave in any meaningful manner.
The following code displays the myFish array before and after removing its first element. It also displays the removed element:
var myFish = ['angel', 'clown', 'mandarin', 'surgeon'];\n\nconsole.log('myFish before:', JSON.stringify(myFish));\n// myFish before: ['angel', 'clown', 'mandarin', 'surgeon']\n\nvar shifted = myFish.shift(); \n\nconsole.log('myFish after:', myFish); \n// myFish after: ['clown', 'mandarin', 'surgeon']\n\nconsole.log('Removed this element:', shifted); \n// Removed this element: angel\n The shift() method is often used in condition inside while loop. In the following example every iteration will remove the next element from an array, until it is empty:
var names = [\"Andrew\", \"Edward\", \"Paul\", \"Chris\" ,\"John\"];\n\nwhile( (i = names.shift()) !== undefined ) {\n console.log(i);\n}\n// Andrew, Edward, Paul, Chris, John\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.shift' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.shift' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.shift' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift\n
The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.
arr.unshift(element1[, ...[, elementN]])
elementNThe new length property of the object upon which the method was called.
The unshift method inserts the given values to the beginning of an array-like object.
unshift is intentionally generic; this method can be called or applied to objects resembling arrays. Objects which do not contain a length property reflecting the last in a series of consecutive, zero-based numerical properties may not behave in any meaningful manner.
var arr = [1, 2];\n\narr.unshift(0); // result of call is 3, the new array length\n// arr is [0, 1, 2]\n\narr.unshift(-2, -1); // = 5\n// arr is [-2, -1, 0, 1, 2]\n\narr.unshift([-3]);\n// arr is [[-3], -2, -1, 0, 1, 2]\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.unshift' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.unshift' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype.unshift' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n1 | \nYes | \n1 | \n5.5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift\n
The Array[@@species] accessor property returns the Array constructor.
Array[Symbol.species]\n
The Array constructor.
The species accessor property returns the default constructor for Array objects. Subclass constructors may override it to change the constructor assignment.
The species property returns the default constructor function, which is the Array constructor for Array objects:
Array[Symbol.species]; // function Array()
In a derived collection object (e.g. your custom array MyArray), the MyArray species is the MyArray constructor. However, you might want to overwrite this, in order to return parent Array objects in your derived class methods:
class MyArray extends Array {\n // Overwrite MyArray species to the parent Array constructor\n static get [Symbol.species]() { return Array; }\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'get Array [ @@species ]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'get Array [ @@species ]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n48 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.5.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/@@species\n
Array instances inherit from Array.prototype. As with all constructors, you can change the constructor's prototype object to make changes to all Array instances. For example, you can add new methods and properties to extend all Array objects. This is used for polyfilling, for example.
However, adding non-standard methods to the array object can cause issues later, either with your own code, or when adding features to JavaScript.
Little known fact: Array.prototype itself is an Array:
Array.isArray(Array.prototype); // true\n
Property attributes of Array.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Array.prototype.constructorArray.prototype.lengthArray.prototype[@@unscopables]with binding scope.These methods modify the array:
Array.prototype.copyWithin()Array.prototype.fill()Array.prototype.pop()Array.prototype.push()Array.prototype.reverse()Array.prototype.shift()Array.prototype.sort()Array.prototype.splice()Array.prototype.unshift()These methods do not modify the array and return some representation of the array.
Array.prototype.concat()Array.prototype.includes()true or false as appropriate.Array.prototype.indexOf()Array.prototype.join()Array.prototype.lastIndexOf()Array.prototype.slice()Array.prototype.toSource() \nObject.prototype.toSource() method.Array.prototype.toString()Object.prototype.toString() method.Array.prototype.toLocaleString()Object.prototype.toLocaleString() method.Several methods take as arguments functions to be called back while processing the array. When these methods are called, the length of the array is sampled, and any element added beyond this length from within the callback is not visited. Other changes to the array (setting the value of or deleting an element) may affect the results of the operation if the method visits the changed element afterwards. While the specific behavior of these methods in such cases is well-defined, you should not rely upon it so as not to confuse others who might read your code. If you must mutate the array, copy into a new array instead.
Array.prototype.entries()Array Iterator object that contains the key/value pairs for each index in the array.Array.prototype.every()Array.prototype.filter()Array.prototype.find()undefined if not found.Array.prototype.findIndex()Array.prototype.forEach()Array.prototype.keys()Array Iterator that contains the keys for each index in the array.Array.prototype.map()Array.prototype.reduce()Array.prototype.reduceRight()Array.prototype.some()Array.prototype.values()Array Iterator object that contains the values for each index in the array.Array.prototype[@@iterator]()Array Iterator object that contains the values for each index in the array.Many methods on the JavaScript Array object are designed to be generally applied to all objects which “look like” Arrays. That is, they can be used on any object which has a length property, and which can usefully be accessed using numeric property names (as with array[5] indexing). Some methods, such as join, only read the length and numeric properties of the object they are called on. Others, like reverse, require that the object's numeric properties and length be mutable; these methods can therefore not be called on objects like String, which does not permit its length property or synthesized numeric properties to be set.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype' in that specification. | Standard | Added the copyWithin(), fill(), entries(), keys(), values(), find(), findIndex() methods. |
| ECMAScript 2016 (ECMA-262) The definition of 'Array.prototype' in that specification. | Standard | Added the includes() method. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Array.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype\n
The byteLength accessor property represents the length of an SharedArrayBuffer in bytes.
sab.byteLength
The byteLength property is an accessor property whose set accessor function is undefined, meaning that you can only read this property. The value is established when the shared array is constructed and cannot be changed.
var sab = new SharedArrayBuffer(1024);\nsab.byteLength; // 1024\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'SharedArrayBuffer.prototype.byteLength' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/byteLength\n
The SharedArrayBuffer.prototype property represents the prototype for the SharedArrayBuffer object.
Property attributes of SharedArrayBuffer.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
SharedArrayBuffer instances inherit from SharedArrayBuffer.prototype. As with all constructors, you can change the constructor's prototype object to make changes to all SharedArrayBuffer instances.
SharedArrayBuffer constructor.SharedArrayBuffer.prototype.byteLength Read only \nSharedArrayBuffer.prototype.slice(begin, end)SharedArrayBuffer whose contents are a copy of this SharedArrayBuffer's bytes from begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'SharedArrayBuffer.prototype' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n No\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/prototype\n
The SharedArrayBuffer.prototype.slice() method returns a new SharedArrayBuffer whose contents are a copy of this SharedArrayBuffer's bytes from begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning. This method has the same algorithm as Array.prototype.slice().
sab.slice()\nsab.slice(begin)\nsab.slice(begin, end)
begin Optional\nslice(-2) extracts the last two elements in the sequence.begin is undefined, slice begins from index 0.end Optional\nslice extracts up to but not including end.slice(1,4) extracts the second element through the fourth element (elements indexed 1, 2, and 3).slice(2,-1) extracts the third element through the second-to-last element in the sequence.end is omitted, slice extracts through the end of the sequence (sab.byteLength).\nA new SharedArrayBuffer containing the extracted elements.
var sab = new SharedArrayBuffer(1024);\nsab.slice(); // SharedArrayBuffer { byteLength: 1024 }\nsab.slice(2); // SharedArrayBuffer { byteLength: 1022 }\nsab.slice(-2); // SharedArrayBuffer { byteLength: 2 }\nsab.slice(0, 1); // SharedArrayBuffer { byteLength: 1 }\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'SharedArrayBuffer.prototype.slice' in that specification. | Draft | Initial definition in ES2017. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 68\n
| \n 16\n
| \n 57\n
| \nNo | \nNo | \n10.1 — ? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n60 — 63\n
| \n60 — 63\n
| \n? | \n 57\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.10.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer/slice\n
The RegExp.prototype property represents the prototype object for the RegExp constructor.
Property attributes of RegExp.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
See RegExp for a description of RegExp instances. RegExp instances inherit from RegExp.prototype. Modifications to the prototype object are propagated to all RegExp instances.
See also deprecated RegExp properties.
Note that several of the RegExp properties have both long and short (Perl-like) names. Both names always refer to the same value. Perl is the programming language from which JavaScript modeled its regular expressions.
RegExp.prototype.constructorRegExp.prototype.flagsRegExp object.RegExp.prototype.globalRegExp.prototype.ignoreCaseRegExp.prototype.multilineRegExp.prototype.sourceRegExp.prototype.stickyRegExp.prototype.unicodeRegExp.prototype.compile() \nRegExp.prototype.exec()RegExp.prototype.test()RegExp.prototype[@@match]()RegExp.prototype[@@replace]()RegExp.prototype[@@search]()RegExp.prototype[@@split]()RegExp.prototype.toSource() \nObject.prototype.toSource() method.RegExp.prototype.toString()Object.prototype.toString() method.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype' in that specification. | Standard | Added flags, sticky and unicode properties. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
RegExpFunction.prototype\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype\n
The flags property returns a string consisting of the flags of the current regular expression object.
Property attributes of RegExp.prototype.flags\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
Flags in the flags property are sorted alphabetically (from left to right, e.g. \"gimuy\").
flags\n/foo/ig.flags; // \"gi\"\n/bar/myu.flags; // \"muy\"\n
if (RegExp.prototype.flags === undefined) {\n Object.defineProperty(RegExp.prototype, 'flags', {\n configurable: true,\n get: function() {\n return this.toString().match(/[gimuy]*$/)[0];\n }\n });\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype.flags' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype.flags' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n37 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n37 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/flags\n
The multiline property indicates whether or not the \"m\" flag is used with the regular expression. multiline is a read-only property of an individual regular expression instance.
Property attributes of RegExp.prototype.multiline\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
The value of multiline is a Boolean and is true if the \"m\" flag was used; otherwise, false. The \"m\" flag indicates that a multiline input string should be treated as multiple lines. For example, if \"m\" is used, \"^\" and \"$\" change from matching at only the start or end of the entire string to the start or end of any line within the string.
You cannot change this property directly.
multiline\nvar regex = new RegExp('foo', 'm');\n\nconsole.log(regex.multiline); // true\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. JavaScript 1.5: multiline is a property of a RegExp instance, not the RegExp object. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp.prototype.multiline' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype.multiline' in that specification. | Standard | \nmultiline is now a prototype accessor property rather than an instance's own data property. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype.multiline' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \n? | \n38 | \n? | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \nYes | \n? | \n38 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \n
RegExp.multiline property existed in addition to this RegExp.prototype.multiline property. It is removed in newer versions (see bug 1219757). Use the property described on this page or the m flag instead.RegExp.lastIndexRegExp.prototype.globalRegExp.prototype.ignoreCaseRegExp.prototype.sourceRegExp.prototype.sticky\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/multiline\n
The unicode property indicates whether or not the \"u\" flag is used with a regular expression. unicode is a read-only property of an individual regular expression instance.
Property attributes of RegExp.prototype.unicode\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
The value of unicode is a Boolean and true if the \"u\" flag was used; otherwise false. The \"u\" flag enables various Unicode-related features. With the \"u\" flag, any Unicode code point escapes will be interpreted as such, for example.
You cannot change this property directly. It is read-only.
unicode propertyvar regex = new RegExp('\\u{61}', 'u');\n\nconsole.log(regex.unicode); // true\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype.unicode' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype.unicode' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n50 | \n 12\n
| \n46 | \nNo | \n37 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n50 | \nYes | \n46 | \n37 | \n10 | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
RegExp.lastIndexRegExp.prototype.globalRegExp.prototype.ignoreCaseRegExp.prototype.multilineRegExp.prototype.sourceRegExp.prototype.sticky\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/unicode\n
The match() method retrieves the matches when matching a string against a regular expression.
str.match(regexp)
regexpobj is passed, it is implicitly converted to a RegExp by using new RegExp(obj). If you don't give any parameter and use the match() method directly, you will get an Array with an empty string:[\"\"].If the string matches the expression, it will return an Array containing the entire matched string as the first element, followed by any results captured in parentheses. If there were no matches, null is returned.
If the regular expression does not include the g flag, str.match() will return the same result as RegExp.exec(). The returned Array has an extra input property, which contains the original string that was parsed. In addition, it has an index property, which represents the zero-based index of the match in the string.
If the regular expression includes the g flag, the method returns an Array containing all matched substrings rather than match objects. Captured groups are not returned. If there were no matches, the method returns null.
RegExp methodsRegExp, use RegExp.test().RegExp.exec() instead.RegExp.exec() instead.match()\nIn the following example, match() is used to find 'Chapter' followed by 1 or more numeric characters followed by a decimal point and numeric character 0 or more times. The regular expression includes the i flag so that upper/lower case differences will be ignored.
var str = 'For more information, see Chapter 3.4.5.1';\nvar re = /see (chapter \\d+(\\.\\d)*)/i;\nvar found = str.match(re);\n\nconsole.log(found);\n\n// logs [ 'see Chapter 3.4.5.1',\n// 'Chapter 3.4.5.1',\n// '.1',\n// index: 22,\n// input: 'For more information, see Chapter 3.4.5.1' ]\n\n// 'see Chapter 3.4.5.1' is the whole match.\n// 'Chapter 3.4.5.1' was captured by '(chapter \\d+(\\.\\d)*)'.\n// '.1' was the last value captured by '(\\.\\d)'.\n// The 'index' property (22) is the zero-based index of the whole match.\n// The 'input' property is the original string that was parsed.
match()\nThe following example demonstrates the use of the global and ignore case flags with match(). All letters A through E and a through e are returned, each its own element in the array.
var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';\nvar regexp = /[A-E]/gi;\nvar matches_array = str.match(regexp);\n\nconsole.log(matches_array);\n// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']\n
match() with no parametervar str = \"Nothing will come of nothing.\";\n\nstr.match(); // returns [\"\"]
When the parameter is a string or a number, it is implicitly converted to a RegExp by using new RegExp(obj). If it is a positive number with a positive sign,the RegExp() method will ignore the positive sign.
var str1 = \"NaN means not a number. Infinity contains -Infinity and +Infinity in JavaScript.\",\n str2 = \"My grandfather is 65 years old and My grandmother is 63 years old.\",\n str3 = \"The contract was declared null and void.\";\nstr1.match(\"number\"); // \"number\" is a string. returns [\"number\"]\nstr1.match(NaN); // the type of NaN is the number. returns [\"NaN\"]\nstr1.match(Infinity); // the type of Infinity is the number. returns [\"Infinity\"]\nstr1.match(+Infinity); // returns [\"Infinity\"]\nstr1.match(-Infinity); // returns [\"-Infinity\"]\nstr2.match(65); // returns [\"65\"]\nstr2.match(+65); // A number with a positive sign. returns [\"65\"]\nstr3.match(null); // returns [\"null\"]
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.match' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.match' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.match' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nflags \n | \nNo | \nNo | \n1 — 49 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nflags \n | \nNo | \nNo | \nNo | \n4 — 49 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\nflags \n | \nNo | \n
flags was a non standard second argument only available in Gecko : str.match(regexp, flags)match() is called with a global regular expression, the RegExp.lastIndex property (if specified) will be reset to 0 (bug 501739).flags argument is deprecated and throws a console warning (bug 1142351).flags argument is no longer supported in non-release builds and will soon be removed entirely (bug 1245801).flags argument is no longer supported (bug 1108382).\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match\n
The global property indicates whether or not the \"g\" flag is used with the regular expression. global is a read-only property of an individual regular expression instance.
Property attributes of RegExp.prototype.global\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
The value of global is a Boolean and true if the \"g\" flag was used; otherwise, false. The \"g\" flag indicates that the regular expression should be tested against all possible matches in a string. A regular expression defined as both global (\"g\") and sticky (\"y\") will ignore the global flag and perform sticky matches.
You cannot change this property directly.
global\nvar regex = new RegExp('foo', 'g');\n\nconsole.log(regex.global); // true\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. JavaScript 1.5: global is a property of a RegExp instance, not the RegExp object. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp.prototype.global' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype.global' in that specification. | Standard | \nglobal is now a prototype accessor property rather than an instance's own data property. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype.global' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \n? | \n38 | \n? | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \nYes | \n? | \n38 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \n
RegExp.lastIndexRegExp.prototype.ignoreCaseRegExp.prototype.multilineRegExp.prototype.sourceRegExp.prototype.sticky\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/global\n
The ignoreCase property indicates whether or not the \"i\" flag is used with the regular expression. ignoreCase is a read-only property of an individual regular expression instance.
Property attributes of RegExp.prototype.ignoreCase\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
The value of ignoreCase is a Boolean and true if the \"i\" flag was used; otherwise, false. The \"i\" flag indicates that case should be ignored while attempting a match in a string.
You cannot change this property directly.
ignoreCase\nvar regex = new RegExp('foo', 'i');\n\nconsole.log(regex.ignoreCase); // true\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. JavaScript 1.5: ignoreCase is a property of a RegExp instance, not the RegExp object. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp.prototype.ignoreCase' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype.ignoreCase' in that specification. | Standard | \nignoreCase is now a prototype accessor property rather than an instance's own data property. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype.ignoreCase' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \n? | \n38 | \n? | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \nYes | \n? | \n38 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \n
RegExp.lastIndexRegExp.prototype.globalRegExp.prototype.multilineRegExp.prototype.sourceRegExp.prototype.sticky\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase\n
The sticky property reflects whether or not the search is sticky (searches in strings only from the index indicated by the lastIndex property of this regular expression). sticky is a read-only property of an individual regular expression object.
Property attributes of RegExp.prototype.sticky\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
The value of sticky is a Boolean and true if the \"y\" flag was used; otherwise, false. The \"y\" flag indicates that it matches only from the index indicated by the lastIndex property of this regular expression in the target string (and does not attempt to match from any later indexes). A regular expression defined as both sticky and global ignores the global flag.
You cannot change this property directly. It is read-only.
var str = '#foo#';\nvar regex = /foo/y;\n\nregex.lastIndex = 1;\nregex.test(str); // true\nregex.lastIndex = 5;\nregex.test(str); // false (lastIndex is taken into account with sticky flag)\nregex.lastIndex; // 0 (reset after match failure)\n
For several versions, Firefox's SpiderMonkey engine had a bug with regard to the ^ assertion and the sticky flag which allowed expressions starting with the ^ assertion and using the sticky flag to match when they shouldn't. The bug was introduced some time after Firefox 3.6 (which had the sticky flag but not the bug) and fixed in 2015. Perhaps because of the bug, the ES2015 specification specifically calls out the fact that:
When the
yflag is used with a pattern, ^ always matches only at the beginning of the input, or (ifmultilineistrue) at the beginning of a line.
Examples of correct behavior:
var regex = /^foo/y;\nregex.lastIndex = 2;\nregex.test('..foo'); // false - index 2 is not the beginning of the string\n\nvar regex2 = /^foo/my;\nregex2.lastIndex = 2;\nregex2.test('..foo'); // false - index 2 is not the beginning of the string or line\nregex2.lastIndex = 2;\nregex2.test('.\\nfoo'); // true - index 2 is the beginning of a line\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype.sticky' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype.sticky' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n13 | \n3 | \nNo | \n36 | \n10 | \n
| Prototype accessor property (ES2015) | \nYes | \n? | \n38 | \n? | \nYes | \nYes | \n
| Anchored sticky flag behavior per ES2015 | \nYes | \nYes | \n44 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n49 | \n49 | \nYes | \n4 | \n36 | \n10 | \n5.0 | \n
| Prototype accessor property (ES2015) | \nYes | \nYes | \n? | \n38 | \nYes | \nYes | \nYes | \n
| Anchored sticky flag behavior per ES2015 | \n? | \nYes | \nYes | \n44 | \n? | \n? | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \n
| Anchored sticky flag behavior per ES2015 | \n? | \n
RegExp.lastIndexRegExp.prototype.globalRegExp.prototype.ignoreCaseRegExp.prototype.multilineRegExp.prototype.source\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/sticky\n
The test() method executes a search for a match between a regular expression and a specified string. Returns true or false.
regexObj.test(str)
strtrue if there is a match between the regular expression and the specified string; otherwise, false.
Use test() whenever you want to know whether a pattern is found in a string. test() returns a boolean, unlike the String.prototype.search() method, which returns the index (or -1 if not found). To get more information (but with slower execution), use the exec() method (similar to the String.prototype.match() method). As with exec() (or in combination with it), test() called multiple times on the same global regular expression instance will advance past the previous match.
test()\nSimple example that tests if \"hello\" is contained at the very beginning of a string, returning a boolean result.
var str = 'hello world!';\nvar result = /^hello/.test(str);\nconsole.log(result); // true\n
The following example logs a message which depends on the success of the test:
function testinput(re, str) {\n var midstring;\n if (re.test(str)) {\n midstring = ' contains ';\n } else {\n midstring = ' does not contain ';\n }\n console.log(str + midstring + re.source);\n}\n test() on a regex with the global flagIf the regex has the global flag set, test() will advance the lastIndex of the regex. A subsequent use of test() will start the search at the substring of str specified by lastIndex (exec() will also advance the lastIndex property). It is worth noting that the lastIndex will not reset when testing a different string.
The following example demonstrates this behaviour:
var regex = /foo/g;\n\n// regex.lastIndex is at 0\nregex.test('foo'); // true\n\n// regex.lastIndex is now at 3\nregex.test('foo'); // false\n\n// regex.lastIndex is at 0\nregex.test('barfoo') // true\n\n// regex.lastIndex is at 6\nregex.test('foobar') //false Using the same mechanism the following example counts the total number of words in a string:
function countWords (sText) {\n\n for (var rWord = /\\w+/g, nCount = 0; rWord.test(sText); nCount++);\n\n return nCount;\n\n}\n\nconsole.log(countWords(\"What a beautiful day!\")); // 4\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp.test' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.test' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.test' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Prior to Firefox 8, test() was implemented incorrectly; when it was called with no parameters, it would match against the value of the previous input (RegExp.input property) instead of against the string \"undefined\". This is fixed; now /undefined/.test() correctly results in true, instead of an error.
RegExp\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test\n
The source property returns a String containing the source text of the regexp object, and it doesn't contain the two forward slashes on both sides and any flags.
Property attributes of RegExp.prototype.source\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
source\nvar regex = /fooBar/ig;\n\nconsole.log(regex.source); // \"fooBar\", doesn't contain /.../ and \"ig\".\n
Starting with ECMAScript 5, the source property no longer returns an empty string for empty regular expressions. Instead, the string \"(?:)\" is returned. In addition, line terminators (such as \"\\n\") are escaped now.
new RegExp().source; // \"(?:)\"\n\nnew RegExp('\\n').source === '\\n'; // true, prior to ES5\nnew RegExp('\\n').source === '\\\\n'; // true, starting with ES5\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. JavaScript 1.5: source is a property of a RegExp instance, not the RegExp object. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp.prototype.source' in that specification. | Standard | The source property for empty regular expressions now returns \"(?:)\" instead of an empty string. A definition for the escaping behavior has been added. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype.source' in that specification. | Standard | \nsource is now a prototype accessor property rather than an instance's own data property. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype.source' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \n? | \n41 | \n? | \nYes | \nYes | \n
| Escaping | \n? | \n? | \n38 | \n? | \n? | \n? | \n
| \"(?:)\" for empty regexps | \nYes | \n? | \n38 | \n? | \n? | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \nYes | \n? | \n41 | \nYes | \nYes | \nYes | \n
| Escaping | \n? | \n? | \n? | \n38 | \n? | \n? | \n? | \n
| \"(?:)\" for empty regexps | \n? | \n? | \n? | \n38 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Prototype accessor property (ES2015) | \nYes | \n
| Escaping | \n? | \n
| \"(?:)\" for empty regexps | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/source\n
The RegExp[@@species] accessor property returns the RegExp constructor.
RegExp[Symbol.species]\n
The species accessor property returns the default constructor for RegExp objects. Subclass constructors may over-ride it to change the constructor assignment.
The species property returns the default constructor function, which is the RegExp constructor for RegExp objects:
RegExp[Symbol.species]; // function RegExp()
In a derived collection object (e.g. your custom regexp MyRegExp), the MyRegExp species is the MyRegExp constructor. However, you might want to overwrite this, in order to return parent RegExp objects in your derived class methods:
class MyRegExp extends RegExp {\n // Overwrite MyRegExp species to the parent RegExp constructor\n static get [Symbol.species]() { return RegExp; }\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'get RegExp [ @@species ]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'get RegExp [ @@species ]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.5.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@species\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The deprecated compile() method is used to (re-)compile a regular expression during execution of a script. It is basically the same as the RegExp constructor.
regexObj.compile(pattern, flags)
patternflagsIf specified, flags can have any combination of the following values:
gimylastIndex property of this regular expression in the target string (and does not attempt to match from any later indexes). The compile method is deprecated. You can just use the RegExp constructor to achieve the same effect.
compile()\nThe following example shows how to recompile a regular expression with a new pattern and a new flag.
var regexObj = new RegExp('foo', 'gi'); \nregexObj.compile('new foo', 'g');\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype.compile' in that specification. | Standard | Initial definition. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype.compile' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/compile\n
The lastIndex is a read/write integer property of regular expression instances that specifies the index at which to start the next match.
Property attributes of regexp.lastIndex\n | |
|---|---|
| Writable | yes |
| Enumerable | no |
| Configurable | no |
regExpObj.lastIndex
This property is set only if the regular expression instance used the \"g\" flag to indicate a global search, or the \"y\" flag to indicate a sticky search. The following rules apply:
lastIndex is greater than the length of the string, test() and exec() fail, then lastIndex is set to 0.lastIndex is equal to the length of the string and if the regular expression matches the empty string, then the regular expression matches input starting at lastIndex.lastIndex is equal to the length of the string and if the regular expression does not match the empty string, then the regular expression mismatches input, and lastIndex is reset to 0.lastIndex is set to the next position following the most recent match.lastIndex\nConsider the following sequence of statements:
var re = /(hi)?/g;\n
Matches the empty string.
console.log(re.exec('hi'));\nconsole.log(re.lastIndex);\n Returns [\"hi\", \"hi\"] with lastIndex equal to 2.
console.log(re.exec('hi'));\nconsole.log(re.lastIndex);\n Returns [\"\", undefined], an empty array whose zeroth element is the match string. In this case, the empty string because lastIndex was 2 (and still is 2) and \"hi\" has length 2.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. JavaScript 1.5: lastIndex is a property of a RegExp instance, not the RegExp object. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp.lastIndex' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.lastIndex' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.lastIndex' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
RegExp.prototype.ignoreCaseRegExp.prototype.globalRegExp.prototype.multilineRegExp.prototype.sourceRegExp.prototype.sticky\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastIndex\n
The Symbol.hasInstance well-known symbol is used to determine if a constructor object recognizes an object as its instance. The instanceof operator's behavior can be customized by this symbol.
Property attributes of Symbol.hasInstance\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
You could implement your custom instanceof behavior like this, for example:
class MyArray { \n static [Symbol.hasInstance](instance) {\n return Array.isArray(instance);\n }\n}\nconsole.log([] instanceof MyArray); // true | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.hasInstance' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.hasInstance' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n51 | \n15 | \n50 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n50 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.5.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance\n
The replace() method returns a new string with some or all matches of a pattern replaced by a replacement. The pattern can be a string or a RegExp, and the replacement can be a string or a function to be called for each match. If pattern is a string, only the first occurrence will be replaced.
The original string is left unchanged.
str.replace(regexp|substr, newSubstr|function)
regexp (pattern)RegExp object or literal. The match or matches are replaced with newSubStr or the value returned by the specified function.substr (pattern)String that is to be replaced by newSubStr. It is treated as a verbatim string and is not interpreted as a regular expression. Only the first occurrence will be replaced.newSubStr (replacement)String that replaces the substring specified by the specified regexp or substr parameter. A number of special replacement patterns are supported; see the \"Specifying a string as a parameter\" section below.function (replacement)regexp or substr. The arguments supplied to this function are described in the \"Specifying a function as a parameter\" section below.A new string with some or all matches of a pattern replaced by a replacement.
This method does not change the String object it is called on. It simply returns a new string.
To perform a global search and replace, include the g switch in the regular expression.
The replacement string can include the following special replacement patterns:
| Pattern | Inserts |
|---|---|
$$ | Inserts a \"$\". |
$& | Inserts the matched substring. |
$` | Inserts the portion of the string that precedes the matched substring. |
$' | Inserts the portion of the string that follows the matched substring. |
$n | Where n is a positive integer less than 100, inserts the nth parenthesized submatch string, provided the first argument was a RegExp object. Note that this is 1-indexed. |
You can specify a function as the second parameter. In this case, the function will be invoked after the match has been performed. The function's result (return value) will be used as the replacement string. (Note: the above-mentioned special replacement patterns do not apply in this case.) Note that the function will be invoked multiple times for each full match to be replaced if the regular expression in the first parameter is global.
The arguments to the function are as follows:
| Possible name | Supplied value |
|---|---|
match | The matched substring. (Corresponds to $& above.) |
p1, p2, ... | The nth string found by a parenthesized capture group, provided the first argument to replace() was a RegExp object. (Corresponds to $1, $2, etc. above.) For example, if /(\\a+)(\\b+)/, was given, p1 is the match for \\a+, and p2 for \\b+. |
offset | The offset of the matched substring within the whole string being examined. (For example, if the whole string was 'abcd', and the matched substring was 'bc', then this argument will be 1.) |
string | The whole string being examined. |
(The exact number of arguments will depend on whether the first argument was a RegExp object and, if so, how many parenthesized submatches it specifies.)
The following example will set newString to 'abc - 12345 - #$*%':
function replacer(match, p1, p2, p3, offset, string) {\n // p1 is nondigits, p2 digits, and p3 non-alphanumerics\n return [p1, p2, p3].join(' - ');\n}\nvar newString = 'abc12345#$*%'.replace(/([^\\d]*)(\\d*)([^\\w]*)/, replacer);\nconsole.log(newString); // abc - 12345 - #$*%\n replace()\nIn the following example, the regular expression is defined in replace() and includes the ignore case flag.
var str = 'Twas the night before Xmas...';\nvar newstr = str.replace(/xmas/i, 'Christmas');\nconsole.log(newstr); // Twas the night before Christmas...\n
This logs 'Twas the night before Christmas...'
global and ignore with replace()\nGlobal replace can only be done with a regular expression. In the following example, the regular expression includes the global and ignore case flags which permits replace() to replace each occurrence of 'apples' in the string with 'oranges'.
var re = /apples/gi;\nvar str = 'Apples are round, and apples are juicy.';\nvar newstr = str.replace(re, 'oranges');\nconsole.log(newstr); // oranges are round, and oranges are juicy.\n
This logs 'oranges are round, and oranges are juicy'.
The following script switches the words in the string. For the replacement text, the script uses the $1 and $2 replacement patterns.
var re = /(\\w+)\\s(\\w+)/;\nvar str = 'John Smith';\nvar newstr = str.replace(re, '$2, $1');\nconsole.log(newstr); // Smith, John\n
This logs 'Smith, John'.
In this example, all occurrences of capital letters in the string are converted to lower case, and a hyphen is inserted just before the match location. The important thing here is that additional operations are needed on the matched item before it is given back as a replacement.
The replacement function accepts the matched snippet as its parameter, and uses it to transform the case and concatenate the hyphen before returning.
function styleHyphenFormat(propertyName) {\n function upperToHyphenLower(match, offset, string) {\n return (offset > 0 ? '-' : '') + match.toLowerCase();\n }\n return propertyName.replace(/[A-Z]/g, upperToHyphenLower);\n}\n Given styleHyphenFormat('borderTop'), this returns 'border-top'.
Because we want to further transform the result of the match before the final substitution is made, we must use a function. This forces the evaluation of the match prior to the toLowerCase() method. If we had tried to do this using the match without a function, the toLowerCase() would have no effect.
var newString = propertyName.replace(/[A-Z]/g, '-' + '$&'.toLowerCase()); // won't work\n
This is because '$&'.toLowerCase() would be evaluated first as a string literal (resulting in the same '$&') before using the characters as a pattern.
The following example replaces a Fahrenheit degree with its equivalent Celsius degree. The Fahrenheit degree should be a number ending with F. The function returns the Celsius number ending with C. For example, if the input number is 212F, the function returns 100C. If the number is 0F, the function returns -17.77777777777778C.
The regular expression test checks for any number that ends with F. The number of Fahrenheit degree is accessible to the function through its second parameter, p1. The function sets the Celsius number based on the Fahrenheit degree passed in a string to the f2c() function. f2c() then returns the Celsius number. This function approximates Perl's s///e flag.
function f2c(x) {\n function convert(str, p1, offset, s) {\n return ((p1 - 32) * 5/9) + 'C';\n }\n var s = String(x);\n var test = /(-?\\d+(?:\\.\\d*)?)F\\b/g;\n return s.replace(test, convert);\n}\n for loopsThe following example takes a string pattern and converts it into an array of objects.
Input:
A string made out of the characters x, - and _
x-x_\nx---x---x---x---\nx-xxx-xx-x-\nx_x_x___x___x___\n
Output:
An array of objects. An 'x' denotes an 'on' state, a '-' (hyphen) denotes an 'off' state and an '_' (underscore) denotes the length of an 'on' state.
[\n { on: true, length: 1 },\n { on: false, length: 1 },\n { on: true, length: 2 }\n ...\n]\n Snippet:
var str = 'x-x_';\nvar retArr = [];\nstr.replace(/(x_*)|(-)/g, function(match, p1, p2) {\n if (p1) { retArr.push({ on: true, length: p1.length }); }\n if (p2) { retArr.push({ on: false, length: 1 }); }\n});\n\nconsole.log(retArr);\n This snippet generates an array of 3 objects in the desired format without using a for loop.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.replace' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.replace' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.replace' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nflags \n | \nNo | \nNo | \n1 — 49 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nflags \n | \nNo | \nNo | \nNo | \n4 — 49 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\nflags \n | \nNo | \n
flags was a non standard third argument only available in Gecko : str.replace(regexp|substr, newSubStr|function, flags)replace() is called with a global regular expression, the RegExp.lastIndex property (if specified) will be reset to 0 (bug 501739).flags argument is deprecated and throws a console warning (bug 1142351).flags argument is no longer supported in non-release builds and will soon be removed entirely (bug 1245801).flags argument is no longer supported (bug 1108382).\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace\n
The [@@search]() method executes a search for a match between a this regular expression and a string.
regexp[Symbol.search](str)
strString that is a target of the search.[@@search]() returns the index of the first match of the regular expression inside the string. Otherwise, it returns -1.This method is called internally in String.prototype.search(). For example, the following two examples return the same result.
'abc'.search(/a/);\n\n/a/[Symbol.search]('abc'); This method exists for customizing the search behavior in RegExp subclasses.
This method can be used in almost the same way as String.prototype.search(), except the different this and the different arguments order.
var re = /-/g;\nvar str = '2016-01-02';\nvar result = re[Symbol.search](str);\nconsole.log(result); // 4\n
@@search in subclassesSubclass of RegExp can override [@@search]() method to modify the behavior.
class MyRegExp extends RegExp {\n constructor(str) {\n super(str)\n this.pattern = str;\n }\n [Symbol.search](str) {\n return str.indexOf(this.pattern);\n }\n}\n\nvar re = new MyRegExp('a+b');\nvar str = 'ab a+b';\nvar result = str.search(re); // String.prototype.search calls re[@@search].\nconsole.log(result); // 3\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype[@@search]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype[@@search]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
String.prototype.search()RegExp.prototype[@@match]()RegExp.prototype[@@replace]()RegExp.prototype[@@split]()RegExp.prototype.exec()RegExp.prototype.test()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@search\n
The [@@match]() method retrieves the matches when matching a string against a regular expression.
regexp[Symbol.match](str)
strString that is a target of the match.An Array containing the entire match result and any parentheses-captured matched results, or null if there were no matches.
This method is called internally in String.prototype.match(). For example, the following two examples return same result.
'abc'.match(/a/);\n\n/a/[Symbol.match]('abc'); This method exists for customizing match behavior within RegExp subclasses.
This method can be used in almost the same way as String.prototype.match(), except the different this and the different arguments order.
var re = /[0-9]+/g;\nvar str = '2016-01-02';\nvar result = re[Symbol.match](str);\nconsole.log(result); // [\"2016\", \"01\", \"02\"]\n
@@match in subclassesSubclasses of RegExp can override the [@@match]() method to modify the default behavior.
class MyRegExp extends RegExp {\n [Symbol.match](str) {\n var result = RegExp.prototype[Symbol.match].call(this, str);\n if (!result) return null;\n return {\n group(n) {\n return result[n];\n }\n };\n }\n}\n\nvar re = new MyRegExp('([0-9]+)-([0-9]+)-([0-9]+)');\nvar str = '2016-01-02';\nvar result = str.match(re); // String.prototype.match calls re[@@match].\nconsole.log(result.group(1)); // 2016\nconsole.log(result.group(2)); // 01\nconsole.log(result.group(3)); // 02\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype[@@match]' in that specification. | Standard | Initial defintion. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype[@@match]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
String.prototype.match()RegExp.prototype[@@replace]()RegExp.prototype[@@search]()RegExp.prototype[@@split]()RegExp.prototype.exec()RegExp.prototype.test()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@match\n
The Symbol.iterator well-known symbol specifies the default iterator for an object. Used by for...of.
Property attributes of Symbol.iterator\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Whenever an object needs to be iterated (such as at the beginning of a for..of loop), its @@iterator method is called with no arguments, and the returned iterator is used to obtain the values to be iterated.
Some built-in types have a default iteration behavior, while other types (such as Object) do not. The built-in types with a @@iterator method are:
Array.prototype[@@iterator]()TypedArray.prototype[@@iterator]()String.prototype[@@iterator]()Map.prototype[@@iterator]()Set.prototype[@@iterator]()See also Iteration protocols for more information.
We can make our own iterables like this:
var myIterable = {}\nmyIterable[Symbol.iterator] = function* () {\n yield 1;\n yield 2;\n yield 3;\n};\n[...myIterable] // [1, 2, 3]\n If an iterable's @@iterator method does not return an iterator object, then it is a non-well-formed iterable. Using it as such is likely to result in runtime exceptions or buggy behavior:
var nonWellFormedIterable = {}\nnonWellFormedIterable[Symbol.iterator] = () => 1\n[...nonWellFormedIterable] // TypeError: [] is not a function\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.iterator' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.iterator' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n43 | \nYes | \n36 | \nNo | \n30 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n36 | \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Array.prototype[@@iterator]()TypedArray.prototype[@@iterator]()String.prototype[@@iterator]()Map.prototype[@@iterator]()Set.prototype[@@iterator]()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator\n
The Symbol.isConcatSpreadable well-known symbol is used to configure if an object should be flattened to its array elements when using the Array.prototype.concat() method.
Property attributes of Symbol.isConcatSpreadable\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The @@isConcatSpreadable symbol (Symbol.isConcatSpreadable) can be defined as an own or inherited property and its value is a boolean. It can control behavior for arrays and array-like objects:
Symbol.isConcatSpreadable can avoid flattening in these cases.Symbol.isConcatSpreadable can force flattening in these cases.By default, Array.prototype.concat() spreads (flattens) arrays into its result:
var alpha = ['a', 'b', 'c'], \n numeric = [1, 2, 3]; \n\nvar alphaNumeric = alpha.concat(numeric); \n\nconsole.log(alphaNumeric); // Result: ['a', 'b', 'c', 1, 2, 3]\n
When setting Symbol.isConcatSpreadable to false, you can disable the default behavior:
var alpha = ['a', 'b', 'c'], \n numeric = [1, 2, 3]; \n\nnumeric[Symbol.isConcatSpreadable] = false;\nvar alphaNumeric = alpha.concat(numeric); \n\nconsole.log(alphaNumeric); // Result: ['a', 'b', 'c', [1, 2, 3] ]\n
For array-like objects, the default is to not spread. Symbol.isConcatSpreadable needs to be set to true in order to get a flattened array:
var x = [1, 2, 3];\n\nvar fakeArray = { \n [Symbol.isConcatSpreadable]: true, \n length: 2, \n 0: 'hello', \n 1: 'world' \n}\n\nx.concat(fakeArray); // [1, 2, 3, \"hello\", \"world\"]\n Note: The length property is used to control the number of object properties to be added. In the above example, length:2 indicates two properties has to be added.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.isconcatspreadable' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.isconcatspreadable' in that specification. | Draft | No change. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n48 | \n15 | \n48 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n48 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/isConcatSpreadable\n
The [@@split]() method splits a String object into an array of strings by separating the string into substrings.
regexp[Symbol.split](str[, limit])
strlimitOptional. Integer specifying a limit on the number of splits to be found. The [@@split]() method still splits on every match of this RegExp pattern, until the number of split items match the limit or the string falls short of this pattern.
An Array containing substrings as its elements.
This method is called internally in String.prototype.split() if the separator argument is a RegExp object. For example, the following two examples return the same result.
'a-b-c'.split(/-/);\n\n/-/[Symbol.split]('a-b-c'); This method exists for customizing the split behavior in RegExp subclass.
If the str argument is not a RegExp object, String.prototype.split() doesn't call this method, nor create a RegExp object.
This method can be used in almost the same way as String.prototype.split(), except the different this and the different arguments order.
var re = /-/g;\nvar str = '2016-01-02';\nvar result = re[Symbol.split](str);\nconsole.log(result); // [\"2016\", \"01\", \"02\"]\n
@@split in subclassesSubclasses of RegExp can override the [@@split]() method to modify the default behavior.
class MyRegExp extends RegExp {\n [Symbol.split](str, limit) {\n var result = RegExp.prototype[Symbol.split].call(this, str, limit);\n return result.map(x => \"(\" + x + \")\");\n }\n}\n\nvar re = new MyRegExp('-');\nvar str = '2016-01-02';\nvar result = str.split(re); // String.prototype.split calls re[@@split].\nconsole.log(result); // [\"(2016)\", \"(01)\", \"(02)\"]\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype[@@split]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype[@@split]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
String.prototype.split()RegExp.prototype[@@match]()RegExp.prototype[@@replace]()RegExp.prototype[@@search]()RegExp.prototype.exec()RegExp.prototype.test()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@split\n
The Symbol.match well-known symbol specifies the matching of a regular expression against a string. This function is called by the String.prototype.match() method.
Property attributes of Symbol.match\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
This function is also used to identify if objects have the behavior of regular expressions. For example, the methods String.prototype.startsWith(), String.prototype.endsWith() and String.prototype.includes(), check if their first argument is a regular expression and will throw a TypeError if they are. Now, if the match symbol is set to false (or a Falsy value), it indicates that the object is not intended to be used as a regular expression object.
isRegExp checkThe following code will throw a TypeError:
'/bar/'.startsWith(/bar/); \n\n// Throws TypeError, as /bar/ is a regular expression\n// and Symbol.match is not modified.
However, if you set Symbol.match to false, the isRegExp check (that uses the match property) will indicate that the object is not a regular expression object. The methods startsWith and endsWith won't throw a TypeError as a consequence.
var re = /foo/;\nre[Symbol.match] = false;\n'/foo/'.startsWith(re); // true\n'/baz/'.endsWith(re); // false\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.match' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.match' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n50 | \nYes | \n40 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n40 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/match\n
The Symbol.replace well-known symbol specifies the method that replaces matched substrings of a string. This function is called by the String.prototype.replace() method.
For more information, see RegExp.prototype[@@replace]() and String.prototype.replace().
Property attributes of Symbol.replace\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.replace' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.replace' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n50 | \nYes | \n49 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/replace\n
The Symbol.search well-known symbol specifies the method that returns the index within a string that matches the regular expression. This function is called by the String.prototype.search() method.
For more information, see RegExp.prototype[@@search]() and String.prototype.search().
Property attributes of Symbol.search\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.search' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.search' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n50 | \nYes | \n49 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/search\n
The well-known symbol Symbol.species specifies a function-valued property that the constructor function uses to create derived objects.
Property attributes of Symbol.species\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The species accessor property allows subclasses to override the default constructor for objects.
You might want to return Array objects in your derived array class MyArray. For example, when using methods such as map() that return the default constructor, you want these methods to return a parent Array object, instead of the MyArray object. The species symbol lets you do this:
class MyArray extends Array {\n // Overwrite species to the parent Array constructor\n static get [Symbol.species]() { return Array; }\n}\nvar a = new MyArray(1,2,3);\nvar mapped = a.map(x => x * x);\n\nconsole.log(mapped instanceof MyArray); // false\nconsole.log(mapped instanceof Array); // true\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.species' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.species' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n51 | \n14 | \n41 | \nNo | \n38 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \n14 | \n41 | \n38 | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.5.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/species\n
The Symbol.split well-known symbol specifies the method that splits a string at the indices that match a regular expression. This function is called by the String.prototype.split() method.
For more information, see RegExp.prototype[@@split]() and String.prototype.split().
Property attributes of Symbol.split\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.split' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.split' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n50 | \nYes | \n49 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/split\n
The Symbol.prototype property represents the prototype for the Symbol constructor.
Property attributes of Symbol.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Symbol instances inherit from Symbol.prototype. You can use the constructor's prototype object to add properties or methods to all Symbol instances.
Symbol.prototype.constructorSymbol function by default.Symbol.prototype.descriptionSymbol.prototype.toSource() \nSymbol object. Overrides the Object.prototype.toSource() method.Symbol.prototype.toString()Object.prototype.toString() method.Symbol.prototype.valueOf()Symbol object. Overrides the Object.prototype.valueOf() method.Symbol.prototype[@@toPrimitive]Symbol object.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n36 | \nNo | \n25 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n38 | \nYes | \n36 | \n25 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/prototype\n
The read-only description property is a string returning the optional description of Symbol objects.
Symbol('myDescription').description;\nSymbol.iterator.description;\nSymbol.for('foo').description;\n Symbol objects can be created with an optional description which can be used for debugging but not to access the symbol itself. The Symbol.prototype.description property can be used to read that description. It is different to Symbol.prototype.toString() as it does not contain the enclosing \"Symbol()\" string. See the examples.
Symbol('desc').toString(); // \"Symbol(desc)\"\nSymbol('desc').description; // \"desc\"\nSymbol('').description; // \"\"\nSymbol().description; // undefined\n\n// well-known symbols\nSymbol.iterator.toString(); // \"Symbol(Symbol.iterator)\"\nSymbol.iterator.description; // \"Symbol.iterator\"\n\n// global symbols\nSymbol.for('foo').toString(); // \"Symbol(foo)\"\nSymbol.for('foo').description; // \"foo\"\n\n | Specification | Status |
|---|---|
\nget Symbol.prototype.description proposal | Stage 3 |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n70 | \nNo | \n63 | \nNo | \n57 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n70 | \n70 | \nNo | \n63 | \n57 | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/description\n
The Symbol.toStringTag well-known symbol is a string valued property that is used in the creation of the default string description of an object. It is accessed internally by the Object.prototype.toString() method.
Property attributes of Symbol.toStringTag\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Many JavaScript types have tags by default:
Object.prototype.toString.call('foo'); // \"[object String]\"\nObject.prototype.toString.call([1, 2]); // \"[object Array]\"\nObject.prototype.toString.call(3); // \"[object Number]\"\nObject.prototype.toString.call(true); // \"[object Boolean]\"\nObject.prototype.toString.call(undefined); // \"[object Undefined]\"\nObject.prototype.toString.call(null); // \"[object Null]\"\n// ... and more\n Others have a built-in toStringTag symbol defined:
Object.prototype.toString.call(new Map()); // \"[object Map]\"\nObject.prototype.toString.call(function* () {}); // \"[object GeneratorFunction]\"\nObject.prototype.toString.call(Promise.resolve()); // \"[object Promise]\"\n// ... and more\n When creating your own class, JavaScript defaults to the \"Object\" tag:
class ValidatorClass {}\n\nObject.prototype.toString.call(new ValidatorClass()); // \"[object Object]\"\n Now, with the help of toStringTag, you are able to set your own custom tag:
class ValidatorClass {\n get [Symbol.toStringTag]() {\n return 'Validator';\n }\n}\n\nObject.prototype.toString.call(new ValidatorClass()); // \"[object Validator]\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.toStringTag' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.toStringTag' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n49 | \n15 | \n51 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n51 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag\n
The [@@replace]() method replaces some or all matches of a this pattern in a string by a replacement, and returns the result of the replacement as a new string. The replacement can be a string or a function to be called for each match.
regexp[Symbol.replace](str, newSubStr|function)
strString that is a target of the replacement.newSubStr (replacement)String that replaces the substring. A number of special replacement patterns are supported; see the Specifying a string as a parameter section in String.prototype.replace() page.function (replacement)String.prototype.replace() page.A new string with some or all matches of a pattern replaced by a replacement.
This method is called internally in String.prototype.replace() if the pattern argument is a RegExp object. For example, following two examples return same result.
'abc'.replace(/a/, 'A');\n\n/a/[Symbol.replace]('abc', 'A'); This method exists for customizing replace behavior in RegExp subclass.
If pattern argument is not a RegExp object, String.prototype.replace() doesn't call this method, nor creates a RegExp object.
This method can be used in almost the same way as String.prototype.replace(), except the different this and the different arguments order.
var re = /-/g; \nvar str = '2016-01-01';\nvar newstr = re[Symbol.replace](str, '.');\nconsole.log(newstr); // 2016.01.01\n
Subclasses of RegExp can override the [@@replace]() method to modify the default behavior.
class MyRegExp extends RegExp {\n constructor(pattern, flags, count) {\n super(pattern, flags);\n this.count = count;\n }\n [Symbol.replace](str, replacement) {\n // Perform @@replace |count| times.\n var result = str;\n for (var i = 0; i < this.count; i++) {\n result = RegExp.prototype[Symbol.replace].call(this, result, replacement);\n }\n return result;\n }\n}\n\nvar re = new MyRegExp('\\\\d', '', 3);\nvar str = '01234567';\nvar newstr = str.replace(re, '#'); // String.prototype.replace calls re[@@replace].\nconsole.log(newstr); // ###34567 | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype[@@replace]' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype[@@replace]' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n49 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n49 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
String.prototype.replace()RegExp.prototype[@@match]()RegExp.prototype[@@search]()RegExp.prototype[@@split]()RegExp.prototype.exec()RegExp.prototype.test()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@replace\n
The toString() method returns a string representing the regular expression.
regexObj.toString();
A string representing the given object.
The RegExp object overrides the toString() method of the Object object; it does not inherit Object.prototype.toString(). For RegExp objects, the toString() method returns a string representation of the regular expression.
toString()\nThe following example displays the string value of a RegExp object:
var myExp = new RegExp('a+b+c');\nconsole.log(myExp.toString()); // logs '/a+b+c/'\n\nvar foo = new RegExp('bar', 'g');\nconsole.log(foo.toString()); // logs '/bar/g'\n Starting with ECMAScript 5, an empty regular expression returns the string \"/(?:)/\" and line terminators such as \"\\n\" are escaped:
new RegExp().toString(); // \"/(?:)/\"\n\nnew RegExp('\\n').toString() === '/\\n/'; // true, prior to ES5\nnew RegExp('\\n').toString() === '/\\\\n/'; // true, starting with ES5\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'RegExp.prototype.toString' in that specification. | Standard | Added definition for escaping behavior and \"(?:)\" for empty regular expressions. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'RegExp.prototype.toString' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'RegExp.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Escaping | \nYes | \nYes | \n38 | \nYes | \nYes | \nYes | \n
| Generic function | \n? | \n? | \n39 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Escaping | \nYes | \nYes | \nYes | \n38 | \nYes | \nYes | \nYes | \n
| Generic function | \n? | \n? | \n? | \n39 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Escaping | \nYes | \n
| Generic function | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/toString\n
The Symbol.unscopables well-known symbol is used to specify an object value of whose own and inherited property names are excluded from the with environment bindings of the associated object.
Property attributes of Symbol.unscopables\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
The @@unscopables symbol (Symbol.unscopables) can be defined on any object to exclude property names from being exposed as lexical variables in with with environment bindings. Note that if using Strict mode, with statements are not available and will likely also not need this symbol.
Setting a property to true in an unscopables object will make it unscopable and therefore it won't appear in lexical scope variables. Setting a property to false will make it scopable and thus it will appear in lexical scope variables.
The following code works fine in ES5 and below. However, in ECMAScript 2015 and later, the Array.prototype.keys() method was introduced. That means that inside with environment \"keys\" would now be the method and not the variable. That's when the unscopables symbol was introduced. A built-in unscopables setting is implemented as Array.prototype[@@unscopables] to prevent that some of the Array methods are being scoped into the with statement.
var keys = [];\n\nwith (Array.prototype) {\n keys.push('something');\n}\n\nObject.keys(Array.prototype[Symbol.unscopables]); \n// [\"copyWithin\", \"entries\", \"fill\", \"find\", \"findIndex\", \n// \"includes\", \"keys\", \"values\"]\n You can also set unscopables for your own objects.
var obj = { \n foo: 1, \n bar: 2 \n};\n\nobj[Symbol.unscopables] = { \n foo: false, \n bar: true \n};\n\nwith (obj) {\n console.log(foo); // 1\n console.log(bar); // ReferenceError: bar is not defined\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.unscopables' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.unscopables' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n48 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n48 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
Array.prototype[@@unscopables]with statement (not available in Strict mode)\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/unscopables\n
The Symbol.for(key) method searches for existing symbols in a runtime-wide symbol registry with the given key and returns it if found. Otherwise a new symbol gets created in the global symbol registry with this key.
Symbol.for(key);
An existing symbol with the given key if found; otherwise, a new symbol is created and returned.
In contrast to Symbol(), the Symbol.for() function creates a symbol available in a global symbol registry list. Symbol.for() does also not necessarily create a new symbol on every call, but checks first if a symbol with the given key is already present in the registry. In that case, that symbol is returned. If no symbol with the given key is found, Symbol.for() will create a new global symbol.
The global symbol registry is a list with the following record structure and it is initialized empty:
| Field name | Value |
|---|---|
| [[key]] | A string key used to identify a symbol. |
| [[symbol]] | A symbol that is stored globally. |
Symbol.for('foo'); // create a new global symbol\nSymbol.for('foo'); // retrieve the already created symbol\n\n// Same global symbol, but not locally\nSymbol.for('bar') === Symbol.for('bar'); // true\nSymbol('bar') === Symbol('bar'); // false\n\n// The key is also used as the description\nvar sym = Symbol.for('mario');\nsym.toString(); // \"Symbol(mario)\"\n To avoid name clashes with your global symbol keys and other (library code) global symbols, it might be a good idea to prefix your symbols:
Symbol.for('mdn.foo');\nSymbol.for('mdn.bar');\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.for' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.for' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n40 | \nYes | \n36 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n36 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/for\n
The Symbol.toPrimitive is a symbol that specifies a function valued property that is called to convert an object to a corresponding primitive value.
Property attributes of Symbol.toPrimitive\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
With the help of the Symbol.toPrimitive property (used as a function value), an object can be converted to a primitive value. The function is called with a string argument hint, which specifies the preferred type of the result primitive value. The hint argument can be one of \"number\", \"string\", and \"default\".
Following example describes how Symbol.toPrimitive property can modify the primitive value converted from an object.
// An object without Symbol.toPrimitive property.\nvar obj1 = {};\nconsole.log(+obj1); // NaN\nconsole.log(`${obj1}`); // \"[object Object]\"\nconsole.log(obj1 + ''); // \"[object Object]\"\n\n// An object with Symbol.toPrimitive property.\nvar obj2 = {\n [Symbol.toPrimitive](hint) {\n if (hint == 'number') {\n return 10;\n }\n if (hint == 'string') {\n return 'hello';\n }\n return true;\n }\n};\nconsole.log(+obj2); // 10 -- hint is \"number\"\nconsole.log(`${obj2}`); // \"hello\" -- hint is \"string\"\nconsole.log(obj2 + ''); // \"true\" -- hint is \"default\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.toPrimitive' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.toPrimitive' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n48 | \n15 | \n44 | \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n44 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
Date.prototype[@@toPrimitive]Symbol.prototype[@@toPrimitive]Object.prototype.toString()Object.prototype.valueOf()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive\n
The Symbol.keyFor(sym) method retrieves a shared symbol key from the global symbol registry for the given symbol.
Symbol.keyFor(sym);
A string representing the key for the given symbol if one is found on the global registry; otherwise, undefined.
var globalSym = Symbol.for('foo'); // create a new global symbol\nSymbol.keyFor(globalSym); // \"foo\"\n\nvar localSym = Symbol();\nSymbol.keyFor(localSym); // undefined\n\n// well-known symbols are not symbols registered \n// in the global symbol registry\nSymbol.keyFor(Symbol.iterator) // undefined\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.keyFor' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.keyFor' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n40 | \nYes | \n36 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n36 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/keyFor\n
The toString() method returns a string representing the specified Symbol object.
Symbol().toString();
A string representing the specified Symbol object.
The Symbol object overrides the toString method of the Object object; it does not inherit Object.prototype.toString(). For Symbol objects, the toString method returns a string representation of the object.
While you can call toString() on Symbols, you can't use string concatenation with them:
Symbol('foo') + 'bar'; // TypeError: Can't convert symbol to string Symbol('desc').toString(); // \"Symbol(desc)\"\n\n// well-known symbols\nSymbol.iterator.toString(); // \"Symbol(Symbol.iterator)\n\n// global symbols\nSymbol.for('foo').toString() // \"Symbol(foo)\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.prototype.toString' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n36 | \nNo | \n25 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n38 | \nYes | \n36 | \n25 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toString\n
The valueOf() method returns the primitive value of a Symbol object.
Symbol().valueOf();\n
The primitive value of the specified Symbol object.
The valueOf method of Symbol returns the primitive value of a Symbol object as a Symbol data type.
JavaScript calls the valueOf method to convert an object to a primitive value. You rarely need to invoke the valueOf method yourself; JavaScript automatically invokes it when encountering an object where a primitive value is expected.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.prototype.valueOf' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.prototype.valueOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \n12 | \n36 | \nNo | \n25 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n38 | \nYes | \n36 | \n25 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/valueOf\n
The [@@toPrimitive]() method converts a Symbol object to a primitive value.
Symbol()[Symbol.toPrimitive](hint);\n
The primitive value of the specified Symbol object.
The [@@toPrimitive]() method of Symbol returns the primitive value of a Symbol object as a Symbol data type. The hint argument is not used.
JavaScript calls the [@@toPrimitive]() method to convert an object to a primitive value. You rarely need to invoke the [@@toPrimitive]() method yourself; JavaScript automatically invokes it when encountering an object where a primitive value is expected.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Symbol.prototype.@@toPrimitive' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Symbol.prototype.@@toPrimitive' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n? | \n? | \n44 | \nNo | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/@@toPrimitive\n
The search() method executes a search for a match between a regular expression and this String object.
str.search(regexp)
regexpobj is passed, it is implicitly converted to a RegExp by using new RegExp(obj).The index of the first match between the regular expression and the given string; if not found, -1.
When you want to know whether a pattern is found and also its index in a string use search() (if you only want to know if it exists, use the similar test() method on the RegExp prototype, which returns a boolean); for more information (but slower execution) use match() (similar to the regular expression exec() method).
search()\nThe following example searches a string with 2 different regex objects to show a successful search (positive value) vs. an unsuccessful search (-1)
var str = \"hey JudE\";\nvar re = /[A-Z]/g;\nvar re2 = /[.]/g;\nconsole.log(str.search(re)); // returns 4, which is the index of the first capital letter \"J\"\nconsole.log(str.search(re2)); // returns -1 cannot find '.' dot punctuation
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.search' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.search' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.search' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
\nflags \n | \nNo | \nNo | \n1 — 49 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
\nflags \n | \nNo | \nNo | \nNo | \n4 — 49 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\nflags \n | \nNo | \n
flags was a non standard second argument only available in Gecko : str.search(regexp, flags)search() was implemented incorrectly; when it was called with no parameters or with undefined, it would match against the string 'undefined', instead of matching against the empty string. This is fixed; now 'a'.search() and 'a'.search(undefined) correctly return 0.flags argument is deprecated and throws a console warning (bug 1142351).flags argument is no longer supported in non-release builds and will soon be removed entirely (bug 1245801).flags argument is no longer supported (bug 1108382).\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search\n
The split() method splits a String object into an array of strings by separating the string into substrings, using a specified separator string to determine where to make each split.
str.split([separator[, limit]])
Attention: If an empty string (\"\") is used as the separator, the string is not split between each user-perceived character (grapheme cluster) or between each unicode character (codepoint) but between each UTF-16 codeunit. This destroys surrogate pairs. See also How do you get a string to a character array in JavaScript? on stackoverflow.
separator Optional\nseparator is treated as a string or as a regular expression. If a plain-text separator contains more than one character, that entire string must be found to represent a split point. If separator is omitted or does not occur in str, the array returned contains one element consisting of the entire string. If separator is an empty string, str is converted to an array of characters.limit Optional\nInteger specifying a limit on the number of splits to be found. When this parameter is provided, the split() method splits the string at each occurrence of the specified separator but stops when limit entries have been placed into the array. It may still contain fewer entries than limit if the end of the string is reached before the specified limit is reached. The left-over text is not returned in the new array.
An Array of strings split at each point where the separator occurs in the given string.
When found, separator is removed from the string and the substrings are returned in an array. If separator is not found or is omitted, the array contains one element consisting of the entire string. If separator is an empty string, str is converted to an array of characters. If separator appears at the beginning or end of the string, or both, the array begins, ends, or both begins and ends, respectively, with an empty string. Thus, if the string consists solely of one instance of separator, the array consists of two empty strings.
If separator is a regular expression that contains capturing parentheses, then each time separator is matched, the results (including any undefined results) of the capturing parentheses are spliced into the output array.
split() returns an array containing one empty string, rather than an empty array. If the string and separator are both empty strings, an empty array is returned.split()\nThe following example defines a function that splits a string into an array of strings using the specified separator. After splitting the string, the function logs messages indicating the original string (before the split), the separator used, the number of elements in the array, and the individual array elements.
function splitString(stringToSplit, separator) {\n var arrayOfStrings = stringToSplit.split(separator);\n\n console.log('The original string is: \"' + stringToSplit + '\"');\n console.log('The separator is: \"' + separator + '\"');\n console.log('The array has ' + arrayOfStrings.length + ' elements: ' + arrayOfStrings.join(' / '));\n}\n\nvar tempestString = 'Oh brave new world that has such people in it.';\nvar monthString = 'Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec';\n\nvar space = ' ';\nvar comma = ',';\n\nsplitString(tempestString, space);\nsplitString(tempestString);\nsplitString(monthString, comma);\n This example produces the following output:
The original string is: \"Oh brave new world that has such people in it.\"\nThe separator is: \" \"\nThe array has 10 elements: Oh / brave / new / world / that / has / such / people / in / it.\n\nThe original string is: \"Oh brave new world that has such people in it.\"\nThe separator is: \"undefined\"\nThe array has 1 elements: Oh brave new world that has such people in it.\n\nThe original string is: \"Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec\"\nThe separator is: \",\"\nThe array has 12 elements: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec\n
In the following example, split() looks for 0 or more spaces followed by a semicolon followed by 0 or more spaces and, when found, removes the spaces and the semicolon from the string. nameList is the array returned as a result of split().
var names = 'Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ';\n\nconsole.log(names);\n\nvar re = /\\s*(?:;|$)\\s*/;\nvar nameList = names.split(re);\n\nconsole.log(nameList);\n
This logs two lines; the first line logs the original string, and the second line logs the resulting array.
Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand \n[ \"Harry Trump\", \"Fred Barney\", \"Helen Rigby\", \"Bill Abel\", \"Chris Hand\", \"\" ]\n
In the following example, split() looks for spaces in a string and returns the first 3 splits that it finds.
var myString = 'Hello World. How are you doing?';\nvar splits = myString.split(' ', 3);\n\nconsole.log(splits);\n This script displays the following:
[\"Hello\", \"World.\", \"How\"]\n
RegExp to include parts of the separator in the resultIf separator is a regular expression that contains capturing parentheses (), matched results are included in the array.
var myString = 'Hello 1 word. Sentence number 2.';\nvar splits = myString.split(/(\\d)/);\n\nconsole.log(splits);\n
This script displays the following:
[ \"Hello \", \"1\", \" word. Sentence number \", \"2\", \".\" ]\n
var myString = 'this|is|a|Test';\nvar splits = myString.split(['|']);\n\nconsole.log(splits); //[\"this\", \"is\", \"a\", \"Test\"]\n\nvar myString = 'ca,bc,a,bca,bca,bc';\n\nvar splits = myString.split(['a','b']); \n// myString.split(['a','b']) is same as myString.split(String(['a','b'])) \n\nconsole.log(splits); //[\"c\", \"c,\", \"c\", \"c\", \"c\"]\n
split()\nThis is not a robust way to reverse a string:
var str = 'asdfghjkl';\nvar strReverse = str.split('').reverse().join(''); // 'lkjhgfdsa'\n// split() returns an array on which reverse() and join() can be applied\n It doesn't work if the string contains grapheme clusters, even when using a unicode aware split (use for example esrever instead).
var str = 'résumé';\nvar strReverse = str.split(/(?:)/u).reverse().join('');\n// => \"́emuśer\"\n Bonus: use === operator to test if the original string was palindrome.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.split' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.split' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.split' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
String.prototype.charAt()String.prototype.indexOf()String.prototype.lastIndexOf()Array.prototype.join()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split\n
The Date.now() method returns the number of milliseconds elapsed since January 1, 1970 00:00:00 UTC.
var timeInMs = Date.now();
A Number representing the milliseconds elapsed since the UNIX epoch.
Because now() is a static method of Date, you always use it as Date.now().
To offer protection against timing attacks and fingerprinting, the precision of Date.now() might get rounded depending on browser settings.
In Firefox, the privacy.reduceTimerPrecision preference is enabled by default and defaults to 20us in Firefox 59; in 60 it will be 2ms.
// reduced time precision (2ms) in Firefox 60\nDate.now()\n// 1519211809934\n// 1519211810362\n// 1519211811670\n// ...\n\n\n// reduced time precision with `privacy.resistFingerprinting` enabled\nDate.now();\n// 1519129853500\n// 1519129858900\n// 1519129864400\n// ...\n
In Firefox, you can also enable privacy.resistFingerprinting, the precision will be 100ms or the value of privacy.resistFingerprinting.reduceTimerPrecision.microseconds, whichever is larger.
This method was standardized in ECMA-262 5th edition. Engines which have not been updated to support this method can work around the absence of this method using the following shim:
if (!Date.now) {\n Date.now = function now() {\n return new Date().getTime();\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.now' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.now' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.now' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n5 | \nYes | \n3 | \n9 | \n10.5 | \n4 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Performance.now() — provides timestamps with sub-millisecond resolution for use in measuring web page performanceconsole.time() / console.timeEnd()\n\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now\n
The getDay() method returns the day of the week for the specified date according to local time, where 0 represents Sunday. For the day of the month see getDate().
dateObj.getDay()
An integer number corresponding to the day of the week for the given date, according to local time: 0 for Sunday, 1 for Monday, 2 for Tuesday, and so on.
getDay()\nThe second statement below assigns the value 1 to weekday, based on the value of the Date object Xmas95. December 25, 1995, is a Monday.
var Xmas95 = new Date('December 25, 1995 23:15:30');\nvar weekday = Xmas95.getDay();\n\nconsole.log(weekday); // 1\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getDay' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getDay' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getDay' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDay\n
The getDate() method returns the day of the month for the specified date according to local time.
dateObj.getDate()
An integer number, between 1 and 31, representing the day of the month for the given date according to local time.
The second statement below assigns the value 25 to the variable day, based on the value of the Date object Xmas95.
var Xmas95 = new Date('December 25, 1995 23:15:30');\nvar day = Xmas95.getDate();\n\nconsole.log(day); // 25\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getDate' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getDate' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getDate' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getDate\n
The getFullYear() method returns the year of the specified date according to local time.
Use this method instead of the getYear() method.
dateObj.getFullYear()
A number corresponding to the year of the given date, according to local time.
The value returned by getFullYear() is an absolute number. For dates between the years 1000 and 9999, getFullYear() returns a four-digit number, for example, 1995. Use this function to make sure a year is compliant with years after 2000.
getFullYear()\nThe following example assigns the four-digit value of the current year to the variable year.
var today = new Date();\nvar year = today.getFullYear();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getFullYear' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getFullYear' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getFullYear' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getFullYear\n
The getMinutes() method returns the minutes in the specified date according to local time.
dateObj.getMinutes()
An integer number, between 0 and 59, representing the minutes in the given date according to local time.
getMinutes()\nThe second statement below assigns the value 15 to the variable minutes, based on the value of the Date object Xmas95.
var Xmas95 = new Date('December 25, 1995 23:15:30');\nvar minutes = Xmas95.getMinutes();\n\nconsole.log(minutes); // 15\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getMinutes' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getMinutes' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getMinutes' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMinutes\n
The getTimezoneOffset() method returns the time zone difference, in minutes, from current locale (host system settings) to UTC.
dateObj.getTimezoneOffset()
A number representing the time-zone offset, in minutes, from the date based on current host system settings to UTC.
The time-zone offset is the difference, in minutes, from local time to UTC. Note that this means that the offset is positive if the local timezone is behind UTC and negative if it is ahead. For example, for time zone UTC+10:00 (Australian Eastern Standard Time, Vladivostok Time, Chamorro Standard Time), -600 will be returned.
| Current Locale | UTC-8 | UTC | UTC+3 |
| Return Value | 480 | 0 | -180 |
The time zone offset returned is the one that applies for the Date that it's called on. Where the host system is configured for daylight saving, the offset will change depending on the date and time that the Date represents and that daylight saving applies.
getTimezoneOffset()\n// Get current timezone offset for host device\nvar x = new Date();\nvar currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60;\n// 1\n\n// Get timezone offset for International Labour Day (May 1) in 2016\n// Be careful, the Date() constructor uses 0-indexed month so May is\n// represented with 4 (and not 5)\nvar labourDay = new Date(2016, 4, 1)\nvar labourDayOffset = labourDay.getTimezoneOffset() / 60;\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getTimezoneOffset' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getTimezoneOffset' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getTimezoneOffset' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n5 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset\n
The Date.parse() method parses a string representation of a date, and returns the number of milliseconds since January 1, 1970, 00:00:00 UTC or NaN if the string is unrecognized or, in some cases, contains illegal date values (e.g. 2015-02-31).
It is not recommended to use Date.parse as until ES5, parsing of strings was entirely implementation dependent. There are still many differences in how different hosts parse date strings, therefore date strings should be manually parsed (a library can help if many different formats are to be accommodated).
Direct call:
Date.parse(dateString)
Implicit call:
new Date(dateString)
dateStringA number representing the milliseconds elapsed since January 1, 1970, 00:00:00 UTC and the date obtained by parsing the given string representation of a date. If the argument doesn't represent a valid date, NaN is returned.
The parse() method takes a date string (such as \"Dec 25, 1995\") and returns the number of milliseconds since January 1, 1970, 00:00:00 UTC. This function is useful for setting date values based on string values, for example in conjunction with the setTime() method and the Date object.
Given a string representing a time, parse() returns the time value. It accepts the RFC2822 / IETF date syntax (RFC2822 Section 3.3), e.g. \"Mon, 25 Dec 1995 13:30:00 GMT\". It understands the continental US time zone abbreviations, but for general use, use a time zone offset, for example, \"Mon, 25 Dec 1995 13:30:00 +0430\" (4 hours, 30 minutes east of the Greenwich meridian).
GMT and UTC are considered equivalent. The local time zone is used to interpret arguments in RFC2822 Section 3.3 format that do not contain time zone information.
Because of the variances in parsing of date strings, it is recommended to always manually parse strings as results are inconsistent, especially across different ECMAScript implementations where strings like \"2015-10-12 12:00:00\" may be parsed to as NaN, UTC or local timezone.
The date time string may be in a simplified ISO 8601 format. For example, \"2011-10-10\" (just date) or \"2011-10-10T14:48:00\" (date and time) can be passed and parsed. Where the string is ISO 8601 date only, the UTC time zone is used to interpret arguments. If the string is date and time in ISO 8601 format, it will be treated as local.
While time zone specifiers are used during date string parsing to interpret the argument, the value returned is always the number of milliseconds between January 1, 1970 00:00:00 UTC and the point in time represented by the argument or NaN.
Because parse() is a static method of Date, it is called as Date.parse() rather than as a method of a Date instance.
Given a date string of \"March 7, 2014\", parse() assumes a local time zone, but given an ISO format such as \"2014-03-07\" it will assume a time zone of UTC (ES5 and ECMAScript 2015). Therefore Date objects produced using those strings may represent different moments in time depending on the version of ECMAScript supported unless the system is set with a local time zone of UTC. This means that two date strings that appear equivalent may result in two different values depending on the format of the string that is being converted.
The ECMAScript specification states: If the String does not conform to the standard format the function may fall back to any implementation–specific heuristics or implementation–specific parsing algorithm. Unrecognizable strings or dates containing illegal element values in ISO formatted strings shall cause Date.parse() to return NaN.
However, invalid values in date strings not recognized as simplified ISO format as defined by ECMA-262 may or may not result in NaN, depending on the browser and values provided, e.g.:
// Non-ISO string with invalid date values\nnew Date('23/25/2014');\n will be treated as a local date of 25 November, 2015 in Firefox 30 and an invalid date in Safari 7. However, if the string is recognized as an ISO format string and it contains invalid values, it will return NaN in all browsers compliant with ES5 and later:
// ISO string with invalid values\nnew Date('2014-25-23').toISOString();\n// returns \"RangeError: invalid date\" in all es5 compliant browsers\n SpiderMonkey's implementation-specific heuristic can be found in jsdate.cpp. The string \"10 06 2014\" is an example of a non–conforming ISO format and thus falls back to a custom routine. See also this rough outline on how the parsing works.
new Date('10 06 2014');\n will be treated as a local date of 6 October, 2014 and not 10 June, 2014. Other examples:
new Date('foo-bar 2014').toString();\n// returns: \"Invalid Date\"\n\nDate.parse('foo-bar 2014');\n// returns: NaN\n Date.parse()\nIf IPOdate is an existing Date object, it can be set to August 9, 1995 (local time) as follows:
IPOdate.setTime(Date.parse('Aug 9, 1995')); Some other examples of parsing non–standard date strings:
Date.parse('Aug 9, 1995'); Returns 807937200000 in time zone GMT-0300, and other values in other time zones, since the string does not specify a time zone and is not ISO format, therefore the time zone defaults to local.
Date.parse('Wed, 09 Aug 1995 00:00:00 GMT'); Returns 807926400000 no matter the local time zone as GMT (UTC) is provided.
Date.parse('Wed, 09 Aug 1995 00:00:00'); Returns 807937200000 in time zone GMT-0300, and other values in other time zones, since there is no time zone specifier in the argument and it is not ISO format, so is treated as local.
Date.parse('Thu, 01 Jan 1970 00:00:00 GMT'); Returns 0 no matter the local time zone as a time zone GMT (UTC) is provided.
Date.parse('Thu, 01 Jan 1970 00:00:00'); Returns 14400000 in time zone GMT-0400, and other values in other time zones, since no time zone is provided and the string is not in ISO format, therefore the local time zone is used.
Date.parse('Thu, 01 Jan 1970 00:00:00 GMT-0400'); Returns 14400000 no matter the local time zone as a time zone GMT (UTC) is provided.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.parse' in that specification. | Standard | Simplified ISO 8601 format added. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.parse' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.parse' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| ISO 8601 format | \nYes | \n? | \n4 | \n9 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| ISO 8601 format | \nYes | \nYes | \n? | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| ISO 8601 format | \n? | \n
50 are parsed as 21st century years. For example, 04/16/17, previously parsed as April 16, 1917, will be April 16, 2017 now. To avoid any interoperability issues or ambiguous years, it is recommended to use the ISO 8601 format like \"2017-04-16\" (bug 1265136).\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse\n
The getMonth() method returns the month in the specified date according to local time, as a zero-based value (where zero indicates the first month of the year).
dateObj.getMonth()
An integer number, between 0 and 11, representing the month in the given date according to local time. 0 corresponds to January, 1 to February, and so on.
getMonth()\nThe second statement below assigns the value 11 to the variable month, based on the value of the Date object Xmas95.
var Xmas95 = new Date('December 25, 1995 23:15:30');\nvar month = Xmas95.getMonth();\n\nconsole.log(month); // 11\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getMonth' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getMonth' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getMonth' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMonth\n
The Date.UTC() method accepts the same parameters as the Date constructor, but treats them as UTC. It returns the number of milliseconds since January 1, 1970, 00:00:00 UTC.
Date.UTC(year, month[, day[, hour[, minute[, second[, millisecond]]]]])
yearmonthdayhourminutesecondmillisecondA number representing the number of milliseconds for the given date since January 1, 1970, 00:00:00, UTC.
UTC() takes comma-delimited date and time parameters and returns the number of milliseconds between January 1, 1970, 00:00:00, universal time and the specified date and time.
Years between 0 and 99 are converted to a year in the 20th century (1900 + year); for example, 95 is converted to the year 1995.
The UTC() method differs from the Date constructor in two ways.
Date.UTC() uses universal time instead of the local time.Date.UTC() returns a time value as a number instead of creating a Date object.If a parameter is outside of the expected range, the UTC() method updates the other parameters to accommodate the value. For example, if 15 is used for month, the year will be incremented by 1 (year + 1) and 3 will be used for the month.
UTC() is a static method of Date, so it's called as Date.UTC() rather than as a method of a Date instance.
Date.UTC()\nThe following statement creates a Date object with the arguments treated as UTC instead of local:
var utcDate = new Date(Date.UTC(2018, 11, 1, 0, 0, 0));\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.UTC' in that specification. | Draft | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.UTC' in that specification. | Standard | |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.UTC' in that specification. | Standard | |
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Date.UTC with fewer than two argumentsWhen providing less than two arguments to Date.UTC, ECMAScript 2017 requires that NaN is returned. Engines that weren't supporting this behavior have been updated (see bug 1050755, ecma-262 #642).
Date.UTC();\nDate.UTC(1);\n\n// Safari: NaN \n// Chrome/Opera/V8: NaN\n\n// Firefox <54: non-NaN\n// Firefox 54+: NaN\n\n// IE: non-NaN\n// Edge: NaN\n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/UTC\n
The getHours() method returns the hour for the specified date, according to local time.
dateObj.getHours()
An integer number, between 0 and 23, representing the hour for the given date according to local time.
getHours()\nThe second statement below assigns the value 23 to the variable hours, based on the value of the Date object Xmas95.
var Xmas95 = new Date('December 25, 1995 23:15:30');\nvar hours = Xmas95.getHours();\n\nconsole.log(hours); // 23\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getHours' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getHours' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getHours' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getHours\n
The getMilliseconds() method returns the milliseconds in the specified date according to local time.
dateObj.getMilliseconds()
A number, between 0 and 999, representing the milliseconds for the given date according to local time.
getMilliseconds()\nThe following example assigns the milliseconds portion of the current time to the variable milliseconds:
var today = new Date();\nvar milliseconds = today.getMilliseconds();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getMilliseconds' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getMilliseconds' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getMilliseconds' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds\n
The getUTCDay() method returns the day of the week in the specified date according to universal time, where 0 represents Sunday.
dateObj.getUTCDay()
An integer number corresponding to the day of the week for the given date, according to universal time: 0 for Sunday, 1 for Monday, 2 for Tuesday, and so on.
getUTCDay()\nThe following example assigns the weekday portion of the current date to the variable weekday.
var today = new Date();\nvar weekday = today.getUTCDay();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getUTCDay' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getUTCDay' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getUTCDay' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDay\n
The getUTCDate() method returns the day (date) of the month in the specified date according to universal time.
dateObj.getUTCDate()
An integer number, between 1 and 31, representing the day of the month in the given date according to universal time.
getUTCDate()\nThe following example assigns the day portion of the current date to the variable day.
var today = new Date();\nvar day = today.getUTCDate();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getUTCDate' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getUTCDate' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getUTCDate' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCDate\n
The getUTCHours() method returns the hours in the specified date according to universal time.
dateObj.getUTCHours()
An integer number, between 0 and 23, representing the hours in the given date according to universal time.
getUTCHours()\nThe following example assigns the hours portion of the current time to the variable hours.
var today = new Date();\nvar hours = today.getUTCHours();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getUTCHours' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getUTCHours' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getUTCHours' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCHours\n
The getUTCMinutes() method returns the minutes in the specified date according to universal time.
dateObj.getUTCMinutes()
An integer number, between 0 and 59, representing the minutes in the given date according to universal time.
getUTCMinutes()\nThe following example assigns the minutes portion of the current time to the variable minutes.
var today = new Date();\nvar minutes = today.getUTCMinutes();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getUTCMinutes' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getUTCMinutes' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getUTCMinutes' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes\n
The getSeconds() method returns the seconds in the specified date according to local time.
dateObj.getSeconds()
An integer number, between 0 and 59, representing the seconds in the given date according to local time.
getSeconds()\nThe second statement below assigns the value 30 to the variable seconds, based on the value of the Date object Xmas95.
var Xmas95 = new Date('December 25, 1995 23:15:30');\nvar seconds = Xmas95.getSeconds();\n\nconsole.log(seconds); // 30\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getSeconds' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getSeconds' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getSeconds' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getSeconds\n
The getTime() method returns the numeric value corresponding to the time for the specified date according to universal time.
getTime() always uses UTC for time representation. For example, a client browser in one timezone, getTime() will be the same as a client browser in any other timezone.
You can use this method to help assign a date and time to another Date object. This method is functionally equivalent to the valueOf() method.
dateObj.getTime()
A number representing the milliseconds elapsed between 1 January 1970 00:00:00 UTC and the given date.
getTime() for copying datesConstructing a date object with the identical time value.
// Since month is zero based, birthday will be January 10, 1995\nvar birthday = new Date(1994, 12, 10);\nvar copy = new Date();\ncopy.setTime(birthday.getTime());\n
Subtracting two subsequent getTime() calls on newly generated Date objects, give the time span between these two calls. This can be used to calculate the executing time of some operations. See also Date.now() to prevent instantiating unnecessary Date objects.
var end, start;\n\nstart = new Date();\nfor (var i = 0; i < 1000; i++) {\n Math.sqrt(i);\n}\nend = new Date();\n\nconsole.log('Operation took ' + (end.getTime() - start.getTime()) + ' msec');\n To offer protection against timing attacks and fingerprinting, the precision of new Date().getTime() might get rounded depending on browser settings.
In Firefox, the privacy.reduceTimerPrecision preference is enabled by default and defaults to 20us in Firefox 59; in 60 it will be 2ms.
// reduced time precision (2ms) in Firefox 60\nnew Date().getTime();\n// 1519211809934\n// 1519211810362\n// 1519211811670\n// ...\n\n\n// reduced time precision with `privacy.resistFingerprinting` enabled\nnew Date().getTime();\n// 1519129853500\n// 1519129858900\n// 1519129864400\n// ...\n
In Firefox, you can also enabled privacy.resistFingerprinting, the precision will be 100ms or the value of privacy.resistFingerprinting.reduceTimerPrecision.microseconds, whichever is larger.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getTime' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getTime' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getTime' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTime\n
The getUTCMonth() returns the month of the specified date according to universal time, as a zero-based value (where zero indicates the first month of the year).
dateObj.getUTCMonth()
An integer number, between 0 and 11, corresponding to the month of the given date according to universal time. 0 for January, 1 for February, 2 for March, and so on.
getUTCMonth()\nThe following example assigns the month portion of the current date to the variable month.
var today = new Date();\nvar month = today.getUTCMonth();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getUTCMonth' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getUTCMonth' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getUTCMonth' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth\n
The getUTCMilliseconds() method returns the milliseconds in the specified date according to universal time.
dateObj.getUTCMilliseconds()
An integer number, between 0 and 999, representing the milliseconds in the given date according to universal time.
getUTCMilliseconds()\nThe following example assigns the milliseconds portion of the current time to the variable milliseconds.
var today = new Date();\nvar milliseconds = today.getUTCMilliseconds();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getUTCMilliseconds' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getUTCMilliseconds' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getUTCMilliseconds' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds\n
The getUTCFullYear() method returns the year in the specified date according to universal time.
dateObj.getUTCFullYear()
A number representing the year in the given date according to universal time.
The value returned by getUTCFullYear() is an absolute number that is compliant with year-2000, for example, 1995.
getUTCFullYear()\nThe following example assigns the four-digit value of the current year to the variable year.
var today = new Date();\nvar year = today.getUTCFullYear();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getUTCFullYear' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getUTCFullYear' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getUTCFullYear' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear\n
The setDate() method sets the day of the Date object relative to the beginning of the currently set month.
dateObj.setDate(dayValue)
dayValueThe number of milliseconds between 1 January 1970 00:00:00 UTC and the given date (the Date object is also changed in place).
If the dayValue is outside of the range of date values for the month, setDate() will update the Date object accordingly. For example, if 0 is provided for dayValue, the date will be set to the last day of the previous month.
setDate()\nvar theBigDay = new Date(1962, 6, 7); // 1962-07-07\ntheBigDay.setDate(24); // 1962-07-24\ntheBigDay.setDate(32); // 1962-08-01\ntheBigDay.setDate(22); // 1962-08-22\ntheBigDay.setDate(0); // 1962-07-31\ntheBigDay.setDate(98); // 1962-10-06\ntheBigDay.setDate(-50); // 1962-08-11\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setDate' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setDate' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setDate' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setDate\n
The setHours() method sets the hours for a specified date according to local time, and returns the number of milliseconds since January 1, 1970 00:00:00 UTC until the time represented by the updated Date instance.
dateObj.setHours(hoursValue[, minutesValue[, secondsValue[, msValue]]])
dateObj.setHours(hoursValue)
hoursValueminutesValuesecondsValuesecondsValue parameter, you must also specify the minutesValue.msValuemsValue parameter, you must also specify the minutesValue and secondsValue.The number of milliseconds between January 1, 1970 00:00:00 UTC and the updated date.
If you do not specify the minutesValue, secondsValue, and msValue parameters, the values returned from the getMinutes(), getSeconds(), and getMilliseconds() methods are used.
If a parameter you specify is outside of the expected range, setHours() attempts to update the date information in the Date object accordingly. For example, if you use 100 for secondsValue, the minutes will be incremented by 1 (minutesValue + 1), and 40 will be used for seconds.
setHours()\nvar theBigDay = new Date();\ntheBigDay.setHours(7);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setHours' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setHours' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setHours' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setHours\n
The setMilliseconds() method sets the milliseconds for a specified date according to local time.
dateObj.setMilliseconds(millisecondsValue)
millisecondsValueThe number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If you specify a number outside the expected range, the date information in the Date object is updated accordingly. For example, if you specify 1005, the number of seconds is incremented by 1, and 5 is used for the milliseconds.
setMilliseconds()\nvar theBigDay = new Date();\ntheBigDay.setMilliseconds(100);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setMilliseconds' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setMilliseconds' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setMilliseconds' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds\n
The setMonth() method sets the month for a specified date according to the currently set year.
dateObj.setMonth(monthValue[, dayValue])
dateObj.setMonth(monthValue)
monthValuedayValueThe number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If you do not specify the dayValue parameter, the value returned from the getDate() method is used.
If a parameter you specify is outside of the expected range, setMonth() attempts to update the date information in the Date object accordingly. For example, if you use 15 for monthValue, the year will be incremented by 1, and 3 will be used for month.
The current day of month will have an impact on the behaviour of this method. Conceptually it will add the number of days given by the current day of the month to the 1st day of the new month specified as the parameter, to return the new date. For example, if the current value is 31st August 2016, calling setMonth with a value of 1 will return 2nd March 2016. This is because in 2016 February had 29 days.
setMonth()\nvar theBigDay = new Date();\ntheBigDay.setMonth(6);\n\n//Watch out for end of month transitions\nvar endOfMonth = new Date(2016, 7, 31);\nendOfMonth.setMonth(1);\nconsole.log(endOfMonth); //Wed Mar 02 2016 00:00:00\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setMonth' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setMonth' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setMonth' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMonth\n
The setFullYear() method sets the full year for a specified date according to local time. Returns new timestamp.
dateObj.setFullYear(yearValue[, monthValue[, dateValue]])
yearValuemonthValuedateValuedateValue parameter, you must also specify the monthValue.The number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If you do not specify the monthValue and dateValue parameters, the values returned from the getMonth() and getDate() methods are used.
If a parameter you specify is outside of the expected range, setFullYear() attempts to update the other parameters and the date information in the Date object accordingly. For example, if you specify 15 for monthValue, the year is incremented by 1 (yearValue + 1), and 3 is used for the month.
setFullYear()\nvar theBigDay = new Date();\ntheBigDay.setFullYear(1997);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setFullYear' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setFullYear' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setFullYear' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setFullYear\n
The setUTCHours() method sets the hour for a specified date according to universal time, and returns the number of milliseconds since January 1, 1970 00:00:00 UTC until the time represented by the updated Date instance.
dateObj.setUTCHours(hoursValue[, minutesValue[, secondsValue[, msValue]]])
hoursValueminutesValuesecondsValuesecondsValue parameter, you must also specify the minutesValue.msValuemsValue parameter, you must also specify the minutesValue and secondsValue.The number of milliseconds between January 1, 1970 00:00:00 UTC and the updated date.
If you do not specify the minutesValue, secondsValue, and msValue parameters, the values returned from the getUTCMinutes(), getUTCSeconds(), and getUTCMilliseconds() methods are used.
If a parameter you specify is outside of the expected range, setUTCHours() attempts to update the date information in the Date object accordingly. For example, if you use 100 for secondsValue, the minutes will be incremented by 1 (minutesValue + 1), and 40 will be used for seconds.
setUTCHours()\nvar theBigDay = new Date();\ntheBigDay.setUTCHours(8);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setUTCHours' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setUTCHours' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setUTCHours' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCHours\n
The Date.prototype property represents the prototype for the Date constructor.
Property attributes of Date.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | yes |
JavaScript Date instances inherit from Date.prototype. You can modify the constructor's prototype object to affect properties and methods inherited by JavaScript Date instances.
For compatibility with millennium calculations (in other words, to take into account the year 2000), you should always specify the year in full; for example, use 1998, not 98. To assist you in specifying the complete year, JavaScript includes the methods getFullYear(), setFullYear(), getUTCFullYear() and setUTCFullYear().
Starting with ECMAScript 6, the Date.prototype object is itself an ordinary object. It is not a Date instance.
Date.prototype.constructorDate constructor by default.Date.prototype.getDate()Date.prototype.getDay()Date.prototype.getFullYear()Date.prototype.getHours()Date.prototype.getMilliseconds()Date.prototype.getMinutes()Date.prototype.getMonth()Date.prototype.getSeconds()Date.prototype.getTime()Date.prototype.getTimezoneOffset()Date.prototype.getUTCDate()Date.prototype.getUTCDay()Date.prototype.getUTCFullYear()Date.prototype.getUTCHours()Date.prototype.getUTCMilliseconds()Date.prototype.getUTCMinutes()Date.prototype.getUTCMonth()Date.prototype.getUTCSeconds()Date.prototype.getYear() \ngetFullYear() instead.Date.prototype.setDate()Date.prototype.setFullYear()Date.prototype.setHours()Date.prototype.setMilliseconds()Date.prototype.setMinutes()Date.prototype.setMonth()Date.prototype.setSeconds()Date.prototype.setTime()Date object to the time represented by a number of milliseconds since January 1, 1970, 00:00:00 UTC, allowing for negative numbers for times prior.Date.prototype.setUTCDate()Date.prototype.setUTCFullYear()Date.prototype.setUTCHours()Date.prototype.setUTCMilliseconds()Date.prototype.setUTCMinutes()Date.prototype.setUTCMonth()Date.prototype.setUTCSeconds()Date.prototype.setYear() \nsetFullYear() instead.Date.prototype.toDateString()Date as a human-readable string like 'Thu Apr 12 2018'Date.prototype.toISOString()Date.prototype.toJSON()Date using toISOString(). Intended for use by JSON.stringify().Date.prototype.toGMTString() \nDate based on the GMT (UT) time zone. Use toUTCString() instead.Date.prototype.toLocaleDateString()Date.prototype.toLocaleFormat() \nDate.prototype.toLocaleString()Object.prototype.toLocaleString() method.Date.prototype.toLocaleTimeString()Date.prototype.toSource() \nDate object; you can use this value to create a new object. Overrides the Object.prototype.toSource() method.Date.prototype.toString()Date object. Overrides the Object.prototype.toString() method.Date.prototype.toTimeString()Date as a human-readable string.Date.prototype.toUTCString()Date.prototype.valueOf()Date object. Overrides the Object.prototype.valueOf() method.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| Ordinary object (ES2015) | \n? | \n? | \n41 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| Ordinary object (ES2015) | \n? | \n? | \n? | \n41 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
| Ordinary object (ES2015) | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/prototype\n
The setMinutes() method sets the minutes for a specified date according to local time.
dateObj.setMinutes(minutesValue[, secondsValue[, msValue]])
dateObj.setMinutes(minutesValue)
minutesValuesecondsValuesecondsValue parameter, you must also specify the minutesValue.msValuemsValue parameter, you must also specify the minutesValue and secondsValue.The number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If you do not specify the secondsValue and msValue parameters, the values returned from getSeconds() and getMilliseconds() methods are used.
If a parameter you specify is outside of the expected range, setMinutes() attempts to update the date information in the Date object accordingly. For example, if you use 100 for secondsValue, the minutes will be incremented by 1 (minutesValue + 1), and 40 will be used for seconds.
setMinutes()\nvar theBigDay = new Date();\ntheBigDay.setMinutes(45);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setMinutes' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setMinutes' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setMinutes' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setMinutes\n
The setSeconds() method sets the seconds for a specified date according to local time.
dateObj.setSeconds(secondsValue[, msValue])
dateObj.setSeconds(secondsValue)
secondsValuemsValueThe number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If you do not specify the msValue parameter, the value returned from the getMilliseconds() method is used.
If a parameter you specify is outside of the expected range, setSeconds() attempts to update the date information in the Date object accordingly. For example, if you use 100 for secondsValue, the minutes stored in the Date object will be incremented by 1, and 40 will be used for seconds.
setSeconds()\nvar theBigDay = new Date();\ntheBigDay.setSeconds(30);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setSeconds' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setSeconds' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setSeconds' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setSeconds\n
The setTime() method sets the Date object to the time represented by a number of milliseconds since January 1, 1970, 00:00:00 UTC.
dateObj.setTime(timeValue)
timeValueThe number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date (effectively, the value of the argument).
Use the setTime() method to help assign a date and time to another Date object.
setTime()\nvar theBigDay = new Date('July 1, 1999');\nvar sameAsBigDay = new Date();\nsameAsBigDay.setTime(theBigDay.getTime());\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setTime' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setTime' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setTime' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setTime\n
The setUTCFullYear() method sets the full year for a specified date according to universal time.
dateObj.setUTCFullYear(yearValue[, monthValue[, dayValue]])
yearValuemonthValuedayValuedayValue parameter, you must also specify the monthValue.The number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If you do not specify the monthValue and dayValue parameters, the values returned from the getUTCMonth() and getUTCDate() methods are used.
If a parameter you specify is outside of the expected range, setUTCFullYear() attempts to update the other parameters and the date information in the Date object accordingly. For example, if you specify 15 for monthValue, the year is incremented by 1 (yearValue + 1), and 3 is used for the month.
setUTCFullYear()\nvar theBigDay = new Date();\ntheBigDay.setUTCFullYear(1997);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setUTCFullYear' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setUTCFullYear' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setUTCFullYear' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear\n
The setUTCMilliseconds() method sets the milliseconds for a specified date according to universal time.
dateObj.setUTCMilliseconds(millisecondsValue)
millisecondsValueThe number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If a parameter you specify is outside of the expected range, setUTCMilliseconds() attempts to update the date information in the Date object accordingly. For example, if you use 1100 for millisecondsValue, the seconds stored in the Date object will be incremented by 1, and 100 will be used for milliseconds.
setUTCMilliseconds()\nvar theBigDay = new Date();\ntheBigDay.setUTCMilliseconds(500);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setUTCMilliseconds' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setUTCMilliseconds' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setUTCMilliseconds' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds\n
The getUTCSeconds() method returns the seconds in the specified date according to universal time.
dateObj.getUTCSeconds()
An integer number, between 0 and 59, representing the seconds in the given date according to universal time.
getUTCSeconds()\nThe following example assigns the seconds portion of the current time to the variable seconds.
var today = new Date();\nvar seconds = today.getUTCSeconds();\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.getUTCSeconds' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.getUTCSeconds' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.getUTCSeconds' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds\n
The setUTCSeconds() method sets the seconds for a specified date according to universal time.
dateObj.setUTCSeconds(secondsValue[, msValue])
secondsValuemsValueThe number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If you do not specify the msValue parameter, the value returned from the getUTCMilliseconds() method is used.
If a parameter you specify is outside of the expected range, setUTCSeconds() attempts to update the date information in the Date object accordingly. For example, if you use 100 for secondsValue, the minutes stored in the Date object will be incremented by 1, and 40 will be used for seconds.
setUTCSeconds()\nvar theBigDay = new Date();\ntheBigDay.setUTCSeconds(20);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setUTCSeconds' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setUTCSeconds' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setUTCSeconds' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds\n
The setUTCMonth() method sets the month for a specified date according to universal time.
dateObj.setUTCMonth(monthValue[, dayValue])
monthValuedayValueThe number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If you do not specify the dayValue parameter, the value returned from the getUTCDate() method is used.
If a parameter you specify is outside of the expected range, setUTCMonth() attempts to update the date information in the Date object accordingly. For example, if you use 15 for monthValue, the year will be incremented by 1, and 3 will be used for month.
setUTCMonth()\nvar theBigDay = new Date();\ntheBigDay.setUTCMonth(11);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setUTCMonth' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setUTCMonth' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setUTCMonth' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth\n
The setUTCDate() method sets the day of the month for a specified date according to universal time.
dateObj.setUTCDate(dayValue)
dayValueThe number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If a parameter you specify is outside of the expected range, setUTCDate() attempts to update the date information in the Date object accordingly. For example, if you use 40 for dayValue, and the month stored in the Date object is June, the day will be changed to 10 and the month will be incremented to July.
setUTCDate()\nvar theBigDay = new Date();\ntheBigDay.setUTCDate(20);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setUTCDate' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setUTCDate' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setUTCDate' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCDate\n
The toDateString() method returns the date portion of a Date object in human readable form in American English.
dateObj.toDateString()
A string representing the date portion of the given Date object in human readable form in American English.
Date instances refer to a specific point in time. Calling toString() will return the date formatted in a human readable form in American English. In SpiderMonkey, this consists of the date portion (day, month, and year) followed by the time portion (hours, minutes, seconds, and time zone). Sometimes it is desirable to obtain a string of the time portion; such a thing can be accomplished with the toTimeString() method.
The toDateString() method is especially useful because compliant engines implementing ECMA-262 may differ in the string obtained from toString() for Date objects, as the format is implementation-dependent and simple string slicing approaches may not produce consistent results across multiple engines.
toDateString()\nvar d = new Date(1993, 5, 28, 14, 39, 7);\n\nconsole.log(d.toString()); // logs Wed Jun 28 1993 14:39:07 GMT-0600 (PDT)\nconsole.log(d.toDateString()); // logs Wed Jun 28 1993\n
Note: Month are 0-indexed when used as an argument of Date (thus 0 corresponds to January and 11 to December).
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toDateString\n
The toString() method returns a string representing the specified Date object.
dateObj.toString()
A string representing the given date.
Date instances inherit their toString() method from Date.prototype, not Object.prototype. Date.prototype.toString() returns a string representation of the Date in the format specified in ECMA-262 which can be summarised as:
E.g. \"Sat Sep 01 2018 14:53:26 GMT+1400 (LINT)\"
Until ECMAScript 2018 (edition 9), the format of the string returned by Date.prototype.toString was implementation dependent. Therefore it should not be relied upon to be in the specified format.
The toString() method is automatically called when a date is to be represented as a text value, e.g. console.log(new Date()), or when a date is used in a string concatenation, such as var today = 'Today is ' + new Date().
toString() is a generic method, it does not require that its this is a Date instance. However, it must have an internal [[TimeValue]] property that can't be constructed using native javascript, so it's effectively limited to use with Date instances. If called on a non–Date instance, a TypeError is thrown.
toString()\nThe following assigns the toString() value of a Date object to myVar:
var x = new Date();\nvar myVar = x.toString(); // assigns a string value to myVar in the same format as:\n // Mon Sep 08 1998 14:36:22 GMT-0700 (PDT)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.toLocaleTimeString' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.toString' in that specification. | Standard | |
| Unknown The definition of 'Date.prototype.toString' in that specification. | Unknown | Format of Date.prototype.toString is standardised. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Object.prototype.toString()Date.prototype.toDateString()Date.prototype.toLocaleString()Date.prototype.toTimeString()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toString\n
The setUTCMinutes() method sets the minutes for a specified date according to universal time.
dateObj.setUTCMinutes(minutesValue[, secondsValue[, msValue]])
minutesValuesecondsValuesecondsValue parameter, you must also specify the minutesValue.msValuemsValue parameter, you must also specify the minutesValue and secondsValue.The number of milliseconds between 1 January 1970 00:00:00 UTC and the updated date.
If you do not specify the secondsValue and msValue parameters, the values returned from getUTCSeconds() and getUTCMilliseconds() methods are used.
If a parameter you specify is outside of the expected range, setUTCMinutes() attempts to update the date information in the Date object accordingly. For example, if you use 100 for secondsValue, the minutes will be incremented by 1 (minutesValue + 1), and 40 will be used for seconds.
setUTCMinutes()\nvar theBigDay = new Date();\ntheBigDay.setUTCMinutes(43);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.setUTCMinutes' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.setUTCMinutes' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.setUTCMinutes' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes\n
The Math.E property represents the base of natural logarithms, e, approximately 2.718.
Property attributes of Math.E\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Because E is a static property of Math, you always use it as Math.E, rather than as a property of a Math object you created (Math is not a constructor).
Math.E\nThe following function returns e:
function getNapier() {\n return Math.E;\n}\n\ngetNapier(); // 2.718281828459045\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.E' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.E' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.E' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/E\n
The Math.LN10 property represents the natural logarithm of 10, approximately 2.302:
Property attributes of Math.LN10\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Because LN10 is a static property of Math, you always use it as Math.LN10, rather than as a property of a Math object you created (Math is not a constructor).
Math.LN10\nThe following function returns the natural log of 10:
function getNatLog10() {\n return Math.LN10;\n}\n\ngetNatLog10(); // 2.302585092994046\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.LN10' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.LN10' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.LN10' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LN10\n
The toTimeString() method returns the time portion of a Date object in human readable form in American English.
dateObj.toTimeString()
A string representing the time portion of the given date in human readable form in American English.
Date instances refer to a specific point in time. Calling toString() will return the date formatted in a human readable form in American English. In SpiderMonkey, this consists of the date portion (day, month, and year) followed by the time portion (hours, minutes, seconds, and time zone). Sometimes it is desirable to obtain a string of the time portion; such a thing can be accomplished with the toTimeString() method.
The toTimeString() method is especially useful because compliant engines implementing ECMA-262 may differ in the string obtained from toString() for Date objects, as the format is implementation-dependent; simple string slicing approaches may not produce consistent results across multiple engines.
toTimeString()\nvar d = new Date(1993, 6, 28, 14, 39, 7);\n\nconsole.log(d.toString()); // Wed Jul 28 1993 14:39:07 GMT-0600 (PDT)\nconsole.log(d.toTimeString()); // 14:39:07 GMT-0600 (PDT)\n
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toTimeString\n
The toISOString() method returns a string in simplified extended ISO format (ISO 8601), which is always 24 or 27 characters long (YYYY-MM-DDTHH:mm:ss.sssZ or ±YYYYYY-MM-DDTHH:mm:ss.sssZ, respectively). The timezone is always zero UTC offset, as denoted by the suffix \"Z\".
dateObj.toISOString()
A string representing the given date in the ISO 8601 format according to universal time.
toISOString()\nvar today = new Date('05 October 2011 14:48 UTC');\n\nconsole.log(today.toISOString()); // Returns 2011-10-05T14:48:00.000Z\n The above example uses parsing of a non–standard string value that may not be correctly parsed in non–Mozilla browsers.
This method was standardized in ECMA-262 5th edition. Engines which have not been updated to support this method can work around the absence of this method using the following shim:
if (!Date.prototype.toISOString) {\n (function() {\n\n function pad(number) {\n if (number < 10) {\n return '0' + number;\n }\n return number;\n }\n\n Date.prototype.toISOString = function() {\n return this.getUTCFullYear() +\n '-' + pad(this.getUTCMonth() + 1) +\n '-' + pad(this.getUTCDate()) +\n 'T' + pad(this.getUTCHours()) +\n ':' + pad(this.getUTCMinutes()) +\n ':' + pad(this.getUTCSeconds()) +\n '.' + (this.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) +\n 'Z';\n };\n\n }());\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.toISOString' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.toISOString' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.toISOString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n9 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString\n
The Math.floor() function returns the largest integer less than or equal to a given number.
Math.floor(x)
xA number representing the largest integer less than or equal to the specified number.
Because floor() is a static method of Math, you always use it as Math.floor(), rather than as a method of a Math object you created (Math is not a constructor).
Math.floor()\nMath.floor( 45.95); // 45\nMath.floor( 45.05); // 45\nMath.floor( 4 ); // 4\nMath.floor(-45.05); // -46 \nMath.floor(-45.95); // -46\n
// Closure\n(function() {\n /**\n * Decimal adjustment of a number.\n *\n * @param {String} type The type of adjustment.\n * @param {Number} value The number.\n * @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).\n * @returns {Number} The adjusted value.\n */\n function decimalAdjust(type, value, exp) {\n // If the exp is undefined or zero...\n if (typeof exp === 'undefined' || +exp === 0) {\n return Math[type](value);\n }\n value = +value;\n exp = +exp;\n // If the value is not a number or the exp is not an integer...\n if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {\n return NaN;\n }\n // Shift\n value = value.toString().split('e');\n value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));\n // Shift back\n value = value.toString().split('e');\n return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));\n }\n\n // Decimal round\n if (!Math.round10) {\n Math.round10 = function(value, exp) {\n return decimalAdjust('round', value, exp);\n };\n }\n // Decimal floor\n if (!Math.floor10) {\n Math.floor10 = function(value, exp) {\n return decimalAdjust('floor', value, exp);\n };\n }\n // Decimal ceil\n if (!Math.ceil10) {\n Math.ceil10 = function(value, exp) {\n return decimalAdjust('ceil', value, exp);\n };\n }\n})();\n\n// Round\nMath.round10(55.55, -1); // 55.6\nMath.round10(55.549, -1); // 55.5\nMath.round10(55, 1); // 60\nMath.round10(54.9, 1); // 50\nMath.round10(-55.55, -1); // -55.5\nMath.round10(-55.551, -1); // -55.6\nMath.round10(-55, 1); // -50\nMath.round10(-55.1, 1); // -60\n// Floor\nMath.floor10(55.59, -1); // 55.5\nMath.floor10(59, 1); // 50\nMath.floor10(-55.51, -1); // -55.6\nMath.floor10(-51, 1); // -60\n// Ceil\nMath.ceil10(55.51, -1); // 55.6\nMath.ceil10(51, 1); // 60\nMath.ceil10(-55.59, -1); // -55.5\nMath.ceil10(-59, 1); // -50\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.floor' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.floor' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.floor' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor\n
The toUTCString() method converts a date to a string, using the UTC time zone.
dateObj.toUTCString()
A string representing the given date using the UTC time zone.
The value returned by toUTCString() is a string in the same format as Date.prototype.toString() but with a zero timezone offset (UTC).
Prior to ECMAScript 2018, the format of the return value varied according to the platform. The most common return value was an RFC-1123 formatted date stamp, which is a slightly updated version of RFC-822 date stamps.
toUTCString()\nvar today = new Date('Wed, 14 Jun 2017 00:00:00 PDT');\nvar UTCstring = today.toUTCString(); // Wed, 14 Jun 2017 07:00:00 GMT\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.3. Format is implementation dependent. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.toUTCString' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.toUTCString' in that specification. | Standard | |
| ECMAScript 2018 (ECMA-262) The definition of 'Date.prototype.toUTCString' in that specification. | Standard | First standardisation of the format. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.toUTCString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString\n
The valueOf() method returns the primitive value of a Date object.
dateObj.valueOf()
The number of milliseconds between 1 January 1970 00:00:00 UTC and the given date.
The valueOf() method returns the primitive value of a Date object as a number data type, the number of milliseconds since midnight 01 January, 1970 UTC.
This method is functionally equivalent to the Date.prototype.getTime() method.
This method is usually called internally by JavaScript and not explicitly in code.
valueOf()\nvar x = new Date(56, 6, 17);\nvar myVar = x.valueOf(); // assigns -424713600000 to myVar\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Date.prototype.valueOf' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.valueOf' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.valueOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/valueOf\n
The [@@toPrimitive]() method converts a Date object to a primitive value.
Date()[Symbol.toPrimitive](hint);\n
The primitive value of the given Date object. Depending on the argument, the method can return either a string or a number.
The [@@toPrimitive]() method of the Date object returns a primitive value, that is either of type number or of type string.
If hint is \"string\" or \"default\", [@@toPrimitive]() tries to call the toString method. If the toString property does not exist, it tries to call the valueOf method and if the valueOf does not exist either, [@@toPrimitive]() throws a TypeError.
If hint is \"number\", [@@toPrimitive]() first tries to call valueOf, and if that fails, it calls toString.
JavaScript calls the [@@toPrimitive]() method to convert an object to a primitive value. You rarely need to invoke the [@@toPrimitive]() method yourself; JavaScript automatically invokes it when encountering an object where a primitive value is expected.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Date.prototype.@@toPrimitive' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Date.prototype.@@toPrimitive' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n? | \n? | \n44 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n6.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive\n
The Math.round() function returns the value of a number rounded to the nearest integer.
Math.round(x)
xThe value of the given number rounded to the nearest integer.
If the fractional portion of the argument is greater than 0.5, the argument is rounded to the integer with the next higher absolute value. If it is less than 0.5, the argument is rounded to the integer with the lower absolute value. If the fractional portion is exactly 0.5, the argument is rounded to the next integer in the direction of +∞. Note that this differs from many languages' round() functions, which often round this case to the next integer away from zero, instead giving a different result in the case of negative numbers with a fractional part of exactly 0.5.
Because round() is a static method of Math, you always use it as Math.round(), rather than as a method of a Math object you created (Math has no constructor).
Math.round( 20.49); // 20\nMath.round( 20.5 ); // 21\nMath.round( 42 ); // 42\nMath.round(-20.5 ); // -20\nMath.round(-20.51); // -21\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.round' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.round' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.round' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round\n
The Math.LOG2E property represents the base 2 logarithm of e, approximately 1.442:
Property attributes of Math.LOG2E\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Because LOG2E is a static property of Math, you always use it as Math.LOG2E, rather than as a property of a Math object you created (Math is not a constructor).
Math.LOG2E\nThe following function returns the base 2 logarithm of e:
function getLog2e() {\n return Math.LOG2E;\n}\n\ngetLog2e(); // 1.4426950408889634\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.LOG2E' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.LOG2E' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.LOG2E' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LOG2E\n
The Math.LN2 property represents the natural logarithm of 2, approximately 0.693:
Property attributes of Math.LN2\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Because LN2 is a static property of Math, you always use it as Math.LN2, rather than as a property of a Math object you created (Math is not a constructor).
Math.LN2\nThe following function returns the natural log of 2:
function getNatLog2() {\n return Math.LN2;\n}\n\ngetNatLog2(); // 0.6931471805599453\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.LN2' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.LN2' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.LN2' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LN2\n
The Math.LOG10E property represents the base 10 logarithm of e, approximately 0.434:
Property attributes of Math.LOG10E\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Because LOG10E is a static property of Math, you always use it as Math.LOG10E, rather than as a property of a Math object you created (Math is not a constructor).
Math.LOG10E\nThe following function returns the base 10 logarithm of e:
function getLog10e() {\n return Math.LOG10E;\n}\n\ngetLog10e(); // 0.4342944819032518\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.LOG10E' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.LOG10E' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.LOG10E' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/LOG10E\n
The Math.PI property represents the ratio of the circumference of a circle to its diameter, approximately 3.14159:
Property attributes of Math.PI\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Because PI is a static property of Math, you always use it as Math.PI, rather than as a property of a Math object you created (Math is not a constructor).
Math.PI\nThe following function uses Math.PI to calculate the circumference of a circle with a passed radius.
function calculateCircumference(radius) {\n return Math.PI * (radius + radius);\n}\n\ncalculateCircumference(1); // 6.283185307179586\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.PI' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.PI' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.PI' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/PI\n
The Math.SQRT1_2 property represents the square root of 1/2 which is approximately 0.707:
Property attributes of Math.SQRT1_2\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Because SQRT1_2 is a static property of Math, you always use it as Math.SQRT1_2, rather than as a property of a Math object you created (Math is not a constructor).
Math.SQRT1_2\nThe following function returns 1 over the square root of 2:
function getRoot1_2() {\n return Math.SQRT1_2;\n}\n\ngetRoot1_2(); // 0.7071067811865476\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.SQRT1_2' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.SQRT1_2' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.SQRT1_2' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2\n
The Math.SQRT2 property represents the square root of 2, approximately 1.414:
Property attributes of Math.SQRT2\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Because SQRT2 is a static property of Math, you always use it as Math.SQRT2, rather than as a property of a Math object you created (Math is not a constructor).
Math.SQRT2\nThe following function returns the square root of 2:
function getRoot2() {\n return Math.SQRT2;\n}\n\ngetRoot2(); // 1.4142135623730951\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.SQRT2' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.SQRT2' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.SQRT2' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/SQRT2\n
The Math.acos() function returns the arccosine (in radians) of a number, that is
Math.acos(x)
xThe arccosine (in radians) of the given number if it's between -1 and 1; otherwise, NaN.
The Math.acos() method returns a numeric value between 0 and π radians for x between -1 and 1. If the value of x is outside this range, it returns NaN.
Because acos() is a static method of Math, you always use it as Math.acos(), rather than as a method of a Math object you created (Math is not a constructor).
Math.acos()\nMath.acos(-2); // NaN\nMath.acos(-1); // 3.141592653589793\nMath.acos(0); // 1.5707963267948966\nMath.acos(0.5); // 1.0471975511965979\nMath.acos(1); // 0\nMath.acos(2); // NaN\n
For values less than -1 or greater than 1, Math.acos() returns NaN.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.acos' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.acos' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.acos' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acos\n
The Math.acosh() function returns the hyperbolic arc-cosine of a number, that is
Math.acosh(x)
The hyperbolic arc-cosine of the given number. If the number is less than 1, NaN.
Because acosh() is a static method of Math, you always use it as Math.acosh(), rather than as a method of a Math object you created (Math is no constructor).
Math.acosh()\nMath.acosh(-1); // NaN\nMath.acosh(0); // NaN\nMath.acosh(0.5); // NaN\nMath.acosh(1); // 0\nMath.acosh(2); // 1.3169578969248166\n
For values less than 1 Math.acosh() returns NaN.
For all , we have and so this can be emulated with the following function:
Math.acosh = Math.acosh || function(x) {\n return Math.log(x + Math.sqrt(x * x - 1));\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.acosh' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.acosh' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh\n
The Math.abs() function returns the absolute value of a number, that is
Math.abs(x)
xThe absolute value of the given number.
Because abs() is a static method of Math, you always use it as Math.abs(), rather than as a method of a Math object you created (Math is not a constructor).
Math.abs()\nPassing an empty object, an array with more than one member, a non-numeric string or undefined/empty variable returns NaN. Passing null, an empty string or an empty array returns 0.
Math.abs('-1'); // 1\nMath.abs(-2); // 2\nMath.abs(null); // 0\nMath.abs(''); // 0\nMath.abs([]); // 0\nMath.abs([2]); // 2\nMath.abs([1,2]); // NaN\nMath.abs({}); // NaN\nMath.abs('string'); // NaN\nMath.abs(); // NaN\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.abs' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.abs' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.abs' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/abs\n
The Math.asinh() function returns the hyperbolic arcsine of a number, that is
Math.asinh(x)
The hyperbolic arcsine of the given number.
Because asinh() is a static method of Math, you always use it as Math.asinh(), rather than as a method of a Math object you created (Math is not a constructor).
Math.asinh()\nMath.asinh(1); // 0.881373587019543\nMath.asinh(0); // 0\n
As a quick and dirty hack the expression may be used directly for a coarse emulation by the following function:
Math.asinh = Math.asinh || function(x) {\n if (x === -Infinity) {\n return x;\n } else {\n return Math.log(x + Math.sqrt(x * x + 1));\n }\n};\n Been formally correct it suffers from a number of issues related to floating point computations. Accurate result requires special handling of positive/negative, small/large arguments as it done e.g. in glibc or GNU Scientific Library.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.asinh' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.asinh' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh\n
The Math.cbrt() function returns the cube root of a number, that is
Math.cbrt(x)
The cube root of the given number.
Because cbrt() is a static method of Math, you always use it as Math.cbrt(), rather than as a method of a Math object you created (Math is not a constructor).
Math.cbrt()\nMath.cbrt(NaN); // NaN\nMath.cbrt(-1); // -1\nMath.cbrt(-0); // -0\nMath.cbrt(-Infinity); // -Infinity\nMath.cbrt(0); // 0\nMath.cbrt(1); // 1\nMath.cbrt(Infinity); // Infinity\nMath.cbrt(null); // 0\nMath.cbrt(2); // 1.2599210498948732\n
For all , have so this can be emulated by the following function:
if (!Math.cbrt) {\n Math.cbrt = (function(pow) {\n return function cbrt(){\n // ensure negative numbers remain negative:\n return x < 0 ? -pow(-x, 1/3) : pow(x, 1/3);\n };\n })(Math.pow); // localize Math.pow to increase efficiency\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.cbrt' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.cbrt' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cbrt\n
The Math.ceil() function returns the smallest integer greater than or equal to a given number.
Math.ceil(x)
xThe smallest integer greater than or equal to the given number.
Because ceil() is a static method of Math, you always use it as Math.ceil(), rather than as a method of a Math object you created (Math is not a constructor).
Math.ceil()\nThe following example shows example usage of Math.ceil().
Math.ceil(.95); // 1\nMath.ceil(4); // 4\nMath.ceil(7.004); // 8\nMath.ceil(-0.95); // -0\nMath.ceil(-4); // -4\nMath.ceil(-7.004); // -7\n
// Closure\n(function() {\n /**\n * Decimal adjustment of a number.\n *\n * @param {String} type The type of adjustment.\n * @param {Number} value The number.\n * @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).\n * @returns {Number} The adjusted value.\n */\n function decimalAdjust(type, value, exp) {\n // If the exp is undefined or zero...\n if (typeof exp === 'undefined' || +exp === 0) {\n return Math[type](value);\n }\n value = +value;\n exp = +exp;\n // If the value is not a number or the exp is not an integer...\n if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {\n return NaN;\n }\n // Shift\n value = value.toString().split('e');\n value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));\n // Shift back\n value = value.toString().split('e');\n return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));\n }\n\n // Decimal round\n if (!Math.round10) {\n Math.round10 = function(value, exp) {\n return decimalAdjust('round', value, exp);\n };\n }\n // Decimal floor\n if (!Math.floor10) {\n Math.floor10 = function(value, exp) {\n return decimalAdjust('floor', value, exp);\n };\n }\n // Decimal ceil\n if (!Math.ceil10) {\n Math.ceil10 = function(value, exp) {\n return decimalAdjust('ceil', value, exp);\n };\n }\n})();\n\n// Round\nMath.round10(55.55, -1); // 55.6\nMath.round10(55.549, -1); // 55.5\nMath.round10(55, 1); // 60\nMath.round10(54.9, 1); // 50\nMath.round10(-55.55, -1); // -55.5\nMath.round10(-55.551, -1); // -55.6\nMath.round10(-55, 1); // -50\nMath.round10(-55.1, 1); // -60\n// Floor\nMath.floor10(55.59, -1); // 55.5\nMath.floor10(59, 1); // 50\nMath.floor10(-55.51, -1); // -55.6\nMath.floor10(-51, 1); // -60\n// Ceil\nMath.ceil10(55.51, -1); // 55.6\nMath.ceil10(51, 1); // 60\nMath.ceil10(-55.59, -1); // -55.5\nMath.ceil10(-59, 1); // -50\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.ceil' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.ceil' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.ceil' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil\n
The Math.atan2() function returns the angle in the plane (in radians) between the positive x-axis and the ray from (0,0) to the point (x,y), for Math.atan2(y,x).
Math.atan2(y, x)
yxThe angle in radians (in ) between the positive x-axis and the ray from (0,0) to the point
The Math.atan2() method returns a numeric value between -π and π representing the angle theta of an (x, y) point. This is the counterclockwise angle, measured in radians, between the positive X axis, and the point (x, y). Note that the arguments to this function pass the y-coordinate first and the x-coordinate second.
Math.atan2() is passed separate x and y arguments, and Math.atan() is passed the ratio of those two arguments.
Because atan2() is a static method of Math, you always use it as Math.atan2(), rather than as a method of a Math object you created (Math is not a constructor).
Math.atan2()\nMath.atan2(90, 15); // 1.4056476493802699\nMath.atan2(15, 90); // 0.16514867741462683\n\nMath.atan2(±0, -0); // ±PI.\nMath.atan2(±0, +0); // ±0.\nMath.atan2(±0, -x); // ±PI for x > 0.\nMath.atan2(±0, x); // ±0 for x > 0.\nMath.atan2(-y, ±0); // -PI/2 for y > 0.\nMath.atan2(y, ±0); // PI/2 for y > 0.\nMath.atan2(±y, -Infinity); // ±PI for finite y > 0.\nMath.atan2(±y, +Infinity); // ±0 for finite y > 0.\nMath.atan2(±Infinity, x); // ±PI/2 for finite x.\nMath.atan2(±Infinity, -Infinity); // ±3*PI/4.\nMath.atan2(±Infinity, +Infinity); // ±PI/4.\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.atan2' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.atan2' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.atan2' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2\n
The Math.atanh() function returns the hyperbolic arctangent of a number, that is
Math.atanh(x)
The hyperbolic arctangent of the given number.
Because atanh() is a static method of Math, you always use it as Math.atanh(), rather than as a method of a Math object you created (Math is not a constructor).
Math.atanh()\nMath.atanh(-2); // NaN\nMath.atanh(-1); // -Infinity\nMath.atanh(0); // 0\nMath.atanh(0.5); // 0.5493061443340548\nMath.atanh(1); // Infinity\nMath.atanh(2); // NaN\n
For values greater than 1 or less than -1, NaN is returned.
For , we have so this can be emulated by the following function:
Math.atanh = Math.atanh || function(x) {\n return Math.log((1+x)/(1-x)) / 2;\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.atanh' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.atanh' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh\n
The Math.asin() function returns the arcsine (in radians) of a number, that is
Math.asin(x)
xThe arcsine (in radians) of the given number if it's between -1 and 1; otherwise, NaN.
The Math.asin() method returns a numeric value between and radians for x between -1 and 1. If the value of x is outside this range, it returns NaN.
Because asin() is a static method of Math, you always use it as Math.asin(), rather than as a method of a Math object you created (Math is not a constructor).
Math.asin()\nMath.asin(-2); // NaN\nMath.asin(-1); // -1.5707963267948966 (-pi/2)\nMath.asin(0); // 0\nMath.asin(0.5); // 0.5235987755982989\nMath.asin(1); // 1.5707963267948966 (pi/2)\nMath.asin(2); // NaN\n
For values less than -1 or greater than 1, Math.asin() returns NaN.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.asin' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.asin' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.asin' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asin\n
The Math.imul() function returns the result of the C-like 32-bit multiplication of the two parameters.
var product = Math.imul(a, b);
abThe result of the C-like 32-bit multiplication of the given arguments.
Math.imul() allows for 32-bit integer multiplication with C-like semantics. This feature is useful for projects like Emscripten. Because imul() is a static method of Math, you always use it as Math.imul(), rather than as a method of a Math object you created (Math is not a constructor). If you use normal JavaScript floating point numbers in imul, you will experience a degrade in performance. This is because of the costly conversion from a floating point to an integer for multiplication, and then converting the multiplied integer back into a floating point. The reason imul exists is because it is faster in only one (so far) circumstance: AsmJS. AsmJS allows for JIST-optimizers to more easily implement internal integers in JavaScript. Multiplying two numbers stored internally as integers (which is only possible with AsmJS) with imul is the only potential circumstance where Math.imul may prove performant in current browsers.
Math.imul()\nMath.imul(2, 4); // 8\nMath.imul(-1, 8); // -8\nMath.imul(-2, -2); // 4\nMath.imul(0xffffffff, 5); // -5\nMath.imul(0xfffffffe, 5); // -10\n
This can be emulated with the following function:
if (!Math.imul) Math.imul = function(a, b) {\n var aHi = (a >>> 16) & 0xffff;\n var aLo = a & 0xffff;\n var bHi = (b >>> 16) & 0xffff;\n var bLo = b & 0xffff;\n // the shift by 0 fixes the sign on the high part\n // the final |0 converts the unsigned value into a signed value\n return ((aLo * bLo) + (((aHi * bLo + aLo * bHi) << 16) >>> 0) | 0);\n}; However, the following function is more performant because it is likely that browsers in which this polyfill would be used do not optimize with an internal integer type in javascript, instead using floating points for all numbers.
if (!Math.imul) Math.imul = function(opA, opB) {\n opB |= 0; // ensure that opB is an integer. opA will automatically be coerced.\n // floating points give us 53 bits of precision to work with plus 1 sign bit\n // automatically handled for our convienence:\n // 1. 0x003fffff /*opA & 0x000fffff*/ * 0x7fffffff /*opB*/ = 0x1fffff7fc00001\n // 0x1fffff7fc00001 < Number.MAX_SAFE_INTEGER /*0x1fffffffffffff*/\n var result = (opA & 0x001fffff) * opB;\n // 2. We can remove an integer coersion from the statement above because:\n // 0x1fffff7fc00001 + 0xffc00000 = 0x1fffffff800001\n // 0x1fffffff800001 < Number.MAX_SAFE_INTEGER /*0x1fffffffffffff*/\n if (opA & 0xffc00000 /*!== 0*/) result += (opA & 0xffc00000) * opB |0;\n return result |0;\n}; | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.imul' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.imul' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n28 | \nYes | \n20 | \nNo | \n16 | \n7 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n20 | \nYes | \n7 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul\n
The Math.log1p() function returns the natural logarithm (base e) of 1 + a number, that is
Math.log1p(x)
xThe natural logarithm (base e) of 1 plus the given number. If the number is less than -1, NaN is returned.
For very small values of x, adding 1 can reduce or eliminate precision. The double floats used in JS give you about 15 digits of precision. 1 + 1e-15 = 1.000000000000001, but 1 + 1e-16 = 1.000000000000000 and therefore exactly 1.0 in that arithmetic, because digits past 15 are rounded off.
When you calculate log(1 + x), you should get an answer very close to x, if x is small (that's why these are called 'natural' logarithms). If you calculate Math.log(1 + 1.1111111111e-15) you should get an answer close to 1.1111111111e-15. Instead, you will end up taking the logarithm of 1.00000000000000111022 (the roundoff is in binary so sometimes it gets ugly), so you get the answer 1.11022...e-15, with only 3 correct digits. If, instead, you calculate Math.log1p(1.1111111111e-15) you will get a much more accurate answer 1.1111111110999995e-15 with 15 correct digits of precision (actually 16 in this case).
If the value of x is less than -1, the return value is always NaN.
Because log1p() is a static method of Math, you always use it as Math.log1p(), rather than as a method of a Math object you created (Math is not a constructor).
Math.log1p()\nMath.log1p(1); // 0.6931471805599453\nMath.log1p(0); // 0\nMath.log1p(-1); // -Infinity\nMath.log1p(-2); // NaN\n
This can be emulated with the following function:
Math.log1p = Math.log1p || function(x) {\n return Math.log(1 + x);\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.log1p' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.log1p' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p\n
The Math.atan() function returns the arctangent (in radians) of a number, that is
Math.atan(x)
xThe arctangent (in radians) of the given number.
The Math.atan() method returns a numeric value between and radians.
Because atan() is a static method of Math, you always use it as Math.atan(), rather than as a method of a Math object you created (Math is not a constructor).
Math.atan()\nMath.atan(1); // 0.7853981633974483\nMath.atan(0); // 0\nMath.atan(-0); // -0\n\nMath.atan(Infinity); // 1.5707963267948966\nMath.atan(-Infinity); // -1.5707963267948966\n\n// The angle that the line [(0,0);(x,y)] forms with the x-axis in a Cartesian coordinate system\nMath.atan(y / x);\n Note that you may want to avoid using ±Infinity for stylistic reasons. In this case, Math.atan2() with 0 as the second argument may be a better solution.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.atan' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.atan' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.atan' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan\n
The Math.exp() function returns ex, where x is the argument, and e is Euler's number (also known as Napier's constant), the base of the natural logarithms.
Math.exp(x)
xA number representing ex, where e is Euler's number and x is the argument.
Because exp() is a static method of Math, you always use it as Math.exp(), rather than as a method of a Math object you created (Math is not a constructor).
Math.exp()\nMath.exp(-1); // 0.36787944117144233\nMath.exp(0); // 1\nMath.exp(1); // 2.718281828459045\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.exp' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.exp' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.exp' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/exp\n
The Math.expm1() function returns ex - 1, where x is the argument, and e the base of the natural logarithms.
Math.expm1(x)
xA number representing ex - 1, where e is Euler's number and x is the argument.
Because expm1() is a static method of Math, you always use it as Math.expm1(), rather than as a method of a Math object you created (Math is not a constructor).
Math.expm1()\nMath.expm1(-1); // -0.6321205588285577 \nMath.expm1(0); // 0\nMath.expm1(1); // 1.718281828459045\n
This can be emulated with the help of the Math.exp() function:
Math.expm1 = Math.expm1 || function(x) {\n return Math.exp(x) - 1;\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.expm1' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.expm1' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/expm1\n
The Math.clz32() function returns the number of leading zero bits in the 32-bit binary representation of a number.
Math.clz32(x)
The number of leading zero bits in the 32-bit binary representation of the given number.
\"clz32\" is short for CountLeadingZeroes32.
If x is not a number, then it will be converted to a number first, then converted to a 32-bit unsigned integer.
If the converted 32-bit unsigned integer is 0, then return 32, because all bits are 0.
This function is particularly useful for systems that compile to JS, like Emscripten.
Math.clz32()\nMath.clz32(1); // 31\nMath.clz32(1000); // 22\nMath.clz32(); // 32\n\n[NaN, Infinity, -Infinity, 0, -0, null, undefined, 'foo', {}, []].filter(\nfunction(n) {\n return Math.clz32(n) !== 32\n}); // []\n\nMath.clz32(true); // 31\nMath.clz32(3.5); // 30 At present, there is no Math.clon for \"Count Leading Ones\" (named \"clon\", not \"clo\", because \"clo\" and \"clz\" are too similar especially for non-english-speaking people). However, a CLON function can easily be created by inversing the bits of a number and passing the result to `Math.clz` which will work because the inverse of 1 is 0 and vice-versa. Thus, inversing the bits will inverse the measured quanity 0 (of Math.clz), thereby making Math.clz count the number of ones instead of the number of zeros.
var clz = Math.clz32;\nfunction clon(integer){\n return clz(~integer);\n}\n Further, this teqnique could be extended to creating jumpless \"Count Trailing Zeros\" and \"Count Trailing Ones\" functions as seen below. The ctrz function below fills in all the high bits with the lowest filled bit, then negates the bits to earase all higher set bits so that clz can then be used.
var clz = Math.clz32;\nfunction ctrz(integer){ // count trailing zeros\n // 1. fill in all the higher bits after the first one\n integer |= integer << 16;\n integer |= integer << 8;\n integer |= integer << 4;\n integer |= integer << 2;\n integer |= integer << 1;\n // 2. Now, inversing the bits reveals the lowest bits\n return 32 - clz(~integer);\n}\nfunction ctron(integer){ // count trailing ones\n // No shift-filling-in-with-ones operator is available in\n // javascript, so the below code is the fastest\n return ctrz(~integer);\n /* Alternate implementation for demonstrational purposes:\n // 1. erase all the higher bits after the first zero\n integer &= (integer << 16) | 0xffff;\n integer &= (integer << 8 ) | 0x00ff;\n integer &= (integer << 4 ) | 0x000f;\n integer &= (integer << 2 ) | 0x0003;\n integer &= (integer << 1 ) | 0x0001;\n // 2. Now, inversing the bits reveals the lowest zeros\n return 32 - clon(~integer);\n */\n}\n Make these helper functions into ASM.JS module; then, you have a true performance masterpiece. Situations like these are exactly what ASM.JS was designed for.
var countTrailsMethods = (function(stdlib, foreign, heap) {\n \"use asm\";\n var clz = stdlib.Math.clz32;\n function ctrz(integer) { // count trailing zeros\n integer = integer | 0; // coerce to an integer\n // 1. fill in all the higher bits after the first one\n // ASM.js for some reason does not allow *=,/=,+=,etc.\n integer = integer | (integer << 16);\n integer = integer | (integer << 8);\n integer = integer | (integer << 4);\n integer = integer | (integer << 2);\n integer = integer | (integer << 1);\n // 2. Now, inversing the bits reveals the lowest bits\n return 32 - clz(~integer) |0;\n }\n function ctron(integer) { // count trailing ones\n integer = integer | 0; // coerce to an integer\n return ctrz(~integer) |0;\n }\n // unfourtunately, ASM.JS demands slow crummy objects:\n return {a: ctrz, b: ctron};\n})(window, null, null);\nvar ctrz = countTrailsMethods.a;\nvar ctron = countTrailsMethods.b;\n The following polyfill is the most efficient.
if (!Math.clz32) Math.clz32 = (function(log, LN2){\n return function(x) {\n // Let n be ToUint32(x).\n // Let p be the number of leading zero bits in \n // the 32-bit binary representation of n.\n // Return p. \n if (x == null || x === 0) {\n return 32;\n }\n return 31 - log(x >>> 0) / LN2 | 0; // the \"| 0\" acts like math.floor\n };\n})(Math.log, Math.LN2);\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.clz32' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.clz32' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n31 | \nNo | \n25 | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n31 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32\n
The Math.sign() function returns the sign of a number, indicating whether the number is positive, negative or zero.
Math.sign(x)
xA number representing the sign of the given argument. If the argument is a positive number, negative number, positive zero or negative zero, the function will return 1, -1, 0 or -0 respectively. Otherwise, NaN is returned.
Because sign() is a static method of Math, you always use it as Math.sign(), rather than as a method of a Math object you created (Math is not a constructor).
This function has 5 kinds of return values, 1, -1, 0, -0, NaN, which represent \"positive number\", \"negative number\", \"positive zero\", \"negative zero\" and NaN respectively.
The argument passed to this function will be converted to number type implicitly.
Math.sign()\nMath.sign(3); // 1\nMath.sign(-3); // -1\nMath.sign('-3'); // -1\nMath.sign(0); // 0\nMath.sign(-0); // -0\nMath.sign(NaN); // NaN\nMath.sign('foo'); // NaN\nMath.sign(); // NaN\n if (!Math.sign) {\n Math.sign = function(x) {\n // If x is NaN, the result is NaN.\n // If x is -0, the result is -0.\n // If x is +0, the result is +0.\n // If x is negative and not -0, the result is -1.\n // If x is positive and not +0, the result is +1.\n return ((x > 0) - (x < 0)) || +x;\n // A more aesthetical persuado-representation is shown below\n //\n // ( (x > 0) ? 0 : 1 ) // if x is negative then negative one\n // + // else (because you cant be both - and +)\n // ( (x < 0) ? 0 : -1 ) // if x is positive then positive one\n // || // if x is 0, -0, or NaN, or not a number,\n // +x // Then the result will be x, (or) if x is\n // // not a number, then x converts to number\n };\n}\n In the above polyfill, no extra type-coercing is needed to make (x > 0) or (x < 0) numbers because subtracting them from each other forces a type conversion from boolean to numbers.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.sign' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.sign' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign\n
The Math.cos() static function returns the cosine of the specified angle, which must be specified in radians. This value is .
Math.cos(x)
xThe cosine of the given number.
The Math.cos() method returns a numeric value between -1 and 1, which represents the cosine of the angle.
Because cos() is a static method of Math, you always use it as Math.cos(), rather than as a method of a Math object you created (Math is not a constructor).
Math.cos()\nMath.cos(0); // 1\nMath.cos(1); // 0.5403023058681398\n\nMath.cos(Math.PI); // -1\nMath.cos(2 * Math.PI); // 1\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.cos' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.cos' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.cos' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos\n
The Math.hypot() function returns the square root of the sum of squares of its arguments, that is
Math.hypot([value1[, value2[, ...]]])
value1, value2, ...The square root of the sum of squares of the given arguments. If at least one of the arguments cannot be converted to a number, NaN is returned.
Calculating the hypotenuse of a right triangle, or the magnitude of a complex number, uses the formula Math.sqrt(v1*v1 + v2*v2) where v1 and v2 are either the sides of the triangle, or the real and complex values. For calculating distance in 2 or more dimensions, simply add in more squares inside the square root sign, like Math.sqrt(v1*v1 + v2*v2 + v3*v3 + v4*v4).
This function makes it a little easier and faster, you just call Math.hypot(v1, v2) , or Math.hypot(v1, v2, v3, v4, ...) .
It also avoids a problem if the magnitude of your numbers is huge. The largest number you can represent in JS's double floats is Number.MAX_VALUE = 1.797...e+308 . If your numbers are larger than about 1e154, taking the square of them will result in Infinity, demolishing your results. For example, Math.sqrt(1e200*1e200 + 1e200*1e200) = Infinity . If you use hypot() instead, you get a good answer Math.hypot(1e200, 1e200) = 1.4142...e+200 . This is also true with very small numbers. Math.sqrt(1e-200*1e-200 + 1e-200*1e-200) = 0, but Math.hypot(1e-200, 1e-200) =1.4142...e-200, a good answer.
Because hypot() is a static method of Math, you always use it as Math.hypot(), rather than as a method of a Math object you created (Math is not a constructor).
If no arguments are given, the result is +0.
If at least one of the arguments cannot be converted to a number, the result is NaN.
With one argument, Math.hypot() returns the same as Math.abs().
Math.hypot()\nMath.hypot(3, 4); // 5\nMath.hypot(3, 4, 5); // 7.0710678118654755\nMath.hypot(); // 0\nMath.hypot(NaN); // NaN\nMath.hypot(3, 4, 'foo'); // NaN, +'foo' => NaN\nMath.hypot(3, 4, '5'); // 7.0710678118654755, +'5' => 5\nMath.hypot(-3); // 3, the same as Math.abs(-3)\n
This can be emulated using the following function:
if (!Math.hypot) Math.hypot = function() {\n var y = 0, i = arguments.length;\n while (i--) y += arguments[i] * arguments[i];\n return Math.sqrt(y);\n};\n A polyfill that avoids underflows and overflows:
if (!Math.hypot) Math.hypot = function (x, y) {\n // https://bugzilla.mozilla.org/show_bug.cgi?id=896264#c28\n var max = 0;\n var s = 0;\n for (var i = 0; i < arguments.length; i += 1) {\n var arg = Math.abs(Number(arguments[i]));\n if (arg > max) {\n s *= (max / arg) * (max / arg);\n max = arg;\n }\n s += arg === 0 && max === 0 ? 0 : (arg / max) * (arg / max);\n }\n return max === 1 / 0 ? 1 / 0 : max * Math.sqrt(s);\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.hypot' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.hypot' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n27 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n27 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/hypot\n
The Math.log10() function returns the base 10 logarithm of a number, that is
Math.log10(x)
xThe base 10 logarithm of the given number. If the number is negative, NaN is returned.
If the value of x is less than 0, the return value is always NaN.
Because log10() is a static method of Math, you always use it as Math.log10(), rather than as a method of a Math object you created (Math is not a constructor).
This function is the equivalent of Math.log(x) / Math.log(10). For log10(e) use the constant Math.LOG10E which is 1 / Math.LN10.
Math.log10()\nMath.log10(2); // 0.3010299956639812\nMath.log10(1); // 0\nMath.log10(0); // -Infinity\nMath.log10(-2); // NaN\nMath.log10(100000); // 5\n
This can be emulated with the following function:
Math.log10 = Math.log10 || function(x) {\n return Math.log(x) * Math.LOG10E;\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.log10' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.log10' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log10\n
The Math.log() function returns the natural logarithm (base e) of a number, that is
The JavaScript Math.log()function is equivalent to ln(x) in mathematics.
Math.log(x)
xThe natural logarithm (base e) of the given number. If the number is negative, NaN is returned.
If the value of x is negative, the return value is always NaN.
Because log() is a static method of Math, you always use it as Math.log(), rather than as a method of a Math object you created (Math is not a constructor).
If you need the natural log of 2 or 10, use the constants Math.LN2 or Math.LN10 . If you need a logarithm to base 2 or 10, use Math.log2() or Math.log10() . If you need a logarithm to other bases, use Math.log(x) / Math.log(otherBase) as in the example below; you might want to precalculate 1 / Math.log(otherBase) .
Math.log()\nMath.log(-1); // NaN, out of range\nMath.log(0); // -Infinity\nMath.log(1); // 0\nMath.log(10); // 2.302585092994046\n
Math.log() with a different baseThe following function returns the logarithm of y with base x (ie. ):
function getBaseLog(x, y) {\n return Math.log(y) / Math.log(x);\n}\n If you run getBaseLog(10, 1000) it returns 2.9999999999999996 due to floating-point rounding, which is very close to the actual answer of 3.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.log' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.log' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.log' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log\n
The Math.log2() function returns the base 2 logarithm of a number, that is
Math.log2(x)
xThe base 2 logarithm of the given number. If the number is negative, NaN is returned.
If the value of x is less than 0, the return value is always NaN.
Because log2() is a static method of Math, you always use it as Math.log2(), rather than as a method of a Math object you created (Math is not a constructor).
This function is the equivalent of Math.log(x) / Math.log(2). For log2(e) use the constant Math.LOG2E which is 1 / Math.LN2.
Math.log2()\nMath.log2(3); // 1.584962500721156\nMath.log2(2); // 1\nMath.log2(1); // 0\nMath.log2(0); // -Infinity\nMath.log2(-2); // NaN\nMath.log2(1024); // 10\n
This Polyfill emulates the Math.log2 function. Note that it returns imprecise values on some inputs (like 1 << 29), wrap into Math.round() if working with bit masks.
Math.log2 = Math.log2 || function(x) {\n return Math.log(x) * Math.LOG2E;\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.log2' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.log2' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log2\n
The static function Math.min() returns the lowest-valued number passed into it, or NaN if any parameter isn't a number and can't be converted into one.
Math.min([value1[, value2[, ...]]])
value1, value2, ...The smallest of the given numbers. If any one or more of the parameters cannot be converted into a number, NaN is returned. The result is Infinity if no parameters are provided.
Because min() is a static method of Math, you always use it as Math.min(), rather than as a method of a Math object you created (Math is not a constructor).
If no arguments are given, the result is Infinity.
If at least one of arguments cannot be converted to a number, the result is NaN.
Math.min()\nThis finds the min of x and y and assigns it to z:
var x = 10, y = -20;\nvar z = Math.min(x, y);\n
Math.min()\nMath.min() is often used to clip a value so that it is always less than or equal to a boundary. For instance, this
var x = f(foo);\n\nif (x > boundary) {\n x = boundary;\n}\n may be written as this
var x = Math.min(f(foo), boundary);\n
Math.max() can be used in a similar way to clip a value at the other end.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.min' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.min' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.min' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min\n
The Math.random() function returns a floating-point, pseudo-random number in the range 0–1 (inclusive of 0, but not 1) with approximately uniform distribution over that range — which you can then scale to your desired range. The implementation selects the initial seed to the random number generation algorithm; it cannot be chosen or reset by the user.
Math.random() does not provide cryptographically secure random numbers. Do not use them for anything related to security. Use the Web Crypto API instead, and more precisely the window.crypto.getRandomValues() method.
Math.random()
A floating-point, pseudo-random number between 0 (inclusive) and 1 (exclusive).
Note that as numbers in JavaScript are IEEE 754 floating point numbers with round-to-nearest-even behavior, the ranges claimed for the functions below (excluding the one for Math.random() itself) aren't exact. If extremely large bounds are chosen (253 or higher), it's possible in extremely rare cases to calculate the usually-excluded upper bound.
function getRandom() {\n return Math.random();\n}\n This example returns a random number between the specified values. The returned value is no lower than (and may possibly equal) min, and is less than (and not equal) max.
function getRandomArbitrary(min, max) {\n return Math.random() * (max - min) + min;\n}\n This example returns a random integer between the specified values. The value is no lower than min (or the next integer greater than min if min isn't an integer), and is less than (but not equal to) max.
function getRandomInt(min, max) {\n min = Math.ceil(min);\n max = Math.floor(max);\n return Math.floor(Math.random() * (max - min)) + min; //The maximum is exclusive and the minimum is inclusive\n}\n It might be tempting to use Math.round() to accomplish that, but doing so would cause your random numbers to follow a non-uniform distribution, which may not be acceptable for your needs.
While the getRandomInt() function above is inclusive at the minimum, it's exclusive at the maximum. What if you need the results to be inclusive at both the minimum and the maximum? The getRandomIntInclusive() function below accomplishes that.
function getRandomIntInclusive(min, max) {\n min = Math.ceil(min);\n max = Math.floor(max);\n return Math.floor(Math.random() * (max - min + 1)) + min; //The maximum is inclusive and the minimum is inclusive \n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. JavaScript 1.0 (UNIX Only) / JavaScript 1.1 (All platforms). |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.random' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.random' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.random' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random\n
The Math.trunc() function returns the integer part of a number by removing any fractional digits.
Math.trunc(x)\n
xThe integer part of the given number.
Unlike the other three Math methods: Math.floor(), Math.ceil() and Math.round(), the way Math.trunc() works is very simple. It truncates (cuts off) the dot and the digits to the right of it, no matter whether the argument is a positive or negative number.
The argument passed to this method will be converted to number type implicitly.
Because trunc() is a static method of Math, you always use it as Math.trunc(), rather than as a method of a Math object you created (Math is not a constructor).
Math.trunc()\nMath.trunc(13.37); // 13\nMath.trunc(42.84); // 42\nMath.trunc(0.123); // 0\nMath.trunc(-0.123); // -0\nMath.trunc('-1.123'); // -1\nMath.trunc(NaN); // NaN\nMath.trunc('foo'); // NaN\nMath.trunc(); // NaN\n if (!Math.trunc) {\n\tMath.trunc = function(v) {\n\t\tv = +v;\n\t\tif (!isFinite(v)) return v;\n\t\t\n\t\treturn (v - v % 1) || (v < 0 ? -0 : v === 0 ? v : 0);\n\t\t\n\t\t// returns:\n\t\t// 0 -> 0\n\t\t// -0 -> -0\n\t\t// 0.2 -> 0\n\t\t// -0.2 -> -0\n\t\t// 0.7 -> 0\n\t\t// -0.7 -> -0\n\t\t// Infinity -> Infinity\n\t\t// -Infinity -> -Infinity\n\t\t// NaN -> NaN\n\t\t// null -> 0\n\t};\n}\n or:
if (!Math.trunc) {\n\tMath.trunc = function(v) {\n\t\tv = +v;\n\t\treturn (v - v % 1) || (!isFinite(v) || v === 0 ? v : v < 0 ? -0 : 0);\n\t};\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.trunc' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.trunc' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc\n
The Math.cosh() function returns the hyperbolic cosine of a number, that can be expressed using the constant e:
Math.cosh(x)
xThe hyperbolic cosine of the given number.
Because cosh() is a static method of Math, you always use it as Math.cosh(), rather than as a method of a Math object you created (Math is not a constructor).
Math.cosh()\nMath.cosh(0); // 1\nMath.cosh(1); // 1.5430806348152437\nMath.cosh(-1); // 1.5430806348152437\n
This can be emulated with the help of the Math.exp() function:
Math.cosh = Math.cosh || function(x) {\n return (Math.exp(x) + Math.exp(-x)) / 2;\n}\n or using only one call to the Math.exp() function:
Math.cosh = Math.cosh || function(x) {\n var y = Math.exp(x);\n return (y + 1 / y) / 2;\n};\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.cosh' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.cosh' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cosh\n
The Math.max() function returns the largest of zero or more numbers.
Math.max([value1[, value2[, ...]]])
value1, value2, ...The largest of the given numbers. If at least one of the arguments cannot be converted to a number, NaN is returned.
Because max() is a static method of Math, you always use it as Math.max(), rather than as a method of a Math object you created (Math is not a constructor).
If no arguments are given, the result is -Infinity.
If at least one of arguments cannot be converted to a number, the result is NaN.
Math.max()\nMath.max(10, 20); // 20\nMath.max(-10, -20); // -10\nMath.max(-10, 20); // 20\n
Array.reduce() can be used to find the maximum element in a numeric array, by comparing each value:
var arr = [1,2,3];\nvar max = arr.reduce(function(a, b) {\n return Math.max(a, b);\n});\n The following function uses Function.prototype.apply() to get the maximum of an array. getMaxOfArray([1, 2, 3]) is equivalent to Math.max(1, 2, 3), but you can use getMaxOfArray() on programmatically constructed arrays. This should only be used for arrays with relatively few elements.
function getMaxOfArray(numArray) {\n return Math.max.apply(null, numArray);\n} The new spread operator is a shorter way of writing the apply solution to get the maximum of an array:
var arr = [1, 2, 3];\nvar max = Math.max(...arr);\n
However, both spread (...) and apply will either fail or return the wrong result if the array has too many elements, because they try to pass the array elements as function parameters. See Using apply and built-in functions for more details. The reduce solution does not have this problem.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.max' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.max' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.max' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max\n
The Math.sin() function returns the sine of a number.
Math.sin(x)
xThe sine of the given number.
The Math.sin() method returns a numeric value between -1 and 1, which represents the sine of the angle given in radians.
Because sin() is a static method of Math, you always use it as Math.sin(), rather than as a method of a Math object you created (Math is not a constructor).
Math.sin()\nMath.sin(0); // 0\nMath.sin(1); // 0.8414709848078965\n\nMath.sin(Math.PI / 2); // 1\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.sin' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.sin' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.sin' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin\n
The Math.sinh() function returns the hyperbolic sine of a number, that can be expressed using the constant e:
Math.sinh(x)
xThe hyperbolic sine of the given number.
Because sinh() is a static method of Math, you always use it as Math.sinh(), rather than as a method of a Math object you created (Math is not a constructor).
Math.sinh()\nMath.sinh(0); // 0\nMath.sinh(1); // 1.1752011936438014\n
This can be emulated with the help of the Math.exp() function:
Math.sinh = Math.sinh || function(x) {\n return (Math.exp(x) - Math.exp(-x)) / 2;\n}\n or using only one call to the Math.exp() function:
Math.sinh = Math.sinh || function(x) {\n var y = Math.exp(x);\n return (y - 1 / y) / 2;\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.sinh' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.sinh' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sinh\n
The Math.sqrt() function returns the square root of a number, that is
Math.sqrt(x)
xThe square root of the given number. If the number is negative, NaN is returned.
If the value of x is negative, Math.sqrt() returns NaN.
Because sqrt() is a static method of Math, you always use it as Math.sqrt(), rather than as a method of a Math object you created (Math is not a constructor).
Math.sqrt()\nMath.sqrt(9); // 3\nMath.sqrt(2); // 1.414213562373095\n\nMath.sqrt(1); // 1\nMath.sqrt(0); // 0\nMath.sqrt(-1); // NaN\nMath.sqrt(-0); // -0\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.sqrt' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.sqrt' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.sqrt' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt\n
The Math.fround() function returns the nearest 32-bit single precision float representation of a Number.
var singleFloat = Math.fround(doubleFloat);
doubleFloatNumber. If the parameter is of a different type, it will get converted to a number or to NaN if it cannot be converted.The nearest 32-bit single precision float representation of the given number.
JavaScript uses 64-bit double floating-point numbers internally, which offer a very high precision. However, sometimes you may be working with 32-bit floating-point numbers, for example if you are reading values from a Float32Array. This can create confusion: Checking a 64-bit float and a 32-bit float for equality may fail even though the numbers are seemingly identical.
To solve this, Math.fround() can be used to cast the 64-bit float to a 32-bit float. Internally, JavaScript continues to treat the number as a 64-bit float, it just performs a \"round to even\" on the 23rd bit of the mantissa, and sets all following mantissa bits to 0. If the number is outside the range of a 32-bit float, Infinity-Infinity is returned.
Because fround() is a static method of Math, you always use it as Math.fround(), rather than as a method of a Math object you created (Math is not a constructor).
Math.fround()\nThe number 1.5 can be precisely represented in the binary numeral system, and is identical in 32-bit and 64-bit:
Math.fround(1.5); // 1.5\nMath.fround(1.5) === 1.5; // true\n
However, the number 1.337 cannot be precisely represented in the binary numeral system, so it differs in 32-bit and 64-bit:
Math.fround(1.337); // 1.3370000123977661\nMath.fround(1.337) === 1.337; // false\n
is too big for a 32-bit float, so Infinity is returned:
2 ** 150; // 1.42724769270596e+45\nMath.fround(2 ** 150); // Infinity\n
If the parameter cannot be converted to a number, or it is not-a-number (NaN), Math.fround() will return NaN:
Math.fround('abc'); // NaN\nMath.fround(NaN); // NaN\n This can be emulated with the following function, if Float32Array are supported:
Math.fround = Math.fround || (function (array) {\n return function(x) {\n return array[0] = x, array[0];\n };\n})(new Float32Array(1));\n Supporting older browsers is slower, but also possible:
Math.fround = Math.fround || function(arg) {\n arg = Number(arg);\n // Return early for ±0 and NaN.\n if (!arg) return arg;\n var sign = arg < 0 ? -1 : 1;\n if (sign < 0) arg = -arg;\n // Compute the exponent (8 bits, signed).\n var exp = Math.floor(Math.log(arg) / Math.LN2);\n var powexp = Math.pow(2, Math.max(-126, Math.min(exp, 127)));\n // Handle subnormals: leading digit is zero if exponent bits are all zero.\n var leading = exp < -127 ? 0 : 1;\n // Compute 23 bits of mantissa, inverted to round toward zero.\n var mantissa = Math.round((leading - arg / powexp) * 0x800000);\n if (mantissa <= -0x800000) return sign * Infinity;\n return sign * powexp * (leading - mantissa / 0x800000);\n}; | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.fround' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.fround' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n26 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n26 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround\n
The Math.pow() function returns the base to the exponent power, that is, baseexponent.
Math.pow(base, exponent)
baseexponentbase.A number representing the given base taken to the power of the given exponent.
Because pow() is a static method of Math, you always use it as Math.pow(), rather than as a method of a Math object you created (Math has no constructor).
Math.pow()\n// simple\nMath.pow(7, 2); // 49\nMath.pow(7, 3); // 343\nMath.pow(2, 10); // 1024\n// fractional exponents\nMath.pow(4, 0.5); // 2 (square root of 4)\nMath.pow(8, 1/3); // 2 (cube root of 8)\nMath.pow(2, 0.5); // 1.4142135623730951 (square root of 2)\nMath.pow(2, 1/3); // 1.2599210498948732 (cube root of 2)\n// signed exponents\nMath.pow(7, -2); // 0.02040816326530612 (1/49)\nMath.pow(8, -1/3); // 0.5\n// signed bases\nMath.pow(-7, 2); // 49 (squares are positive)\nMath.pow(-7, 3); // -343 (cubes can be negative)\nMath.pow(-7, 0.5); // NaN (negative numbers don't have a real square root)\n// due to \"even\" and \"odd\" roots laying close to each other, \n// and limits in the floating number precision, \n// negative bases with fractional exponents always return NaN\nMath.pow(-7, 1/3); // NaN \n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.pow' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.pow' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.pow' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow\n
The Math.tanh() function returns the hyperbolic tangent of a number, that is
Math.tanh(x)
xThe hyperbolic tangent of the given number.
Because tanh() is a static method of Math, you always use it as Math.tanh(), rather than as a method of a Math object you created (Math is not a constructor).
Math.tanh()\nMath.tanh(0); // 0\nMath.tanh(Infinity); // 1\nMath.tanh(1); // 0.7615941559557649\n
This can be emulated with the help of the Math.exp() function:
Math.tanh = Math.tanh || function(x){\n var a = Math.exp(+x), b = Math.exp(-x);\n return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b);\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.tanh' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.tanh' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n38 | \nYes | \n25 | \nNo | \n25 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n25 | \nYes | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tanh\n
The Math.tan() function returns the tangent of a number.
Math.tan(x)
xThe tangent of the given number.
The Math.tan() method returns a numeric value that represents the tangent of the angle.
Because tan() is a static method of Math, you always use it as Math.tan(), rather than as a method of a Math object you created (Math is not a constructor).
Math.tan()\nMath.tan(1); // 1.5574077246549023\n
Because the Math.tan() function accepts radians, but it is often easier to work with degrees, the following function accepts a value in degrees, converts it to radians and returns the tangent.
function getTanDeg(deg) {\n var rad = deg * Math.PI/180;\n return Math.tan(rad);\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Math.tan' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Math.tan' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Math.tan' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tan\n
The Object.prototype property represents the Object prototype object.
Property attributes of Object.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
Nearly all objects in JavaScript are instances of Object; a typical object inherits properties (including methods) from Object.prototype, although these properties may be shadowed (a.k.a. overridden). However, an Object may be deliberately created for which this is not true (e.g. by Object.create(null)), or it may be altered so that this is no longer true (e.g. with Object.setPrototypeOf).
Changes to the Object prototype object are seen by all objects through prototype chaining, unless the properties and methods subject to those changes are overridden further along the prototype chain. This provides a very powerful although potentially dangerous mechanism to override or extend object behavior.
Object.prototype.constructorObject.prototype.__proto__ \nObject.prototype.__noSuchMethod__ \nObject.prototype.__count__ Object.prototype.__parent__ Object.prototype.__defineGetter__() \nObject.prototype.__defineSetter__() \nObject.prototype.__lookupGetter__() \n__defineGetter__() method.Object.prototype.__lookupSetter__() \n__defineSetter__() method.Object.prototype.hasOwnProperty()Object.prototype.isPrototypeOf()Object.prototype.propertyIsEnumerable()Object.prototype.toSource() \nObject.prototype.toLocaleString()toString().Object.prototype.toString()Object.prototype.unwatch() \nObject.prototype.valueOf()Object.prototype.watch() \nObject.prototype.eval() When altering the behavior of existing Object.prototype methods, consider injecting code by wrapping your extension before or after the existing logic. For example, this (untested) code will pre-conditionally execute custom logic before the built-in logic or someone else's extension is executed.
When a function is called, the arguments to the call are held in the array-like \"variable\" arguments. For example, in the call \"myFn(a, b, c)\", the arguments within myFn's body will contain 3 array-like elements corresponding to (a, b, c). When modifying prototypes with hooks, simply pass this & the arguments (the call state) to the current behavior by calling apply() on the function. This pattern can be used for any prototype, such as Node.prototype, Function.prototype, etc.
var current = Object.prototype.valueOf;\n\n// Since my property \"-prop-value\" is cross-cutting and isn't always\n// on the same prototype chain, I want to modify Object.prototype: \nObject.prototype.valueOf = function() {\n if (this.hasOwnProperty('-prop-value')) {\n return this['-prop-value'];\n } else {\n // It doesn't look like one of my objects, so let's fall back on \n // the default behavior by reproducing the current behavior as best we can.\n // The apply behaves like \"super\" in some other languages.\n // Even though valueOf() doesn't take arguments, some other hook may.\n return current.apply(this, arguments);\n }\n}\n Since JavaScript doesn't exactly have sub-class objects, prototype is a useful workaround to make a “base class” object of certain functions that act as objects. For example:
var Person = function(name) {\n this.name = name;\n this.canTalk = true;\n};\n\nPerson.prototype.greet = function() {\n if (this.canTalk) {\n console.log('Hi, I am ' + this.name);\n }\n};\n\nvar Employee = function(name, title) {\n Person.call(this, name);\n this.title = title;\n};\n\nEmployee.prototype = Object.create(Person.prototype);\n\nEmployee.prototype.greet = function() {\n if (this.canTalk) {\n console.log('Hi, I am ' + this.name + ', the ' + this.title);\n }\n};\n\nvar Customer = function(name) {\n Person.call(this, name);\n};\n\nCustomer.prototype = Object.create(Person.prototype);\n\nvar Mime = function(name) {\n Person.call(this, name);\n this.canTalk = false;\n};\n\nMime.prototype = Object.create(Person.prototype);\n\nvar bob = new Employee('Bob', 'Builder');\nvar joe = new Customer('Joe');\nvar rg = new Employee('Red Green', 'Handyman');\nvar mike = new Customer('Mike');\nvar mime = new Mime('Mime');\n\nbob.greet();\n// Hi, I am Bob, the Builder\n\njoe.greet();\n// Hi, I am Joe\n\nrg.greet();\n// Hi, I am Red Green, the Handyman\n\nmike.greet();\n// Hi, I am Mike\n\nmime.greet();\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.prototype' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.prototype' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype\n
The Object.assign() method is used to copy the values of all enumerable own properties from one or more source objects to a target object. It will return the target object.
Object.assign(target, ...sources)
targetsourcesThe target object.
Properties in the target object will be overwritten by properties in the sources if they have the same key. Later sources' properties will similarly overwrite earlier ones.
The Object.assign() method only copies enumerable and own properties from a source object to a target object. It uses [[Get]] on the source and [[Set]] on the target, so it will invoke getters and setters. Therefore it assigns properties versus just copying or defining new properties. This may make it unsuitable for merging new properties into a prototype if the merge sources contain getters. For copying property definitions, including their enumerability, into prototypes Object.getOwnPropertyDescriptor() and Object.defineProperty() should be used instead.
Both String and Symbol properties are copied.
In case of an error, for example if a property is non-writable, a TypeError will be raised, and the target object can be changed if any properties are added before error is raised.
Note that Object.assign() does not throw on null or undefined source values.
var obj = { a: 1 };\nvar copy = Object.assign({}, obj);\nconsole.log(copy); // { a: 1 }\n For deep cloning, we need to use other alternatives because Object.assign() copies property values. If the source value is a reference to an object, it only copies that reference value.
function test() {\n 'use strict';\n\n let obj1 = { a: 0 , b: { c: 0}};\n let obj2 = Object.assign({}, obj1);\n console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}\n \n obj1.a = 1;\n console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}\n console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}\n \n obj2.a = 2;\n console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}\n console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 0}}\n \n obj2.b.c = 3;\n console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 3}}\n console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 3}}\n \n // Deep Clone\n obj1 = { a: 0 , b: { c: 0}};\n let obj3 = JSON.parse(JSON.stringify(obj1));\n obj1.a = 4;\n obj1.b.c = 4;\n console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}}\n}\n\ntest(); var o1 = { a: 1 };\nvar o2 = { b: 2 };\nvar o3 = { c: 3 };\n\nvar obj = Object.assign(o1, o2, o3);\nconsole.log(obj); // { a: 1, b: 2, c: 3 }\nconsole.log(o1); // { a: 1, b: 2, c: 3 }, target object itself is changed. var o1 = { a: 1, b: 1, c: 1 };\nvar o2 = { b: 2, c: 2 };\nvar o3 = { c: 3 };\n\nvar obj = Object.assign({}, o1, o2, o3);\nconsole.log(obj); // { a: 1, b: 2, c: 3 } The properties are overwritten by other objects that have the same properties later in the parameters order.
var o1 = { a: 1 };\nvar o2 = { [Symbol('foo')]: 2 };\n\nvar obj = Object.assign({}, o1, o2);\nconsole.log(obj); // { a : 1, [Symbol(\"foo\")]: 2 } (cf. bug 1207182 on Firefox)\nObject.getOwnPropertySymbols(obj); // [Symbol(foo)]\n var obj = Object.create({ foo: 1 }, { // foo is on obj's prototype chain.\n bar: {\n value: 2 // bar is a non-enumerable property.\n },\n baz: {\n value: 3,\n enumerable: true // baz is an own enumerable property.\n }\n});\n\nvar copy = Object.assign({}, obj);\nconsole.log(copy); // { baz: 3 }\n var v1 = 'abc';\nvar v2 = true;\nvar v3 = 10;\nvar v4 = Symbol('foo');\n\nvar obj = Object.assign({}, v1, null, v2, undefined, v3, v4); \n// Primitives will be wrapped, null and undefined will be ignored.\n// Note, only string wrappers can have own enumerable properties.\nconsole.log(obj); // { \"0\": \"a\", \"1\": \"b\", \"2\": \"c\" }\n var target = Object.defineProperty({}, 'foo', {\n value: 1,\n writable: false\n}); // target.foo is a read-only property\n\nObject.assign(target, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 });\n// TypeError: \"foo\" is read-only\n// The Exception is thrown when assigning target.foo\n\nconsole.log(target.bar); // 2, the first source was copied successfully.\nconsole.log(target.foo2); // 3, the first property of the second source was copied successfully.\nconsole.log(target.foo); // 1, exception is thrown here.\nconsole.log(target.foo3); // undefined, assign method has finished, foo3 will not be copied.\nconsole.log(target.baz); // undefined, the third source will not be copied either.\n var obj = {\n foo: 1,\n get bar() {\n return 2;\n }\n};\n\nvar copy = Object.assign({}, obj); \nconsole.log(copy); \n// { foo: 1, bar: 2 }, the value of copy.bar is obj.bar's getter's return value.\n\n// This is an assign function that copies full descriptors\nfunction completeAssign(target, ...sources) {\n sources.forEach(source => {\n let descriptors = Object.keys(source).reduce((descriptors, key) => {\n descriptors[key] = Object.getOwnPropertyDescriptor(source, key);\n return descriptors;\n }, {});\n // by default, Object.assign copies enumerable Symbols too\n Object.getOwnPropertySymbols(source).forEach(sym => {\n let descriptor = Object.getOwnPropertyDescriptor(source, sym);\n if (descriptor.enumerable) {\n descriptors[sym] = descriptor;\n }\n });\n Object.defineProperties(target, descriptors);\n });\n return target;\n}\n\nvar copy = completeAssign({}, obj);\nconsole.log(copy);\n// { foo:1, get bar() { return 2 } }\n This polyfill doesn't support symbol properties, since ES5 doesn't have symbols anyway:
if (typeof Object.assign != 'function') {\n // Must be writable: true, enumerable: false, configurable: true\n Object.defineProperty(Object, \"assign\", {\n value: function assign(target, varArgs) { // .length of function is 2\n 'use strict';\n if (target == null) { // TypeError if undefined or null\n throw new TypeError('Cannot convert undefined or null to object');\n }\n\n var to = Object(target);\n\n for (var index = 1; index < arguments.length; index++) {\n var nextSource = arguments[index];\n\n if (nextSource != null) { // Skip over if undefined or null\n for (var nextKey in nextSource) {\n // Avoid bugs when hasOwnProperty is shadowed\n if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {\n to[nextKey] = nextSource[nextKey];\n }\n }\n }\n }\n return to;\n },\n writable: true,\n configurable: true\n });\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.assign' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.assign' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n45 | \nYes | \n34 | \nNo | \n32 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n45 | \nYes | \n34 | \nNo | \nYes | \n5.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n
The Object.entries() method returns an array of a given object's own enumerable property [key, value] pairs, in the same order as that provided by a for...in loop (the difference being that a for-in loop enumerates properties in the prototype chain as well) . The order of the array returned by Object.entries() does not depend on how an object is defined. If there is a need for certain ordering then the array needs to be sorted first like Object.entries(obj).sort((a, b) => a[0] - b[0]);.
Object.entries(obj)
obj[key, value] pairs are to be returned.An array of the given object's own enumerable property [key, value] pairs.
Object.entries() returns an array whose elements are arrays corresponding to the enumerable property [key, value] pairs found directly upon object. The ordering of the properties is the same as that given by looping over the property values of the object manually.
const obj = { foo: 'bar', baz: 42 };\nconsole.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]\n\n// array like object\nconst obj = { 0: 'a', 1: 'b', 2: 'c' };\nconsole.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]\n\n// array like object with random key ordering\nconst anObj = { 100: 'a', 2: 'b', 7: 'c' };\nconsole.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]\n\n// getFoo is property which isn't enumerable\nconst myObj = Object.create({}, { getFoo: { value() { return this.foo; } } });\nmyObj.foo = 'bar';\nconsole.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]\n\n// non-object argument will be coerced to an object\nconsole.log(Object.entries('foo')); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]\n\n// returns an empty array for any primitive type, since primitives have no own properties\nconsole.log(Object.entries(100)); // [ ]\n\n// iterate through key-value gracefully\nconst obj = { a: 5, b: 7, c: 9 };\nfor (const [key, value] of Object.entries(obj)) {\n console.log(`${key} ${value}`); // \"a 5\", \"b 7\", \"c 9\"\n}\n\n// Or, using array extras\nObject.entries(obj).forEach(([key, value]) => {\n console.log(`${key} ${value}`); // \"a 5\", \"b 7\", \"c 9\"\n});\n Object to a Map\nThe new Map() constructor accepts an iterable of entries. With Object.entries, you can easily convert from Object to Map:
const obj = { foo: 'bar', baz: 42 }; \nconst map = new Map(Object.entries(obj));\nconsole.log(map); // Map { foo: \"bar\", baz: 42 }\n Object\nUsing Array Destructuring, you can iterate through objects easily.
const obj = { foo: 'bar', baz: 42 };\nObject.entries(obj).forEach(([key, value]) => console.log(`${key}: ${value}`)); // \"foo: bar\", \"baz: 42\"\n To add compatible Object.entries support in older environments that do not natively support it, you can find a demonstrational implementation of Object.entries in the tc39/proposal-object-values-entries (if you don't need any support for IE), a polyfill in the es-shims/Object.entries repositories, or you can use the simple, ready to deploy polyfill listed below.
if (!Object.entries) {\n Object.entries = function( obj ){\n var ownProps = Object.keys( obj ),\n i = ownProps.length,\n resArray = new Array(i); // preallocate the Array\n while (i--)\n resArray[i] = [ownProps[i], obj[ownProps[i]]];\n \n return resArray;\n };\n}\n For the above polyfill code snippet, if you need support for IE < 9, then you will also need an Object.keys polyfill (such as the one found on the Object.keys page).
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.entries' in that specification. | Draft | Initial definition. |
| ECMAScript 2017 (ECMA-262) The definition of 'Object.entries' in that specification. | Standard |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n54 | \n14 | \n47 | \nNo | \n41 | \n10.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n54 | \n54 | \nYes | \n47 | \n41 | \n10.1 | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 7.0.0\n
| \n
Object.keys()Object.values()Object.prototype.propertyIsEnumerable()Object.create()Object.getOwnPropertyNames()Map.prototype.entries()Map.prototype.keys()Map.prototype.values()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries\n
The add() method appends a new object to the end of a WeakSet object.
ws.add(value);\n
WeakSet collection.The WeakSet object.
add methodvar ws = new WeakSet();\n\nws.add(window); // add the window object to the WeakSet\n\nws.has(window); // true\n\n// Weakset only takes objects as arguments\nws.add(1);\n// results in \"TypeError: Invalid value used in weak set\" in Chrome\n// and \"TypeError: 1 is not a non-null object\" in Firefox
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakSet.prototype.add' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakSet.prototype.add' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \nYes | \n34 | \nNo | \n23 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \nYes | \n34 | \n23 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet/add\n
The Object.fromEntries() method transforms a list of key-value pairs into an object.
Object.fromEntries(iterable);
iterableArray or Map or other objects implementing the iterable protocol.A new object whose properties are given by the entries of the iterable.
The Object.fromEntries() method takes a list of key-value pairs and returns a new object whose properties are given by those entries. The iterable argument is expected to be an object that implements an @@iterator method, that returns an iterator object, that produces a two element array-like object, whose first element is a value that will be used as a property key, and whose second element is the value to associate with that property key.
Object.fromEntries() performs the reverse of Object.entries().
Map to an Object\nWith Object.fromEntries, you can convert from Map to Object:
const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);\nconst obj = Object.fromEntries(map);\nconsole.log(obj); // { foo: \"bar\", baz: 42 }\n Array to an Object\nWith Object.fromEntries, you can convert from Array to Object:
const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ];\nconst obj = Object.fromEntries(arr);\nconsole.log(obj); // { 0: \"a\", 1: \"b\", 2: \"c\" }\n With Object.fromEntries, its reverse method Object.entries(), and array manipulation methods, you are able to transform objects like this:
const object1 = { a: 1, b: 2, c: 3 };\n\nconst object2 = Object.fromEntries(\n Object.entries(object1)\n .map(([ key, val ]) => [ key, val * 2 ])\n);\n\nconsole.log(object2);\n// { a: 2, b: 4, c: 6 } | Specification | Status |
|---|---|
\nObject.fromEntries proposal | Stage 3 |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nNo | \nNo | \n63 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nNo | \nNo | \n63 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
Object.entries()Object.keys()Object.values()Map.prototype.entries()Map.prototype.keys()Map.prototype.values()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries\n
The Object.getOwnPropertyDescriptors() method returns all own property descriptors of a given object.
Object.getOwnPropertyDescriptors(obj)
objAn object containing all own property descriptors of an object. Might be an empty object, if there are no properties.
This method permits examination of the precise description of all own properties of an object. A property in JavaScript consists of either a string-valued name or a Symbol and a property descriptor. Further information about property descriptor types and their attributes can be found in Object.defineProperty().
A property descriptor is a record with some of the following attributes:
valuewritabletrue if and only if the value associated with the property may be changed (data descriptors only).getundefined if there is no getter (accessor descriptors only).setundefined if there is no setter (accessor descriptors only).configurabletrue if and only if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.enumerabletrue if and only if this property shows up during enumeration of the properties on the corresponding object.Whereas the Object.assign() method will only copy enumerable and own properties from a source object to a target object, you are able to use this method and Object.create() for a shallow copy between two unknown objects:
Object.create(\n Object.getPrototypeOf(obj), \n Object.getOwnPropertyDescriptors(obj) \n);\n
A typical way of creating a subclass is to define the subclass, set its prototype to an instance of the superclass, and then define properties on that instance. This can get awkward especially for getters and setters. Instead, you can use this code to set the prototype:
function superclass() {}\nsuperclass.prototype = {\n // Define your methods and properties here\n};\nfunction subclass() {}\nsubclass.prototype = Object.create(\n superclass.prototype,\n {\n // Define your methods and properties here\n }\n);\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.getOwnPropertyDescriptors' in that specification. | Draft | Initial definition in ECMAScript 2017. |
| ECMAScript 2017 (ECMA-262) The definition of 'Object.getOwnPropertyDescriptors' in that specification. | Standard |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n54 | \n15 | \n50 | \nNo | \n41 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \n54 | \nYes | \n50 | \n? | \n? | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 7.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors\n
The WeakSet.prototype property represents the prototype for the WeakSet constructor.
Property attributes of WeakSet.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
WeakSet instances inherit from WeakSet.prototype. You can use the constructor's prototype object to add properties or methods to all WeakSet instances.
WeakSet.prototype is itself just an ordinary object:
Object.prototype.toString.call(WeakSet.prototype); // \"[object Object]\"
WeakSet.prototype.constructorWeakSet function by default.WeakSet.prototype.add(value)WeakSet object.WeakSet.prototype.delete(value)value. WeakSet.prototype.has(value) will return false afterwards.WeakSet.prototype.has(value)WeakSet object or not.WeakSet.prototype.clear() WeakSet object.| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakSet.prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakSet.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \nYes | \n34 | \nNo | \n23 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \nYes | \n34 | \n23 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet/prototype\n
The Object.freeze() method freezes an object. A frozen object can no longer be changed; freezing an object prevents new properties from being added to it, existing properties from being removed, prevents changing the enumerability, configurability, or writability of existing properties, and prevents the values of existing properties from being changed. In addition, freezing an object also prevents its prototype from being changed. freeze() returns the same object that was passed in.
Object.freeze(obj)
objThe object that was passed to the function.
Nothing can be added to or removed from the properties set of a frozen object. Any attempt to do so will fail, either silently or by throwing a TypeError exception (most commonly, but not exclusively, when in strict mode).
For data properties of a frozen object, values cannot be changed, the writable and configurable attributes are set to false. Accessor properties (getters and setters) work the same (and still give the illusion that you are changing the value). Note that values that are objects can still be modified, unless they are also frozen. As an object, an array can be frozen; after doing so, its elements cannot be altered and no elements can be added to or removed from the array.
freeze() returns the same object that was passed into the function. It does not create a frozen copy.
var obj = {\n prop: function() {},\n foo: 'bar'\n};\n\n// New properties may be added, existing properties may be\n// changed or removed\nobj.foo = 'baz';\nobj.lumpy = 'woof';\ndelete obj.prop;\n\n// Both the object being passed as well as the returned\n// object will be frozen. It is unnecessary to save the\n// returned object in order to freeze the original.\nvar o = Object.freeze(obj);\n\no === obj; // true\nObject.isFrozen(obj); // === true\n\n// Now any changes will fail\nobj.foo = 'quux'; // silently does nothing\n// silently doesn't add the property\nobj.quaxxor = 'the friendly duck';\n\n// In strict mode such attempts will throw TypeErrors\nfunction fail(){\n 'use strict';\n obj.foo = 'sparky'; // throws a TypeError\n delete obj.foo; // throws a TypeError\n delete obj.quaxxor; // returns true since attribute 'quaxxor' was never added\n obj.sparky = 'arf'; // throws a TypeError\n}\n\nfail();\n\n// Attempted changes through Object.defineProperty; \n// both statements below throw a TypeError.\nObject.defineProperty(obj, 'ohai', { value: 17 });\nObject.defineProperty(obj, 'foo', { value: 'eit' });\n\n// It's also impossible to change the prototype\n// both statements below will throw a TypeError.\nObject.setPrototypeOf(obj, { x: 20 })\nobj.__proto__ = { x: 20 }\n let a = [0];\nObject.freeze(a); // The array cannot be modified now.\n\na[0]=1; // fails silently\na.push(2); // fails silently\n\n// In strict mode such attempts will throw TypeErrors\nfunction fail() {\n \"use strict\"\n a[0] = 1;\n a.push(2);\n}\n\nfail(); The object being frozen is immutable. However, it is not necessarily constant. The following example shows that a frozen object is not constant (freeze is shallow).
obj1 = {\n internal: {}\n};\n\nObject.freeze(obj1);\nobj1.internal.a = 'aValue';\n\nobj1.internal.a // 'aValue' To be a constant object, the entire reference graph (direct and indirect references to other objects) must reference only immutable frozen objects. The object being frozen is said to be immutable because the entire object state (values and references to other objects) within the whole object is fixed. Note that strings, numbers, and booleans are always immutable and that Functions and Arrays are objects.
The result of calling Object.freeze(object) only applies to the immediate properties of object itself and will prevent future property addition, removal or value re-assignment operations only on object. If the value of those properties are objects themselves, those objects are not frozen and may be the target of property addition, removal or value re-assignment operations.
var employee = {\n name: \"Mayank\",\n designation: \"Developer\",\n address: {\n street: \"Rohini\",\n city: \"Delhi\"\n }\n};\n\nObject.freeze(employee);\n\nemployee.name = \"Dummy\"; // fails silently in non-strict mode\nemployee.address.city = \"Noida\"; // attributes of child object can be modified\n\nconsole.log(employee.address.city) // Output: \"Noida\"\n To make an object immutable, recursively freeze each property which is of type object (deep freeze). Use the pattern on a case-by-case basis based on your design when you know the object contains no Unknown prefix: Cycle_(graph_theory). in the reference graph, otherwise an endless loop will be triggered. An enhancement to deepFreeze() would be to have an internal function that receives a path (e.g. an Array) argument so you can suppress calling deepFreeze() recursively when an object is in the process of being made immutable. You still run a risk of freezing an object that shouldn't be frozen, such as [window].
function deepFreeze(object) {\n\n // Retrieve the property names defined on object\n var propNames = Object.getOwnPropertyNames(object);\n\n // Freeze properties before freezing self\n \n for (let name of propNames) {\n let value = object[name];\n\n object[name] = value && typeof value === \"object\" ? \n deepFreeze(value) : value;\n }\n\n return Object.freeze(object);\n}\n\nvar obj2 = {\n internal: {\n a: null\n }\n};\n\ndeepFreeze(obj2);\n\nobj2.internal.a = 'anotherValue'; // fails silently in non-strict mode\nobj2.internal.a; // null\n In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. In ES2015, a non-object argument will be treated as if it were a frozen ordinary object, and be simply returned.
> Object.freeze(1)\nTypeError: 1 is not an object // ES5 code\n\n> Object.freeze(1)\n1 // ES2015 code\n
An ArrayBufferView with elements will cause a TypeError, as they are views over memory and will definitely cause other possible issues:
> Object.freeze(new Uint8Array(0)) // No elements\nUint8Array []\n\n> Object.freeze(new Uint8Array(1)) // Has elements\nTypeError: Cannot freeze array buffer views with elements\n\n> Object.freeze(new DataView(new ArrayBuffer(32))) // No elements\nDataView {}\n\n> Object.freeze(new Float64Array(new ArrayBuffer(64), 63, 0)) // No elements\nFloat64Array []\n\n> Object.freeze(new Float64Array(new ArrayBuffer(64), 32, 2)) // Has elements\nTypeError: Cannot freeze array buffer views with elements\n Note that; as the standard three properties (buf.byteLength, buf.byteOffset and buf.buffer) are read-only (as are those of an ArrayBuffer or SharedArrayBuffer), there is no reason for attempting to freeze these properties.
Object.seal()\nObjects sealed with Object.seal() can have their existing properties changed. Existing properties in objects frozen with Object.freeze() are made immutable.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.freeze' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.freeze' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.freeze' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze\n
The Object.is() method determines whether two values are the same value.
Object.is(value1, value2);
value1value2A Boolean indicating whether or not the two arguments are the same value.
Object.is() determines whether two values are the same value. Two values are the same if one of the following holds:
undefined\nnull\ntrue or both false\nThis is not the same as being equal according to the == operator. The == operator applies various coercions to both sides (if they are not the same Type) before testing for equality (resulting in such behavior as \"\" == false being true), but Object.is doesn't coerce either value.
This is also not the same as being equal according to the === operator. The === operator (and the == operator as well) treats the number values -0 and +0 as equal and treats Number.NaN as not equal to NaN.
Object.is('foo', 'foo'); // true\nObject.is(window, window); // true\n\nObject.is('foo', 'bar'); // false\nObject.is([], []); // false\n\nvar test = { a: 1 };\nObject.is(test, test); // true\n\nObject.is(null, null); // true\n\n// Special Cases\nObject.is(0, -0); // false\nObject.is(-0, -0); // true\nObject.is(NaN, 0/0); // true\n if (!Object.is) {\n Object.is = function(x, y) {\n // SameValue algorithm\n if (x === y) { // Steps 1-5, 7-10\n // Steps 6.b-6.e: +0 != -0\n return x !== 0 || 1 / x === 1 / y;\n } else {\n // Step 6.a: NaN == NaN\n return x !== x && y !== y;\n }\n };\n} | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.is' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.is' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n30 | \nYes | \n22 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n22 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.10 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n
The Object.isFrozen() determines if an object is frozen.
Object.isFrozen(obj)
objA Boolean indicating whether or not the given object is frozen.
An object is frozen if and only if it is not extensible, all its properties are non-configurable, and all its data properties (that is, properties which are not accessor properties with getter or setter components) are non-writable.
// A new object is extensible, so it is not frozen.\nObject.isFrozen({}); // === false\n\n// An empty object which is not extensible\n// is vacuously frozen.\nvar vacuouslyFrozen = Object.preventExtensions({});\nObject.isFrozen(vacuouslyFrozen); // === true\n\n// A new object with one property is also extensible,\n// ergo not frozen.\nvar oneProp = { p: 42 };\nObject.isFrozen(oneProp); // === false\n\n// Preventing extensions to the object still doesn't \n// make it frozen, because the property is still \n// configurable (and writable).\nObject.preventExtensions(oneProp);\nObject.isFrozen(oneProp); // === false\n\n// ...but then deleting that property makes the object\n// vacuously frozen.\ndelete oneProp.p;\nObject.isFrozen(oneProp); // === true\n\n// A non-extensible object with a non-writable\n// but still configurable property is not frozen.\nvar nonWritable = { e: 'plep' };\nObject.preventExtensions(nonWritable);\nObject.defineProperty(nonWritable, 'e', {\n writable: false\n}); // make non-writable\nObject.isFrozen(nonWritable); // === false\n\n// Changing that property to non-configurable\n// then makes the object frozen.\nObject.defineProperty(nonWritable, 'e', {\n configurable: false\n}); // make non-configurable\nObject.isFrozen(nonWritable); // === true\n\n// A non-extensible object with a non-configurable\n// but still writable property also isn't frozen.\nvar nonConfigurable = { release: 'the kraken!' };\nObject.preventExtensions(nonConfigurable);\nObject.defineProperty(nonConfigurable, 'release', {\n configurable: false\n});\nObject.isFrozen(nonConfigurable); // === false\n\n// Changing that property to non-writable\n// then makes the object frozen.\nObject.defineProperty(nonConfigurable, 'release', {\n writable: false\n});\nObject.isFrozen(nonConfigurable); // === true\n\n// A non-extensible object with a configurable\n// accessor property isn't frozen.\nvar accessor = { get food() { return 'yum'; } };\nObject.preventExtensions(accessor);\nObject.isFrozen(accessor); // === false\n\n// ...but make that property non-configurable\n// and it becomes frozen.\nObject.defineProperty(accessor, 'food', {\n configurable: false\n});\nObject.isFrozen(accessor); // === true\n\n// But the easiest way for an object to be frozen\n// is if Object.freeze has been called on it.\nvar frozen = { 1: 81 };\nObject.isFrozen(frozen); // === false\nObject.freeze(frozen);\nObject.isFrozen(frozen); // === true\n\n// By definition, a frozen object is non-extensible.\nObject.isExtensible(frozen); // === false\n\n// Also by definition, a frozen object is sealed.\nObject.isSealed(frozen); // === true\n In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. In ES2015, a non-object argument will be treated as if it was a frozen ordinary object, simply return true.
Object.isFrozen(1);\n// TypeError: 1 is not an object (ES5 code)\n\nObject.isFrozen(1);\n// true (ES2015 code)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.isFrozen' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.isFrozen' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.isFrozen' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen\n
The Object.create() method creates a new object, using an existing object as the prototype of the newly created object.
Object.create(proto[, propertiesObject])
undefined, an object whose enumerable own properties (that is, those properties defined upon itself and not enumerable properties along its prototype chain) specify property descriptors to be added to the newly-created object, with the corresponding property names. These properties correspond to the second argument of Object.defineProperties().A new object with the specified prototype object and properties.
A TypeError exception if the propertiesObject parameter is null or a non-primitive-wrapper object.
Object.create()\nBelow is an example of how to use Object.create() to achieve classical inheritance. This is for single inheritance, which is all that JavaScript supports.
// Shape - superclass\nfunction Shape() {\n this.x = 0;\n this.y = 0;\n}\n\n// superclass method\nShape.prototype.move = function(x, y) {\n this.x += x;\n this.y += y;\n console.info('Shape moved.');\n};\n\n// Rectangle - subclass\nfunction Rectangle() {\n Shape.call(this); // call super constructor.\n}\n\n// subclass extends superclass\nRectangle.prototype = Object.create(Shape.prototype);\nRectangle.prototype.constructor = Rectangle;\n\nvar rect = new Rectangle();\n\nconsole.log('Is rect an instance of Rectangle?',\n rect instanceof Rectangle); // true\nconsole.log('Is rect an instance of Shape?',\n rect instanceof Shape); // true\nrect.move(1, 1); // Outputs, 'Shape moved.'\n If you wish to inherit from multiple objects, then mixins are a possibility.
function MyClass() {\n SuperClass.call(this);\n OtherSuperClass.call(this);\n}\n\n// inherit one class\nMyClass.prototype = Object.create(SuperClass.prototype);\n// mixin another\nObject.assign(MyClass.prototype, OtherSuperClass.prototype);\n// re-assign constructor\nMyClass.prototype.constructor = MyClass;\n\nMyClass.prototype.myMethod = function() {\n // do something\n};\n Object.assign() copies properties from the OtherSuperClass prototype to the MyClass prototype, making them available to all instances of MyClass. Object.assign() was introduced with ES2015 and can be polyfilled. If support for older browsers is necessary, jQuery.extend() or _.assign() can be used.
propertiesObject argument with Object.create()\nvar o;\n\n// create an object with null as prototype\no = Object.create(null);\n\n\no = {};\n// is equivalent to:\no = Object.create(Object.prototype);\n\n\n// Example where we create an object with a couple of\n// sample properties. (Note that the second parameter\n// maps keys to *property descriptors*.)\no = Object.create(Object.prototype, {\n // foo is a regular 'value property'\n foo: {\n writable: true,\n configurable: true,\n value: 'hello'\n },\n // bar is a getter-and-setter (accessor) property\n bar: {\n configurable: false,\n get: function() { return 10; },\n set: function(value) {\n console.log('Setting `o.bar` to', value);\n }\n/* with ES2015 Accessors our code can look like this\n get() { return 10; },\n set(value) {\n console.log('Setting `o.bar` to', value);\n } */\n }\n});\n\n\nfunction Constructor() {}\no = new Constructor();\n// is equivalent to:\no = Object.create(Constructor.prototype);\n// Of course, if there is actual initialization code\n// in the Constructor function, \n// the Object.create() cannot reflect it\n\n\n// Create a new object whose prototype is a new, empty\n// object and add a single property 'p', with value 42.\no = Object.create({}, { p: { value: 42 } });\n\n// by default properties ARE NOT writable,\n// enumerable or configurable:\no.p = 24;\no.p;\n// 42\n\no.q = 12;\nfor (var prop in o) {\n console.log(prop);\n}\n// 'q'\n\ndelete o.p;\n// false\n\n// to specify an ES3 property\no2 = Object.create({}, {\n p: {\n value: 42,\n writable: true,\n enumerable: true,\n configurable: true\n }\n});\n A new object created from a completely custom object (especially one created from the null object, which is basically a custom object with NO members) can behave in unexpected ways. This is especially true when debugging, since common object-property converting/detecting utility functions may generate errors, or simply lose information (especially if using silent error-traps that ignore errors). For example, here are two objects:
oco = Object.create( {} ); // create a normal object\nocn = Object.create( null ); // create a \"null\" object\n\n> console.log(oco) // {} -- Seems normal\n> console.log(ocn) // {} -- Seems normal here too, so far\n\noco.p = 1; // create a simple property on normal obj\nocn.p = 0; // create a simple property on \"null\" obj\n\n> console.log(oco) // {p: 1} -- Still seems normal\n> console.log(ocn) // {p: 0} -- Still seems normal here too. BUT WAIT...\n
As shown above, all seems normal so far. However, when attempting to actually use these objects, their differences quickly become apparent:
> \"oco is: \" + oco // shows \"ocn is: [object Object]\"\n\n> \"ocn is: \" + ocn // throws error: Cannot convert object to primitive value\n
Testing just a few of the many most basic built-in functions shows the magnitude of the problem more clearly:
> alert(oco) // shows [object Object]\n> alert(ocn) // throws error: Cannot convert object to primitive value\n\n> oco.toString() // shows [object Object]\n> ocn.toString() // throws error: ocn.toString is not a function\n\n> oco.valueOf() // shows {}\n> ocn.valueOf() // throws error: ocn.valueOf is not a function\n\n> oco.hasOwnProperty(\"p\") // shows \"true\"\n> ocn.hasOwnProperty(\"p\") // throws error: ocn.hasOwnProperty is not a function\n\n> oco.constructor // shows \"Object() { [native code] }\"\n> ocn.constructor // shows \"undefined\"\n
As said, these differences can make debugging even simple-seeming problems quickly go astray. For example:
A simple common debugging function:
// display top-level property name:value pairs of given object\nfunction ShowProperties( b ){\n for( var i in b ){ console.log( i + \": \" + b[i] + \"\\n\" ) }\n}
Not such simple results: (especially if silent error-trapping had hidden the error messages)
ob={}; ob.po=oco; ob.pn=ocn; // create a compound object using the test objects from above as property values\n\n> ShowProperties( ob ) // display top-level properties\n- po: [object Object]\n- Error: Cannot convert object to primitive value\n\nNote that only first property gets shown.\n
(But if same object is created simply in different order -- at least in some implementations...)
ob={}; ob.pn=ocn; ob.po=oco; // create same compound object again, but create same properties in different order\n\n> ShowProperties( ob ) // display top-level properties\n- Error: Cannot convert object to primitive value\n\nNote that neither property gets shown. Note that such a different order may arise statically via disparate fixed codings such as here, but also dynamically via whatever the order any such property-adding code-branches actually get executed at runtime as depends on inputs and/or random-variables. Then again, the actual iteration order is not guaranteed no matter what the order members are added.
A good solution for the missing object-methods is not immediately apparent.
Adding the missing object-method directly from the standard-object does NOT work:
ocn = Object.create( null ); // create \"null\" object (same as before)\n\nocn.toString = Object.toString; // since new object lacks method then try assigning it directly from standard-object\n\n> ocn.toString // shows \"toString() { [native code] }\" -- missing method seems to be there now\n> ocn.toString == Object.toString // shows \"true\" -- method seems to be same as the standard object-method\n\n> ocn.toString() // error: Function.prototype.toString requires that 'this' be a Function\n
Adding the missing object-method directly to new object's \"prototype\" does not work either, since new object does not have a real prototype (which is really the cause of ALL these problems) and one cannot be directly added:
ocn = Object.create( null ); // create \"null\" object (same as before)\n\nocn.prototype.toString = Object.toString; // Error: Cannot set property 'toString' of undefined\n\nocn.prototype = {}; // try to create a prototype\nocn.prototype.toString = Object.toString; // since new object lacks method then try assigning it from standard-object \n\n> ocn.toString() // error: ocn.toString is not a function\n
Adding the missing object-method by using the standard-objectas new object's prototype does not work either:
ocn = Object.create( null ); // create \"null\" object (same as before) \nObject.setPrototypeOf(ocn, Object); // set new object's prototype to the standard-object\n\n> ocn.toString() // error: Function.prototype.toString requires that 'this' be a Function\n
Again, adding the missing object-method directly from the standard-object does NOT work. However, adding the generic method directly, DOES:
ocn = Object.create( null ); // create \"null\" object (same as before)\n\nocn.toString = toString; // since new object lacks method then assign it directly from generic version\n\n> ocn.toString() // shows \"[object Object]\"\n> \"ocn is: \" + ocn // shows \"ocn is: [object Object]\"\n\n\nob={}; ob.pn=ocn; ob.po=oco; // create a compound object (same as before)\n\n> ShowProperties(ob) // display top-level properties\n- po: [object Object]\n- pn: [object Object]\n However, setting the generic prototype as the new object's prototype works even better:
ocn = Object.create( null ); // create \"null\" object (same as before)\nObject.setPrototypeOf(ocn, Object.prototype); // set new object's prototype to the \"generic\" object (NOT standard-object)\n
(In addition to all the string-related functions shown above, this also adds:)
> ocn.valueOf() // shows {}\n> ocn.hasOwnProperty(\"x\") // shows \"false\"\n> ocn.constructor // shows \"Object() { [native code] }\"\n\n// ...and all the rest of the properties and methods of Object.prototype.\n As shown, objects modified this way now look very much like ordinary objects.
This polyfill covers the main use case, which is creating a new object for which the prototype has been chosen but doesn't take the second argument into account.
Note that while the setting of null as [[Prototype]] is supported in the real ES5 Object.create, this polyfill cannot support it due to a limitation inherent in versions of ECMAScript lower than 5.
if (typeof Object.create !== \"function\") {\n Object.create = function (proto, propertiesObject) {\n if (typeof proto !== 'object' && typeof proto !== 'function') {\n throw new TypeError('Object prototype may only be an Object: ' + proto);\n } else if (proto === null) {\n throw new Error(\"This browser's implementation of Object.create is a shim and doesn't support 'null' as the first argument.\");\n }\n\n if (typeof propertiesObject != 'undefined') {\n throw new Error(\"This browser's implementation of Object.create is a shim and doesn't support a second argument.\");\n }\n\n function F() {}\n F.prototype = proto;\n\n return new F();\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.create' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.create' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.create' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n5 | \nYes | \n4 | \n9 | \n11.6 | \n5 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \n11.5 | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Object.defineProperty()Object.defineProperties()Object.prototype.isPrototypeOf()Reflect.construct()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create\n
The Object.isSealed() method determines if an object is sealed.
Object.isSealed(obj)
objA Boolean indicating whether or not the given object is sealed.
Returns true if the object is sealed, otherwise false. An object is sealed if it is not extensible and if all its properties are non-configurable and therefore not removable (but not necessarily non-writable).
// Objects aren't sealed by default.\nvar empty = {};\nObject.isSealed(empty); // === false\n\n// If you make an empty object non-extensible,\n// it is vacuously sealed.\nObject.preventExtensions(empty);\nObject.isSealed(empty); // === true\n\n// The same is not true of a non-empty object,\n// unless its properties are all non-configurable.\nvar hasProp = { fee: 'fie foe fum' };\nObject.preventExtensions(hasProp);\nObject.isSealed(hasProp); // === false\n\n// But make them all non-configurable\n// and the object becomes sealed.\nObject.defineProperty(hasProp, 'fee', {\n configurable: false\n});\nObject.isSealed(hasProp); // === true\n\n// The easiest way to seal an object, of course,\n// is Object.seal.\nvar sealed = {};\nObject.seal(sealed);\nObject.isSealed(sealed); // === true\n\n// A sealed object is, by definition, non-extensible.\nObject.isExtensible(sealed); // === false\n\n// A sealed object might be frozen,\n// but it doesn't have to be.\nObject.isFrozen(sealed); // === true \n// (all properties also non-writable)\n\nvar s2 = Object.seal({ p: 3 });\nObject.isFrozen(s2); // === false \n// ('p' is still writable)\n\nvar s3 = Object.seal({ get p() { return 0; } });\nObject.isFrozen(s3); // === true\n// (only configurability matters for accessor properties)\n In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. In ES2015, a non-object argument will be treated as if it was a sealed ordinary object, simply return true.
Object.isSealed(1);\n// TypeError: 1 is not an object (ES5 code)\n\nObject.isSealed(1);\n// true (ES2015 code)\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.isSealed' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.isSealed' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.isSealed' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed\n
The delete() method removes the specified element from a WeakSet object.
ws.delete(value);
WeakSet object.true if an element in the WeakMap object has been removed successfully. false if the key is not found in the WeakMap or if the key is not an object.
delete methodvar ws = new WeakSet();\nvar obj = {};\n\nws.add(window);\n\nws.delete(obj); // Returns false. No obj found to be deleted.\nws.delete(window); // Returns true. Successfully removed.\n\nws.has(window); // Returns false. The window is no longer present in the WeakSet.\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakSet.prototype.delete' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakSet.prototype.delete' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \nYes | \n34 | \nNo | \n23 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \nYes | \n34 | \n23 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet/delete\n
The has() method returns a boolean indicating whether an object exists in a WeakSet or not.
ws.has(value);
WeakSet.true if an element with the specified value exists in the WeakSet object; otherwise false.has methodvar ws = new WeakSet();\nvar obj = {};\nws.add(window);\n\nmySet.has(window); // returns true\nmySet.has(obj); // returns false\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakSet.prototype.has' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakSet.prototype.has' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \nYes | \n34 | \nNo | \n23 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \nYes | \n34 | \n23 | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet/has\n
The delete() method removes the specified element from a WeakMap object.
wm.delete(key);
WeakMap object.true if an element in the WeakMap object has been removed successfully. false if the key is not found in the WeakMap or if the key is not an object.
delete methodvar wm = new WeakMap();\nwm.set(window, 'foo');\n\nwm.delete(window); // Returns true. Successfully removed.\n\nwm.has(window); // Returns false. The window object is no longer in the WeakMap.\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakMap.prototype.delete' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakMap.prototype.delete' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \nYes | \n 6\n
| \n11 | \n23 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \nYes | \n 6\n
| \n23 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/delete\n
The has() method returns a boolean indicating whether an element with the specified key exists in the WeakMap object or not.
wm.has(key);
WeakMap object.true if an element with the specified key exists in the WeakMap object; otherwise false.has methodvar wm = new WeakMap();\nwm.set(window, 'foo');\n\nwm.has(window); // returns true\nwm.has('baz'); // returns false\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakMap.prototype.has' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakMap.prototype.has' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \nYes | \n 6\n
| \n11 | \n23 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \nYes | \n 6\n
| \n23 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/has\n
The Object.keys() method returns an array of a given object's own property names, in the same order as we get with a normal loop.
Object.keys(obj)
objAn array of strings that represent all the enumerable properties of the given object.
Object.keys() returns an array whose elements are strings corresponding to the enumerable properties found directly upon object. The ordering of the properties is the same as that given by looping over the properties of the object manually.
// simple array\nvar arr = ['a', 'b', 'c'];\nconsole.log(Object.keys(arr)); // console: ['0', '1', '2']\n\n// array like object\nvar obj = { 0: 'a', 1: 'b', 2: 'c' };\nconsole.log(Object.keys(obj)); // console: ['0', '1', '2']\n\n// array like object with random key ordering\nvar anObj = { 100: 'a', 2: 'b', 7: 'c' };\nconsole.log(Object.keys(anObj)); // console: ['2', '7', '100']\n\n// getFoo is a property which isn't enumerable\nvar myObj = Object.create({}, {\n getFoo: {\n value: function () { return this.foo; }\n } \n});\nmyObj.foo = 1;\nconsole.log(Object.keys(myObj)); // console: ['foo']\n If you want all properties, even non-enumerables, see Object.getOwnPropertyNames().
In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. In ES2015, a non-object argument will be coerced to an object.
Object.keys('foo');\n// TypeError: \"foo\" is not an object (ES5 code)\n\nObject.keys('foo');\n// [\"0\", \"1\", \"2\"] (ES2015 code)\n To add compatible Object.keys support in older environments that do not natively support it, copy the following snippet:
// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys\nif (!Object.keys) {\n Object.keys = (function() {\n 'use strict';\n var hasOwnProperty = Object.prototype.hasOwnProperty,\n hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'),\n dontEnums = [\n 'toString',\n 'toLocaleString',\n 'valueOf',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'constructor'\n ],\n dontEnumsLength = dontEnums.length;\n\n return function(obj) {\n if (typeof obj !== 'function' && (typeof obj !== 'object' || obj === null)) {\n throw new TypeError('Object.keys called on non-object');\n }\n\n var result = [], prop, i;\n\n for (prop in obj) {\n if (hasOwnProperty.call(obj, prop)) {\n result.push(prop);\n }\n }\n\n if (hasDontEnumBug) {\n for (i = 0; i < dontEnumsLength; i++) {\n if (hasOwnProperty.call(obj, dontEnums[i])) {\n result.push(dontEnums[i]);\n }\n }\n }\n return result;\n };\n }());\n}\n Please note that the above code includes non-enumerable keys in IE7 (and maybe IE8), when passing in an object from a different window.
For a simple Browser Polyfill, see Javascript - Object.keys Browser Compatibility.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.keys' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.keys' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.keys' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n5 | \nYes | \n4 | \n9 | \n12 | \n5 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Object.prototype.propertyIsEnumerable()Object.create()Object.getOwnPropertyNames()Object.values()Object.entries()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys\n
The Object.seal() method seals an object, preventing new properties from being added to it and marking all existing properties as non-configurable. Values of present properties can still be changed as long as they are writable.
Object.seal(obj)
The object being sealed.
By default, objects are extensible (new properties can be added to them). Sealing an object prevents new properties from being added and marks all existing properties as non-configurable. This has the effect of making the set of properties on the object fixed and immutable. Making all properties non-configurable also prevents them from being converted from data properties to accessor properties and vice versa, but it does not prevent the values of data properties from being changed. Attempting to delete or add properties to a sealed object, or to convert a data property to accessor or vice versa, will fail, either silently or by throwing a TypeError (most commonly, although not exclusively, when in strict mode code).
The prototype chain remains untouched. However, the __proto__ property is sealed as well.
Returns a reference to the passed object.
var obj = {\n prop: function() {},\n foo: 'bar'\n};\n\n// New properties may be added, existing properties\n// may be changed or removed.\nobj.foo = 'baz';\nobj.lumpy = 'woof';\ndelete obj.prop;\n\nvar o = Object.seal(obj);\n\no === obj; // true\nObject.isSealed(obj); // === true\n\n// Changing property values on a sealed object\n// still works.\nobj.foo = 'quux';\n\n// But you can't convert data properties to accessors,\n// or vice versa.\nObject.defineProperty(obj, 'foo', {\n get: function() { return 'g'; }\n}); // throws a TypeError\n\n// Now any changes, other than to property values,\n// will fail.\nobj.quaxxor = 'the friendly duck';\n// silently doesn't add the property\ndelete obj.foo;\n// silently doesn't delete the property\n\n// ...and in strict mode such attempts\n// will throw TypeErrors.\nfunction fail() {\n 'use strict';\n delete obj.foo; // throws a TypeError\n obj.sparky = 'arf'; // throws a TypeError\n}\nfail();\n\n// Attempted additions through\n// Object.defineProperty will also throw.\nObject.defineProperty(obj, 'ohai', {\n value: 17\n}); // throws a TypeError\nObject.defineProperty(obj, 'foo', {\n value: 'eit'\n}); // changes existing property value\n In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError. In ES2015, a non-object argument will be treated as if it was a sealed ordinary object, simply return it.
Object.seal(1);\n// TypeError: 1 is not an object (ES5 code)\n\nObject.seal(1);\n// 1 (ES2015 code)\n
Object.freeze()\nExisting properties in objects frozen with Object.freeze() are made immutable. Objects sealed with Object.seal() can have their existing properties changed.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'Object.seal' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.5. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.seal' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.seal' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n6 | \nYes | \n4 | \n9 | \n12 | \n5.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
Object.isSealed()Object.preventExtensions()Object.isExtensible()Object.freeze()Object.isFrozen()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal\n
The WeakMap.prototype property represents the prototype for the WeakMap constructor.
Property attributes of WeakMap.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
WeakMap instances inherit from WeakMap.prototype. You can use the constructor's prototype object to add properties or methods to all WeakMap instances.
WeakMap.prototype is itself just an ordinary object:
Object.prototype.toString.call(WeakMap.prototype); // \"[object Object]\"
WeakMap.prototype.constructorWeakMap function by default.WeakMap.prototype.delete(key)key. WeakMap.prototype.has(key) will return false afterwards.WeakMap.prototype.get(key)key, or undefined if there is none.WeakMap.prototype.has(key)key in the WeakMap object or not.WeakMap.prototype.set(key, value)key in the WeakMap object. Returns the WeakMap object.WeakMap.prototype.clear() WeakMap object. Note that it is possible to implement a WeakMap-like object that has a .clear() method by encapsulating a WeakMap object that hasn't it (see example on page WeakMap)| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakMap.prototype' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakMap.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \nYes | \n6 | \n11 | \n23 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \nYes | \n6 | \n23 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/prototype\n
The get() method returns a specified element from a WeakMap object.
wm.get(key);
WeakMap object.The element associated with the specified key in the WeakMap object. If the key can't be found, undefined is returned.
get methodvar wm = new WeakMap();\nwm.set(window, 'foo');\n\nwm.get(window); // Returns \"foo\".\nwm.get('baz'); // Returns undefined.\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakMap.prototype.get' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakMap.prototype.get' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \nYes | \n 6\n
| \n11 | \n23 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \nYes | \n 6\n
| \n23 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/get\n
The WebAssembly.compileStreaming() function compiles a WebAssembly.Module directly from a streamed underlying source. This function is useful if it is necessary to a compile a module before it can be instantiated (otherwise, the WebAssembly.instantiateStreaming() function should be used).
Promise<WebAssembly.Module> WebAssembly.compileStreaming(source);
Response object or a promise that will fulfill with one, representing the underlying source of a .wasm module you want to stream and compile.A Promise that resolves to a WebAssembly.Module object representing the compiled module.
bufferSource is not a typed array, a TypeError is thrown.WebAssembly.CompileError.The following example (see our compile-streaming.html demo on GitHub, and view it live also) directly streams a .wasm module from an underlying source then compiles it to a WebAssembly.Module object. Because the compileStreaming() function accepts a promise for a Response object, you can directly pass it a WindowOrWorkerGlobalScope.fetch() call, and it will pass the response into the function when it fulfills.
var importObject = { imports: { imported_func: arg => console.log(arg) } };\n\nWebAssembly.compileStreaming(fetch('simple.wasm'))\n.then(module => WebAssembly.instantiate(module, importObject))\n.then(instance => instance.exports.exported_func()); The resulting module instance is then instantiated using WebAssembly.instantiate(), and the exported function invoked.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly features for web embedding The definition of 'compileStreaming()' in that specification. | Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n61 | \n16 | \n58 | \nNo | \n47 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n61 | \n61 | \nNo | \n58 | \n? | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming\n
A WebAssembly.Global object represents a global variable instance, accessible from both JavaScript and importable/exportable across one or more WebAssembly.Module instances. This allows dynamic linking of multiple modules.
var myGlobal = new WebAssembly.Global(descriptor, value);
GlobalDescriptor dictionary object, which contains two properties: value: A USVString representing the data type of the global. This can be one of i32, i64, f32, and f64.mutable: A boolean value that determines whether the global is mutable or not. By default, this is false.DefaultValue algorithm.None.
All Global instances inherit from the Global() constructor's prototype object — this can be modified to affect all Global instances.
Global.prototype.constructorWebAssembly.Global() constructor.Global.prototype[@@toStringTag]Global.prototype.valueGlobal.prototype.valueOf()The following example shows a new global instance being created using the WebAssembly.Global() constructor. It is being defined as a mutable i32 type, with a value of 0.
The value of the global is then changed, first to 42 using the Global.value property, and then to 43 using the incGlobal() function exported out of the global.wasm module (this adds 1 to whatever value is given to it and then returns the new value).
const output = document.getElementById('output');\n\nfunction assertEq(msg, got, expected) {\n output.innerHTML += `Testing ${msg}: `;\n if (got !== expected)\n output.innerHTML += `FAIL!<br>Got: ${got}<br>Expected: ${expected}<br>`;\n else\n output.innerHTML += `SUCCESS! Got: ${got}<br>`;\n}\n\nassertEq(\"WebAssembly.Global exists\", typeof WebAssembly.Global, \"function\");\n\nconst global = new WebAssembly.Global({value:'i32', mutable:true}, 0);\n\nWebAssembly.instantiateStreaming(fetch('global.wasm'), { js: { global } })\n.then(({instance}) => {\n assertEq(\"getting initial value from wasm\", instance.exports.getGlobal(), 0);\n global.value = 42;\n assertEq(\"getting JS-updated value from wasm\", instance.exports.getGlobal(), 42);\n instance.exports.incGlobal();\n assertEq(\"getting wasm-updated value from JS\", global.value, 43);\n}); Note: You can see the example running live on GitHub; see also the source code.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly.Global()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n69 | \nNo | \n62 | \nNo | \nNo | \nNo | \n
value | \n69 | \nNo | \n62 | \nNo | \nNo | \nNo | \n
valueOf | \n69 | \nNo | \n62 | \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n69 | \n69 | \nNo | \n62 | \nNo | \nNo | \nNo | \n
value | \n69 | \n69 | \nNo | \n62 | \nNo | \nNo | \nNo | \n
valueOf | \n69 | \n69 | \nNo | \n62 | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
value | \nNo | \n
valueOf | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global\n
The WebAssembly.compile() function compiles a WebAssembly.Module from WebAssembly binary code. This function is useful if it is necessary to a compile a module before it can be instantiated (otherwise, the WebAssembly.instantiate() function should be used).
Promise<WebAssembly.Module> WebAssembly.compile(bufferSource);
A Promise that resolves to a WebAssembly.Module object representing the compiled module.
bufferSource is not a typed array, a TypeError is thrown.WebAssembly.CompileError.The following example compiles the loaded simple.wasm byte code using the compile() function and then sends it to a worker using postMessage().
var worker = new Worker(\"wasm_worker.js\");\n\nfetch('simple.wasm').then(response =>\n response.arrayBuffer()\n).then(bytes =>\n WebAssembly.compile(bytes)\n).then(mod =>\n worker.postMessage(mod)\n); Note: You'll probably want to use WebAssembly.compileStreaming() in most cases, as it is more efficient than compile().
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'compile()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n44 | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compile\n
The Object.values() method returns an array of a given object's own enumerable property values, in the same order as that provided by a for...in loop (the difference being that a for-in loop enumerates properties in the prototype chain as well).
Object.values(obj)
objAn array containing the given object's own enumerable property values.
Object.values() returns an array whose elements are the enumerable property values found on the object. The ordering of the properties is the same as that given by looping over the property values of the object manually.
var obj = { foo: 'bar', baz: 42 };\nconsole.log(Object.values(obj)); // ['bar', 42]\n\n// array like object\nvar obj = { 0: 'a', 1: 'b', 2: 'c' };\nconsole.log(Object.values(obj)); // ['a', 'b', 'c']\n\n// array like object with random key ordering\n// when we use numeric keys, the value returned in a numerical order according to the keys\nvar an_obj = { 100: 'a', 2: 'b', 7: 'c' };\nconsole.log(Object.values(an_obj)); // ['b', 'c', 'a']\n\n// getFoo is property which isn't enumerable\nvar my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });\nmy_obj.foo = 'bar';\nconsole.log(Object.values(my_obj)); // ['bar']\n\n// non-object argument will be coerced to an object\nconsole.log(Object.values('foo')); // ['f', 'o', 'o']\n To add compatible Object.values support in older environments that do not natively support it, you can find a Polyfill in the tc39/proposal-object-values-entries or in the es-shims/Object.values repositories.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'Object.values' in that specification. | Draft | Initial definition. |
| ECMAScript 2017 (ECMA-262) The definition of 'Object.values' in that specification. | Standard |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n54 | \n14 | \n47 | \nNo | \n41 | \n10.1 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n54 | \n54 | \nYes | \n47 | \n41 | \n10.3 | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 7.0.0\n
| \n
Object.keys()Object.entries()Object.prototype.propertyIsEnumerable()Object.create()Object.getOwnPropertyNames()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values\n
The set() method adds a new element with a specified key and value to a WeakMap object.
wm.set(key, value);
WeakMap object.WeakMap object.The WeakMap object.
set methodvar wm = new WeakMap();\nvar obj = {};\n\n// Add new elements to the WeakMap\nwm.set(obj, 'foo').set(window, 'bar'); // chainable\n\n// Update an element in the WeakMap\nwm.set(obj, 'baz');\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'WeakMap.prototype.set' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'WeakMap.prototype.set' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n36 | \nYes | \n 6\n
| \n11\n
| \n23 | \n8 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n37 | \n36 | \nYes | \n 6\n
| \n23 | \n8 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 0.12\n
| \n
WeakMap.prototype.set returned undefined and was not chainable. This has been fixed (bug 1031632). The behavior can be found in Chrome/v8 as well (issue).\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap/set\n
The WebAssembly.validate() function validates a given typed array of WebAssembly binary code, returning whether the bytes form a valid wasm module (true) or not (false).
WebAssembly.validate(bufferSource);
bufferSourceA boolean that specifies whether bufferSource is valid wasm code (true) or not (false).
If bufferSource is not a typed array or ArrayBuffer, a TypeError is thrown.
The following example (see the validate.html source code, and see it live too) fetches a .wasm module and converts it into a typed array. The validate() method is then used to check whether the module is valid.
fetch('simple.wasm').then(response =>\n response.arrayBuffer()\n).then(function(bytes) {\n var valid = WebAssembly.validate(bytes);\n console.log(\"The given bytes are \"\n + (valid ? \"\" : \"not \") + \"a valid wasm module\");\n});\n | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'validate()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/validate\n
The WebAssembly.instantiateStreaming() function compiles and instantiates a WebAssembly module directly from a streamed underlying source. This is the most efficient, optimized way to load wasm code.
Promise<ResultObject> WebAssembly.instantiateStreaming(source, importObject);
Response object or a promise that will fulfill with one, representing the underlying source of a .wasm module you want to stream, compile, and instantiate.Instance, such as functions or WebAssembly.Memory objects. There must be one matching property for each declared import of the compiled module or else a WebAssembly.LinkError is thrown.A Promise that resolves to a ResultObject which contains two fields:
module: A WebAssembly.Module object representing the compiled WebAssembly module. This Module can be instantiated again or shared via postMessage().instance: A WebAssembly.Instance object that contains all the Exported WebAssembly functions.TypeError is thrown.WebAssembly.CompileError, WebAssembly.LinkError, or WebAssembly.RuntimeError, depending on the cause of the failure.The following example (see our instantiate-streaming.html demo on GitHub, and view it live also) directly streams a .wasm module from an underlying source then compiles and instantiates it, the promise fulfilling with a ResultObject. Because the instantiateStreaming() function accepts a promise for a Response object, you can directly pass it a WindowOrWorkerGlobalScope.fetch() call, and it will pass the response into the function when it fulfills.
var importObject = { imports: { imported_func: arg => console.log(arg) } };\n\nWebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)\n.then(obj => obj.instance.exports.exported_func()); The ResultObject's instance member is then accessed, and the contained exported function invoked.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly features for web embedding The definition of 'instantiateStreaming()' in that specification. | Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n61 | \n16 | \n58 | \nNo | \n47 | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n61 | \n61 | \nNo | \n58 | \n? | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming\n
The WebAssembly.instantiate() function allows you to compile and instantiate WebAssembly code. This function has two overloads:
Promise resolves to both a compiled WebAssembly.Module and its first WebAssembly.Instance.WebAssembly.Module and returns a Promise that resolves to an Instance of that Module. This overload is useful if the Module has already been compiled.Important: This method is not the most efficient way of fetching and instantiating wasm modules. If at all possible, you should use the newer WebAssembly.instantiateStreaming() method instead, which fetches, compiles, and instantiates a module all in one step, directly from the raw bytecode, so doesn't require conversion to an ArrayBuffer.
Promise<ResultObject> WebAssembly.instantiate(bufferSource, importObject);\n
Instance, such as functions or WebAssembly.Memory objects. There must be one matching property for each declared import of the compiled module or else a WebAssembly.LinkError is thrown.A Promise that resolves to a ResultObject which contains two fields:
module: A WebAssembly.Module object representing the compiled WebAssembly module. This Module can be instantiated again, shared via postMessage() or cached in IndexedDB.instance: A WebAssembly.Instance object that contains all the Exported WebAssembly functions.TypeError is thrown.WebAssembly.CompileError, WebAssembly.LinkError, or WebAssembly.RuntimeError, depending on the cause of the failure.Promise<WebAssembly.Instance> WebAssembly.instantiate(module, importObject);\n
WebAssembly.Module object to be instantiated.Instance, such as functions or WebAssembly.Memory objects. There must be one matching property for each declared import of module or else a WebAssembly.LinkError is thrown.A Promise that resolves to an WebAssembly.Instance object.
TypeError is thrown.WebAssembly.CompileError, WebAssembly.LinkError, or WebAssembly.RuntimeError, depending on the cause of the failure.Note: You'll probably want to use WebAssembly.instantiateStreaming() in most cases, as it is more efficient than instantiate().
After fetching some WebAssembly bytecode using fetch, we compile and instantiate the module using the WebAssembly.instantiate() function, importing a JavaScript function into the WebAssembly Module in the process. We then call an Exported WebAssembly function that is exported by the Instance.
var importObject = {\n imports: {\n imported_func: function(arg) {\n console.log(arg);\n }\n }\n};\n\nfetch('simple.wasm').then(response =>\n response.arrayBuffer()\n).then(bytes =>\n WebAssembly.instantiate(bytes, importObject)\n).then(result =>\n result.instance.exports.exported_func()\n); Note: You can also find this example at index.html on GitHub (view it live also).
The following example (see our index-compile.html demo on GitHub, and view it live also) compiles the loaded simple.wasm byte code using the WebAssembly.compileStreaming() method and then sends it to a worker using postMessage().
var worker = new Worker(\"wasm_worker.js\");\n\nWebAssembly.compileStreaming(fetch('simple.wasm'))\n.then(mod =>\n worker.postMessage(mod)\n); In the worker (see wasm_worker.js) we define an import object for the module to use, then set up an event handler to receive the module from the main thread. When the module is received, we create an instance from it using the WebAssembly.instantiate() method and invoke an exported function from inside it.
var importObject = {\n imports: {\n imported_func: function(arg) {\n console.log(arg);\n }\n }\n};\n\nonmessage = function(e) {\n console.log('module received from main thread');\n var mod = e.data;\n\n WebAssembly.instantiate(mod, importObject).then(function(instance) {\n instance.exports.exported_func();\n });\n}; | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'instantiate()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate\n
The static String.fromCharCode() method returns a string created from the specified sequence of UTF-16 code units.
String.fromCharCode(num1[, ...[, numN]])
num1, ..., numNA string of length N consisting of the N specified UTF-16 code units.
This method returns a string and not a String object.
Because fromCharCode() is a static method of String, you always use it as String.fromCharCode(), rather than as a method of a String object you created.
fromCharCode()\nThe following example returns the string \"ABC\".
String.fromCharCode(65, 66, 67); // returns \"ABC\"\nString.fromCharCode(0x2014) // returns \"—\"\nString.fromCharCode(0x12014) // also returns \"—\"; the digit 1 is truncated and ignored\n
Although most common Unicode values can be represented with one 16-bit number (as expected early on during JavaScript standardization) and fromCharCode() can be used to return a single character for the most common values (i.e., UCS-2 values which are the subset of UTF-16 with the most common characters), in order to deal with ALL legal Unicode values (up to 21 bits), fromCharCode() alone is inadequate. Since the higher code point characters use two (lower value) \"surrogate\" numbers to form a single character, String.fromCodePoint() (part of the ES2015 standard) can be used to return such a pair and thus adequately represent these higher valued characters.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'StringfromCharCode' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.fromCharCode' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.fromCharCode' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
String.fromCodePoint()String.prototype.charAt()String.prototype.charCodeAt()String.prototype.codePointAt()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCharCode\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The blink() method creates a <blink> HTML element that causes a string to blink.
Warning: Blinking text is frowned upon by several accessibility standards. The <blink> element itself is non-standard and deprecated!
str.blink()
A string containing a <blink> HTML element.
The blink() method embeds a string in a <blink> tag: \"<blink>str</blink>\".
blink()\nThe following example uses string methods to change the formatting of a string:
var worldString = 'Hello, world';\n\nconsole.log(worldString.blink()); // <blink>Hello, world</blink>\nconsole.log(worldString.bold()); // <b>Hello, world</b>\nconsole.log(worldString.italics()); // <i>Hello, world</i>\nconsole.log(worldString.strike()); // <strike>Hello, world</strike>
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.blink' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.blink' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/blink\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The bold() method creates a <b> HTML element that causes a string to be displayed as bold.
str.bold()
A string containing a <b> HTML element.
The bold() method embeds a string in a <b> tag: \"<b>str</b>\".
bold()\nThe following example uses string methods to change the formatting of a string:
var worldString = 'Hello, world';\n\nconsole.log(worldString.blink()); // <blink>Hello, world</blink>\nconsole.log(worldString.bold()); // <b>Hello, world</b>\nconsole.log(worldString.italics()); // <i>Hello, world</i>\nconsole.log(worldString.strike()); // <strike>Hello, world</strike>
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.bold' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.bold' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/bold\n
The length property of a String object indicates the length of a string, in UTF-16 code units.
str.length
This property returns the number of code units in the string. UTF-16, the string format used by JavaScript, uses a single 16-bit code unit to represent the most common characters, but needs to use two code units for less commonly-used characters, so it's possible for the value returned by length to not match the actual number of characters in the string.
ECMASCript 2016 (ed. 7) established a maximum length of 2^53 - 1 elements. Previously, no maximum length was specified.
For an empty string, length is 0.
The static property String.length returns the value 1.
var x = 'Mozilla';\nvar empty = '';\n\nconsole.log('Mozilla is ' + x.length + ' code units long');\n/* \"Mozilla is 7 code units long\" */\n\nconsole.log('The empty string has a length of ' + empty.length);\n/* \"The empty string has a length of 0\" */ var myString = \"bluebells\";\n\n// Attempting to assign a value to a string's .length property has no observable effect. \nmyString.length = 4;\nconsole.log(myString);\n/* \"bluebells\" */\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.length' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.length' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.length' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The big() method creates a <big> HTML element that causes a string to be displayed in a big font.
Usage note: The <big> element has been removed in HTML5 and shouldn't be used anymore. Instead web developers should use CSS properties.
str.big()
A string containing a <big> HTML element.
The big() method embeds a string in a <big> tag: \"<big>str</big>\".
big()\nThe following example uses string methods to change the size of a string:
var worldString = 'Hello, world';\n\nconsole.log(worldString.small()); // <small>Hello, world</small>\nconsole.log(worldString.big()); // <big>Hello, world</big>\nconsole.log(worldString.fontsize(7)); // <fontsize=7>Hello, world</fontsize>\n
With the element.style object you can get the element's style attribute and manipulate it more generically, for example:
document.getElementById('yourElemId').style.fontSize = '2em';\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.big' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.big' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/big\n
The codePointAt() method returns a non-negative integer that is the Unicode code point value.
str.codePointAt(pos)
posA number representing the code point value of the character at the given index; undefined if there is no element at pos.
If there is no element at the specified position, undefined is returned. If no UTF-16 surrogate pair begins at pos, the code unit at pos is returned.
codePointAt()\n'ABC'.codePointAt(1); // 66\n'\\uD800\\uDC00'.codePointAt(0); // 65536\n\n'XYZ'.codePointAt(42); // undefined\n
The following extends Strings to include the codePointAt() function as specified in ECMAScript 2015 for browsers not supporting it natively.
/*! https://mths.be/codepointat v0.2.0 by @mathias */\nif (!String.prototype.codePointAt) {\n (function() {\n 'use strict'; // needed to support `apply`/`call` with `undefined`/`null`\n var defineProperty = (function() {\n // IE 8 only supports `Object.defineProperty` on DOM elements\n try {\n var object = {};\n var $defineProperty = Object.defineProperty;\n var result = $defineProperty(object, object, object) && $defineProperty;\n } catch(error) {}\n return result;\n }());\n var codePointAt = function(position) {\n if (this == null) {\n throw TypeError();\n }\n var string = String(this);\n var size = string.length;\n // `ToInteger`\n var index = position ? Number(position) : 0;\n if (index != index) { // better `isNaN`\n index = 0;\n }\n // Account for out-of-bounds indices:\n if (index < 0 || index >= size) {\n return undefined;\n }\n // Get the first code unit\n var first = string.charCodeAt(index);\n var second;\n if ( // check if it’s the start of a surrogate pair\n first >= 0xD800 && first <= 0xDBFF && // high surrogate\n size > index + 1 // there is a next code unit\n ) {\n second = string.charCodeAt(index + 1);\n if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate\n // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;\n }\n }\n return first;\n };\n if (defineProperty) {\n defineProperty(String.prototype, 'codePointAt', {\n 'value': codePointAt,\n 'configurable': true,\n 'writable': true\n });\n } else {\n String.prototype.codePointAt = codePointAt;\n }\n }());\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.codePointAt' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.codePointAt' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n41 | \nYes | \n29 | \nNo | \n28 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n29 | \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
String.fromCodePoint()String.fromCharCode()String.prototype.charCodeAt()String.prototype.charAt()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt\n
The static String.fromCodePoint() method returns a string created by using the specified sequence of code points.
String.fromCodePoint(num1[, ...[, numN]])
num1, ..., numNA string created by using the specified sequence of code points.
RangeError is thrown if an invalid Unicode code point is given (e.g. \"RangeError: NaN is not a valid code point\").This method returns a string and not a String object.
Because fromCodePoint() is a static method of String, you always use it as String.fromCodePoint(), rather than as a method of a String object you created.
fromCodePoint()\nString.fromCodePoint(42); // \"*\"\nString.fromCodePoint(65, 90); // \"AZ\"\nString.fromCodePoint(0x404); // \"\\u0404\"\nString.fromCodePoint(0x2F804); // \"\\uD87E\\uDC04\"\nString.fromCodePoint(194564); // \"\\uD87E\\uDC04\"\nString.fromCodePoint(0x1D306, 0x61, 0x1D307) // \"\\uD834\\uDF06a\\uD834\\uDF07\"\n\nString.fromCodePoint('_'); // RangeError\nString.fromCodePoint(Infinity); // RangeError\nString.fromCodePoint(-1); // RangeError\nString.fromCodePoint(3.14); // RangeError\nString.fromCodePoint(3e-2); // RangeError\nString.fromCodePoint(NaN); // RangeError\n // String.fromCharCode() alone cannot get the character at such a high code point\n// The following, on the other hand, can return a 4-byte character as well as the\n// usual 2-byte ones (i.e., it can return a single character which actually has\n// a string length of 2 instead of 1!)\nconsole.log(String.fromCodePoint(0x2F804)); // or 194564 in decimal\n
The String.fromCodePoint method has been added to ECMAScript 2015 and may not be supported in all web browsers or environments yet. Use the code below for a polyfill:
if (!String.fromCodePoint) (function(stringFromCharCode) {\n var fromCodePoint = function(_) {\n var codeUnits = [], codeLen = 0, result = \"\";\n for (var index=0, len = arguments.length; index !== len; ++index) {\n var codePoint = +arguments[index];\n // correctly handles all cases including `NaN`, `-Infinity`, `+Infinity`\n // The surrounding `!(...)` is required to correctly handle `NaN` cases\n // The (codePoint>>>0) === codePoint clause handles decimals and negatives\n if (!(codePoint < 0x10FFFF && (codePoint>>>0) === codePoint))\n throw RangeError(\"Invalid code point: \" + codePoint);\n if (codePoint <= 0xFFFF) { // BMP code point\n codeLen = codeUnits.push(codePoint);\n } else { // Astral code point; split in surrogate halves\n // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n codePoint -= 0x10000;\n codeLen = codeUnits.push(\n (codePoint >> 10) + 0xD800, // highSurrogate\n (codePoint % 0x400) + 0xDC00 // lowSurrogate\n );\n }\n if (codeLen >= 0x3fff) {\n result += stringFromCharCode.apply(null, codeUnits);\n codeUnits.length = 0;\n }\n }\n return result + stringFromCharCode.apply(null, codeUnits);\n };\n try { // IE 8 only supports `Object.defineProperty` on DOM elements\n Object.defineProperty(String, \"fromCodePoint\", {\n \"value\": fromCodePoint, \"configurable\": true, \"writable\": true\n });\n } catch(e) {\n String.fromCodePoint = fromCodePoint;\n }\n}(String.fromCharCode));\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.fromCodePoint' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.fromCodePoint' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n41 | \nYes | \n29 | \nNo | \n28 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n29 | \nYes | \n10 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
String.fromCharCode()String.prototype.charAt()String.prototype.codePointAt()String.prototype.charCodeAt()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The anchor() method creates an <a> HTML anchor element that is used as a hypertext target.
str.anchor(name)
namename attribute of the a tag to be created.A string containing an <a> HTML element.
Use the anchor() method to programmatically create and display an anchor in a document.
In the syntax, the text string represents the literal text that you want the user to see. The name parameter string represents the name attribute of the <a> element.
Anchors created with the anchor() method become elements in the document.anchors array.
anchor()\nvar myString = 'Table of Contents';\n\ndocument.body.innerHTML = myString.anchor('contents_anchor');\n will output the following HTML:
<a name=\"contents_anchor\">Table of Contents</a>\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.anchor' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
if (!String.prototype.anchor)\n String.prototype.anchor = function(x){\n return '<a name=\"' + x + '\">' + this + '</a>'\n }\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n 1\n
| \nNo | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/anchor\n
The charCodeAt() method returns an integer between 0 and 65535 representing the UTF-16 code unit at the given index.
The UTF-16 code unit matches the Unicode code point for code points that can be represented in a single UTF-16 code unit. If the Unicode code point cannot be represented in a single UTF-16 code unit (because its value is greater than 0x10000) then the code unit returned will be the first part of a surrogate pair for the code point. If you want the entire code point value, use codePointAt().
str.charCodeAt(index)
indexA number representing the UTF-16 code unit value of the character at the given index; NaN if index is out of range.
Unicode code points range from 0 to 1114111 (0x10FFFF). The first 128 Unicode code points are a direct match of the ASCII character encoding. For information on Unicode, see the JavaScript Guide.
Note that charCodeAt() will always return a value that is less than 65536. This is because the higher code points are represented by a pair of (lower valued) \"surrogate\" pseudo-characters which are used to comprise the real character. Because of this, in order to examine or reproduce the full character for individual characters of value 65536 and above, for such characters, it is necessary to retrieve not only charCodeAt(i), but also charCodeAt(i+1) (as if examining/reproducing a string with two letters), or to use codePointAt(i) instead. See example 2 and 3 below.
charCodeAt() returns NaN if the given index is less than 0 or is equal to or greater than the length of the string.
Backward compatibility: In historic versions (like JavaScript 1.2) the charCodeAt() method returns a number indicating the ISO-Latin-1 codeset value of the character at the given index. The ISO-Latin-1 codeset ranges from 0 to 255. The first 0 to 127 are a direct match of the ASCII character set.
charCodeAt()\nThe following example returns 65, the Unicode value for A.
'ABC'.charCodeAt(0); // returns 65\n
charCodeAt() to handle non-Basic-Multilingual-Plane characters if their presence earlier in the string is unknownThis version might be used in for loops and the like when it is unknown whether non-BMP characters exist before the specified index position.
function fixedCharCodeAt(str, idx) {\n // ex. fixedCharCodeAt('\\uD800\\uDC00', 0); // 65536\n // ex. fixedCharCodeAt('\\uD800\\uDC00', 1); // false\n idx = idx || 0;\n var code = str.charCodeAt(idx);\n var hi, low;\n \n // High surrogate (could change last hex to 0xDB7F\n // to treat high private surrogates \n // as single characters)\n if (0xD800 <= code && code <= 0xDBFF) {\n hi = code;\n low = str.charCodeAt(idx + 1);\n if (isNaN(low)) {\n throw 'High surrogate not followed by ' +\n 'low surrogate in fixedCharCodeAt()';\n }\n return ((hi - 0xD800) * 0x400) +\n (low - 0xDC00) + 0x10000;\n }\n if (0xDC00 <= code && code <= 0xDFFF) { // Low surrogate\n // We return false to allow loops to skip\n // this iteration since should have already handled\n // high surrogate above in the previous iteration\n return false;\n // hi = str.charCodeAt(idx - 1);\n // low = code;\n // return ((hi - 0xD800) * 0x400) +\n // (low - 0xDC00) + 0x10000;\n }\n return code;\n}\n charCodeAt() to handle non-Basic-Multilingual-Plane characters if their presence earlier in the string is knownfunction knownCharCodeAt(str, idx) {\n str += '';\n var code,\n end = str.length;\n\n var surrogatePairs = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g;\n while ((surrogatePairs.exec(str)) != null) {\n var li = surrogatePairs.lastIndex;\n if (li - 2 < idx) {\n idx++;\n }\n else {\n break;\n }\n }\n\n if (idx >= end || idx < 0) {\n return NaN;\n }\n\n code = str.charCodeAt(idx);\n\n var hi, low;\n if (0xD800 <= code && code <= 0xDBFF) {\n hi = code;\n low = str.charCodeAt(idx + 1);\n // Go one further, since one of the \"characters\"\n // is part of a surrogate pair\n return ((hi - 0xD800) * 0x400) +\n (low - 0xDC00) + 0x10000;\n }\n return code;\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.charCodeAt' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.charCodeAt' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.charCodeAt' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
String.fromCharCode()String.prototype.charAt()String.fromCodePoint()String.prototype.codePointAt()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt\n
The concat() method concatenates the string arguments to the calling string and returns a new string.
str.concat(string2[, string3, ..., stringN])
string2...stringNA new string containing the combined text of the strings provided.
The concat() function concatenates the string arguments to the calling string and returns a new string. Changes to the original string or the returned string don't affect the other. If the arguments are not of the type string, they are converted to string values before concatenating.
concat()\nThe following example combines strings into a new string.
var hello = 'Hello, ';\nconsole.log(hello.concat('Kevin', '. Have a nice day.'));\n/* Hello, Kevin. Have a nice day. */\n\nvar greetList = ['Hello', ' ', 'Venkat', '!'];\n\"\".concat(...greetList); // \"Hello Venkat!\"\n\n\"\".concat({}); // [object Object]\n\"\".concat([]); // \"\"\n\"\".concat(null); // \"null\"\n\"\".concat(true); // \"true\"\n\"\".concat(4, 5); // \"45\"\n\n It is strongly recommended that the assignment operators (+, +=) are used instead of the concat() method.
According to this performance test, the assignment operators are several times faster.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.concat' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.concat' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.concat' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat\n
The endsWith() method determines whether a string ends with the characters of a specified string, returning true or false as appropriate.
str.endsWith(searchString[, length])
searchStringlengthstr. If omitted, the default value is the length of the string.true if the given characters are found at the end of the string; otherwise, false.
This method lets you determine whether or not a string ends with another string. This method is case-sensitive.
endsWith()\nvar str = 'To be, or not to be, that is the question.';\n\nconsole.log(str.endsWith('question.')); // true\nconsole.log(str.endsWith('to be')); // false\nconsole.log(str.endsWith('to be', 19)); // true\n This method has been added to the ECMAScript 6 specification and may not be available in all JavaScript implementations yet. However, you can polyfill String.prototype.endsWith() with the following snippet:
if (!String.prototype.endsWith) {\n\tString.prototype.endsWith = function(search, this_len) {\n\t\tif (this_len === undefined || this_len > this.length) {\n\t\t\tthis_len = this.length;\n\t\t}\n\t\treturn this.substring(this_len - search.length, this_len) === search;\n\t};\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.endsWith' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.endsWith' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n41 | \nYes | \n17 | \nNo | \n28 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n36 | \nYes | \n17 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
String.prototype.startsWith()String.prototype.includes()String.prototype.indexOf()String.prototype.lastIndexOf()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The fixed() method creates a <tt> HTML element that causes a string to be displayed in fixed-pitch font.
str.fixed()
A string representing a <tt> HTML element.
The fixed() method embeds a string in a <tt> tag: \"<tt>str</tt>\".
fixed()\nThe following example uses the fixed method to change the formatting of a string:
var worldString = 'Hello, world';\nconsole.log(worldString.fixed()); // \"<tt>Hello, world</tt>\"\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.fixed' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.fixed' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fixed\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The fontsize() method creates a <font> HTML element that causes a string to be displayed in the specified font size.
Usage note: The <font> element has been removed in HTML5 and shouldn't be used anymore. Instead web developers should use CSS properties.
str.fontsize(size)
sizeA string containing a <font> HTML element.
When you specify size as an integer, you set the font size of str to one of the 7 defined sizes. When you specify size as a string such as \"-2\", you adjust the font size of str relative to the size set in the <basefont> tag.
fontsize()\nThe following example uses string methods to change the size of a string:
var worldString = 'Hello, world';\n\nconsole.log(worldString.small()); // <small>Hello, world</small>\nconsole.log(worldString.big()); // <big>Hello, world</big>\nconsole.log(worldString.fontsize(7)); // <font size=\"7\">Hello, world</fontsize>\n
With the element.style object you can get the element's style attribute and manipulate it more generically, for example:
document.getElementById('yourElemId').style.fontSize = '0.7em';\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.fontsize' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.fontsize' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fontsize\n
The String.prototype property represents the String prototype object.
Property attributes of String.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All String instances inherit from String.prototype. Changes to the String prototype object are propagated to all String instances.
String.prototype.constructorString.prototype.lengthNlength. These properties are read-only.String.prototype.charAt()String.prototype.charCodeAt()String.prototype.codePointAt()String.prototype.concat()String.prototype.includes()String.prototype.endsWith()String.prototype.indexOf()String object of the first occurrence of the specified value, or -1 if not found.String.prototype.lastIndexOf()String object of the last occurrence of the specified value, or -1 if not found.String.prototype.localeCompare()String.prototype.match()String.prototype.normalize()String.prototype.padEnd()String.prototype.padStart()String.prototype.quote() \"\").String.prototype.repeat()String.prototype.replace()String.prototype.search()String.prototype.slice()String.prototype.split()String object into an array of strings by separating the string into substrings.String.prototype.startsWith()String.prototype.substr() \nString.prototype.substring()String.prototype.toLocaleLowerCase()toLowerCase().String.prototype.toLocaleUpperCase()toUpperCase().String.prototype.toLowerCase()String.prototype.toSource() \nObject.prototype.toSource() method.String.prototype.toString()Object.prototype.toString() method.String.prototype.toUpperCase()String.prototype.trim()String.prototype.trimStart()String.prototype.trimLeft()\nString.prototype.trimEnd()String.prototype.trimRight()\nString.prototype.valueOf()Object.prototype.valueOf() method.String.prototype[@@iterator]()Iterator object that iterates over the code points of a String value, returning each code point as a String value.These methods are of limited use, as they provide only a subset of the available HTML tags and attributes.
String.prototype.anchor() \n<a name=\"name\"> (hypertext target)String.prototype.big() \n<big>String.prototype.blink() \n<blink>String.prototype.bold() \n<b>String.prototype.fixed() \n<tt>String.prototype.fontcolor() \n<font color=\"color\">String.prototype.fontsize() \n<font size=\"size\">String.prototype.italics() \n<i>String.prototype.link() \n<a href=\"url\"> (link to URL)String.prototype.small() \n<small>String.prototype.strike() \n<strike>String.prototype.sub() \n<sub>String.prototype.sup() \n<sup>| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The fontcolor() method creates a <font> HTML element that causes a string to be displayed in the specified font color.
Usage note: The <font> element has been removed in HTML5 and shouldn't be used anymore. Instead web developers should use CSS properties.
str.fontcolor(color)
colorA string containing a <font> HTML element.
If you express color as a hexadecimal RGB triplet, you must use the format rrggbb. For example, the hexadecimal RGB values for salmon are red=FA, green=80, and blue=72, so the RGB triplet for salmon is \"FA8072\".
fontcolor()\nThe following example uses the fontcolor() method to change the color of a string by producing a string with the HTML <font> tag.
var worldString = 'Hello, world';\n\nconsole.log(worldString.fontcolor('red') + ' is red in this line');\n// '<font color=\"red\">Hello, world</font> is red in this line'\n\nconsole.log(worldString.fontcolor('FF00') + ' is red in hexadecimal in this line');\n// '<font color=\"FF00\">Hello, world</font> is red in hexadecimal in this line'\n With the element.style object you can get the element's style attribute and manipulate it more generically, for example:
document.getElementById('yourElemId').style.color = 'red';\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.fontcolor' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.fontcolor' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fontcolor\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The italics() method creates an <i> HTML element that causes a string to be italic.
str.italics()
A string containing a <i> HTML element.
The italics() method embeds a string in an <i> tag: \"<i>str</i>\".
italics()\nThe following example uses string methods to change the formatting of a string:
var worldString = 'Hello, world';\nconsole.log(worldString.blink()); // <blink>Hello, world</blink>\nconsole.log(worldString.bold()); // <b>Hello, world</b>\nconsole.log(worldString.italics()); // <i>Hello, world</i>\nconsole.log(worldString.strike()); // <strike>Hello, world</strike>\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.italics' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.italics' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/italics\n
The padEnd() method pads the current string with a given string (repeated, if needed) so that the resulting string reaches a given length. The padding is applied from the end (right) of the current string.
str.padEnd(targetLength [, padString])
targetLengthpadString Optional\nA String of the specified length with the pad string applied at the end of the current string.
'abc'.padEnd(10); // \"abc \"\n'abc'.padEnd(10, \"foo\"); // \"abcfoofoof\"\n'abc'.padEnd(6, \"123456\"); // \"abc123\"\n'abc'.padEnd(1); // \"abc\"
Running the following code before any other code will create String.prototype.padEnd() if it's not natively available.
// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd\nif (!String.prototype.padEnd) {\n String.prototype.padEnd = function padEnd(targetLength,padString) {\n targetLength = targetLength>>0; //floor if number or convert non-number to 0;\n padString = String((typeof padString !== 'undefined' ? padString : ' '));\n if (this.length > targetLength) {\n return String(this);\n }\n else {\n targetLength = targetLength-this.length;\n if (targetLength > padString.length) {\n padString += padString.repeat(targetLength/padString.length); //append to original to ensure we are longer than needed\n }\n return String(this) + padString.slice(0,targetLength);\n }\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.padEnd' in that specification. | Draft | Initial definition in ECMAScript 2017. |
| ECMAScript 2017 (ECMA-262) The definition of 'String.prototype.padEnd' in that specification. | Standard |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n15 | \n48 | \nNo | \n44 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \nYes | \n48 | \n44 | \n10 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 8.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd\n
The padStart() method pads the current string with another string (multiple times, if needed) until the resulting string reaches the given length. The padding is applied from the start (left) of the current string.
str.padStart(targetLength [, padString])
targetLengthpadString Optional\ntargetLength, it will be truncated from the right. The default value is \" \" (U+0020 'SPACE').A String of the specified length with the pad string applied from the start.
'abc'.padStart(10); // \" abc\"\n'abc'.padStart(10, \"foo\"); // \"foofoofabc\"\n'abc'.padStart(6,\"123465\"); // \"123abc\"\n'abc'.padStart(8, \"0\"); // \"00000abc\"\n'abc'.padStart(1); // \"abc\"
Running the following code before any other code will create String.prototype.padStart() if it's not natively available.
// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart\nif (!String.prototype.padStart) {\n String.prototype.padStart = function padStart(targetLength, padString) {\n targetLength = targetLength >> 0; //truncate if number, or convert non-number to 0;\n padString = String(typeof padString !== 'undefined' ? padString : ' ');\n if (this.length >= targetLength) {\n return String(this);\n } else {\n targetLength = targetLength - this.length;\n if (targetLength > padString.length) {\n padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed\n }\n return padString.slice(0, targetLength) + String(this);\n }\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.padStart' in that specification. | Draft | Initial definition in ECMAScript 2017. |
| ECMAScript 2017 (ECMA-262) The definition of 'String.prototype.padStart' in that specification. | Standard |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n15 | \n48 | \nNo | \n44 | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \nYes | \n48 | \n44 | \n10 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 8.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart\n
The includes() method determines whether one string may be found within another string, returning true or false as appropriate.
str.includes(searchString[, position])
searchStringposition Optional\nsearchString. (defaults to 0).true if the search string is found anywhere within the given string; otherwise, false if not.
This method lets you determine whether or not a string includes another string.
The includes() method is case sensitive. For example, the following expression returns false:
'Blue Whale'.includes('blue'); // returns false\n includes()\nvar str = 'To be, or not to be, that is the question.';\n\nconsole.log(str.includes('To be')); // true\nconsole.log(str.includes('question')); // true\nconsole.log(str.includes('nonexistent')); // false\nconsole.log(str.includes('To be', 1)); // false\nconsole.log(str.includes('TO BE')); // false\n This method has been added to the ECMAScript 2015 specification and may not be available in all JavaScript implementations yet. However, you can easily polyfill this method:
if (!String.prototype.includes) {\n Object.defineProperty(String.prototype, 'includes', {\n value: function(search, start) {\n if (typeof start !== 'number') {\n start = 0\n }\n \n if (start + search.length > this.length) {\n return false\n } else {\n return this.indexOf(search, start) !== -1\n }\n }\n })\n}\n\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.includes' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.includes' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n41 | \nYes | \n 40\n
| \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n 40\n
| \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
In Firefox 18 - 39, the name of this method was contains(). It was renamed to includes() in bug 1102219 due to the following reason:
It's been reported that some websites using MooTools 1.2 broke on Firefox 17. This version of MooTools checks whether String.prototype.contains() exists and, if it doesn't, MooTools adds its own function. With the introduction of this function in Firefox 17, the behavior of that check changed in a way that causes code based on MooTools' String.prototype.contains() implementation to break. As a result, the implementation was disabled in Firefox 17 and String.prototype.contains() was available one version later, in Firefox 18, when outreach to MooTools was leading to the release of MooTools version 1.2.6.
MooTools 1.3 forces its own version of String.prototype.contains(), so websites relying on it should not break. However, you should note that MooTools 1.3 signature and ECMAScript 2015 signatures for this method differ (on the second argument). Later, MooTools 1.5+ changed the signature to match the ES2015 standard.
In Firefox 48, String.prototype.contains() has been removed. Use String.prototype.includes() only.
Array.prototype.includes() \nTypedArray.prototype.includes() \nString.prototype.indexOf()String.prototype.lastIndexOf()String.prototype.startsWith()String.prototype.endsWith()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n
The String object's charAt() method returns a new string consisting of the single UTF-16 code unit located at the specified offset into the string.
character = str.charAt(index)
indexA string representing the character (exactly one UTF-16 code unit) at the specified index; empty string if index is out of range.
Characters in a string are indexed from left to right. The index of the first character is 0, and the index of the last character in a string called stringName is stringName.length - 1. If the index you supply is out of this range, JavaScript returns an empty string.
If no index is provided to charAt(), the default is 0.
The following example displays characters at different locations in the string \"Brave new world\":
var anyString = 'Brave new world';\nconsole.log(\"The character at index 0 is '\" + anyString.charAt() + \"'\"); \n// No index was provided, used 0 as default\n\nconsole.log(\"The character at index 0 is '\" + anyString.charAt(0) + \"'\");\nconsole.log(\"The character at index 1 is '\" + anyString.charAt(1) + \"'\");\nconsole.log(\"The character at index 2 is '\" + anyString.charAt(2) + \"'\");\nconsole.log(\"The character at index 3 is '\" + anyString.charAt(3) + \"'\");\nconsole.log(\"The character at index 4 is '\" + anyString.charAt(4) + \"'\");\nconsole.log(\"The character at index 999 is '\" + anyString.charAt(999) + \"'\");\n
These lines display the following:
The character at index 0 is 'B'\n\nThe character at index 0 is 'B'\nThe character at index 1 is 'r'\nThe character at index 2 is 'a'\nThe character at index 3 is 'v'\nThe character at index 4 is 'e'\nThe character at index 999 is ''\n
The following provides a means of ensuring that going through a string loop always provides a whole character, even if the string contains characters that are not in the Basic Multi-lingual Plane.
var str = 'A \\uD87E\\uDC04 Z'; // We could also use a non-BMP character directly\nfor (var i = 0, chr; i < str.length; i++) {\n if ((chr = getWholeChar(str, i)) === false) {\n continue;\n }\n // Adapt this line at the top of each loop, passing in the whole string and\n // the current iteration and returning a variable to represent the \n // individual character\n\n console.log(chr);\n}\n\nfunction getWholeChar(str, i) {\n var code = str.charCodeAt(i);\n\n if (Number.isNaN(code)) {\n return ''; // Position not found\n }\n if (code < 0xD800 || code > 0xDFFF) {\n return str.charAt(i);\n }\n\n // High surrogate (could change last hex to 0xDB7F to treat high private\n // surrogates as single characters)\n if (0xD800 <= code && code <= 0xDBFF) {\n if (str.length <= (i + 1)) {\n throw 'High surrogate without following low surrogate';\n }\n var next = str.charCodeAt(i + 1);\n if (0xDC00 > next || next > 0xDFFF) {\n throw 'High surrogate without following low surrogate';\n }\n return str.charAt(i) + str.charAt(i + 1);\n }\n // Low surrogate (0xDC00 <= code && code <= 0xDFFF)\n if (i === 0) {\n throw 'Low surrogate without preceding high surrogate';\n }\n var prev = str.charCodeAt(i - 1);\n\n // (could change last hex to 0xDB7F to treat high private\n // surrogates as single characters)\n if (0xD800 > prev || prev > 0xDBFF) {\n throw 'Low surrogate without preceding high surrogate';\n }\n // We can pass over low surrogates now as the second component\n // in a pair which we have already processed\n return false;\n}\n In an ECMAScript 2016 environment which allows destructured assignment, the following is a more succinct and somewhat more flexible alternative in that it does incrementing for an incrementing variable automatically (if the character warrants it in being a surrogate pair).
var str = 'A\\uD87E\\uDC04Z'; // We could also use a non-BMP character directly\nfor (var i = 0, chr; i < str.length; i++) {\n [chr, i] = getWholeCharAndI(str, i);\n // Adapt this line at the top of each loop, passing in the whole string and\n // the current iteration and returning an array with the individual character\n // and 'i' value (only changed if a surrogate pair)\n\n console.log(chr);\n}\n\nfunction getWholeCharAndI(str, i) {\n var code = str.charCodeAt(i);\n\n if (Number.isNaN(code)) {\n return ''; // Position not found\n }\n if (code < 0xD800 || code > 0xDFFF) {\n return [str.charAt(i), i]; // Normal character, keeping 'i' the same\n }\n\n // High surrogate (could change last hex to 0xDB7F to treat high private \n // surrogates as single characters)\n if (0xD800 <= code && code <= 0xDBFF) {\n if (str.length <= (i + 1)) {\n throw 'High surrogate without following low surrogate';\n }\n var next = str.charCodeAt(i + 1);\n if (0xDC00 > next || next > 0xDFFF) {\n throw 'High surrogate without following low surrogate';\n }\n return [str.charAt(i) + str.charAt(i + 1), i + 1];\n }\n // Low surrogate (0xDC00 <= code && code <= 0xDFFF)\n if (i === 0) {\n throw 'Low surrogate without preceding high surrogate';\n }\n var prev = str.charCodeAt(i - 1);\n\n // (could change last hex to 0xDB7F to treat high private surrogates\n // as single characters)\n if (0xD800 > prev || prev > 0xDBFF) {\n throw 'Low surrogate without preceding high surrogate';\n }\n // Return the next character instead (and increment)\n return [str.charAt(i + 1), i + 1];\n}\n charAt() to support non-Basic-Multilingual-Plane (BMP) charactersWhile the example above may be more frequently useful for those wishing to support non-BMP characters (since it does not require the caller to know where any non-BMP character might appear), in the event that one does wish, in choosing a character by index, to treat the surrogate pairs within a string as the single characters they represent, one can use the following:
function fixedCharAt(str, idx) {\n var ret = '';\n str += '';\n var end = str.length;\n\n var surrogatePairs = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g;\n while ((surrogatePairs.exec(str)) != null) {\n var li = surrogatePairs.lastIndex;\n if (li - 2 < idx) {\n idx++;\n } else {\n break;\n }\n }\n\n if (idx >= end || idx < 0) {\n return '';\n }\n\n ret += str.charAt(idx);\n\n if (/[\\uD800-\\uDBFF]/.test(ret) && /[\\uDC00-\\uDFFF]/.test(str.charAt(idx + 1))) {\n // Go one further, since one of the \"characters\" is part of a surrogate pair\n ret += str.charAt(idx + 1);\n }\n return ret;\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.charAt' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.charAt' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.charAt' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
String.prototype.indexOf()String.prototype.lastIndexOf()String.prototype.charCodeAt()String.prototype.codePointAt()String.prototype.split()String.fromCodePoint()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt\n
The indexOf() method returns the index within the calling String object of the first occurrence of the specified value, starting the search at fromIndex. Returns -1 if the value is not found.
Array.prototype.indexOf().str.indexOf(searchValue[, fromIndex])
0. For fromIndex values lower than 0 or greater than str.length, the search starts at index 0 and str.length respectively.The index of the first occurrence of searchValue, or -1 if not found.
An empty string searchValue will match at any index between 0 and str.length
Characters in a string are indexed from left to right. The index of the first character is 0, and the index of the last character of a string called stringName is stringName.length - 1.
'Blue Whale'.indexOf('Blue'); // returns 0\n'Blue Whale'.indexOf('Blute'); // returns -1\n'Blue Whale'.indexOf('Whale', 0); // returns 5\n'Blue Whale'.indexOf('Whale', 5); // returns 5\n'Blue Whale'.indexOf('Whale', 7); // returns -1\n'Blue Whale'.indexOf(''); // returns 0\n'Blue Whale'.indexOf('', 9); // returns 9\n'Blue Whale'.indexOf('', 10); // returns 10\n'Blue Whale'.indexOf('', 11); // returns 10\n The indexOf() method is case sensitive. For example, the following expression returns -1:
'Blue Whale'.indexOf('blue'); // returns -1\n Note that '0' doesn't evaluate to true and '-1' doesn't evaluate to false. Therefore, when checking if a specific string exists within another string the correct way to check would be:
'Blue Whale'.indexOf('Blue') !== -1; // true\n'Blue Whale'.indexOf('Bloe') !== -1; // false\n indexOf()\nThe following example uses indexOf() to locate values in the string \"Brave new world\".
var str = 'Brave new world';\n\nconsole.log('Index of first w from start is ' + str.indexOf('w')); // logs 8\nconsole.log('Index of \"new\" from start is ' + str.indexOf('new')); // logs 6\n indexOf() and case-sensitivityThe following example defines two string variables. The variables contain the same string except that the second string contains uppercase letters. The first console.log() method displays 19. But because the indexOf() method is case sensitive, the string \"cheddar\" is not found in myCapString, so the second console.log() method displays -1.
var myString = 'brie, pepper jack, cheddar';\nvar myCapString = 'Brie, Pepper Jack, Cheddar';\n\nconsole.log('myString.indexOf(\"cheddar\") is ' + myString.indexOf('cheddar'));\n// logs 19\nconsole.log('myCapString.indexOf(\"cheddar\") is ' + myCapString.indexOf('cheddar'));\n// logs -1\n indexOf() to count occurrences of a letter in a stringThe following example sets count to the number of occurrences of the letter e in the string str:
var str = 'To be, or not to be, that is the question.';\nvar count = 0;\nvar pos = str.indexOf('e');\n\nwhile (pos !== -1) {\n count++;\n pos = str.indexOf('e', pos + 1);\n}\n\nconsole.log(count); // displays 4\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.indexOf' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.indexOf' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.indexOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
String.prototype.charAt()String.prototype.lastIndexOf()String.prototype.includes()String.prototype.split()Array.prototype.indexOf()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf\n
The lastIndexOf() method returns the index within the calling String object of the last occurrence of the specified value, searching backwards from fromIndex. Returns -1 if the value is not found.
str.lastIndexOf(searchValue[, fromIndex])
searchValuesearchValue is an empty string, then fromIndex is returned.fromIndex Optional\n+Infinity. If fromIndex >= str.length, the whole string is searched. If fromIndex < 0, the behavior will be the same as if it would be 0.The index of the last occurrence of the specified value; -1 if not found.
Characters in a string are indexed from left to right. The index of the first character is 0, and the index of the last character is str.length - 1.
'canal'.lastIndexOf('a'); // returns 3\n'canal'.lastIndexOf('a', 2); // returns 1\n'canal'.lastIndexOf('a', 0); // returns -1\n'canal'.lastIndexOf('x'); // returns -1\n'canal'.lastIndexOf('c', -5); // returns 0\n'canal'.lastIndexOf('c', 0); // returns 0\n'canal'.lastIndexOf(''); // returns 5\n'canal'.lastIndexOf('', 2); // returns 2\n Note: 'abab'.lastIndexOf('ab', 2) will return 2 and not 0, as fromIndex limits only the beginning of the match.
The lastIndexOf() method is case sensitive. For example, the following expression returns -1:
'Blue Whale, Killer Whale'.lastIndexOf('blue'); // returns -1\n indexOf() and lastIndexOf()\nThe following example uses indexOf() and lastIndexOf() to locate values in the string \"Brave new world\".
var anyString = 'Brave new world';\n\nconsole.log('The index of the first w from the beginning is ' + anyString.indexOf('w'));\n// logs 8\nconsole.log('The index of the first w from the end is ' + anyString.lastIndexOf('w')); \n// logs 10\nconsole.log('The index of \"new\" from the beginning is ' + anyString.indexOf('new'));\n// logs 6\nconsole.log('The index of \"new\" from the end is ' + anyString.lastIndexOf('new'));\n// logs 6\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
String.prototype.charAt()String.prototype.indexOf()String.prototype.split()Array.prototype.indexOf()Array.prototype.lastIndexOf()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The link() method creates a string representing the code for an <a> HTML element to be used as a hypertext link to another URL.
str.link(url)
urlhref attribute of the <a> tag; it should be a valid URL (relative or absolute), with any & characters escaped as &, and any \" characters escaped as ".A string containing an <a> HTML element.
Use the link() method to create an HTML snippet for a hypertext link. The returned string can then be added to the document via document.write() or element.innerHTML.
Links created with the link() method become elements in the links array of the document object. See document.links.
link()\nThe following example displays the word \"MDN\" as a hypertext link that returns the user to the Mozilla Developer Network.
var hotText = 'MDN';\nvar URL = 'https://developer.mozilla.org/';\n\nconsole.log('Click to return to ' + hotText.link(URL));\n// Click to return to <a href=\"https://developer.mozilla.org/\">MDN</a>\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.link' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.link' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/link\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The small() method creates a <small> HTML element that causes a string to be displayed in a small font.
str.small()
A string containing a <small> HTML element.
The small() method embeds a string in a <small> tag: \"<small>str</small>\".
small()\nThe following example uses string methods to change the size of a string:
var worldString = 'Hello, world';\n\nconsole.log(worldString.small()); // <small>Hello, world</small>\nconsole.log(worldString.big()); // <big>Hello, world</big>\nconsole.log(worldString.fontsize(7)); // <font size=\"7\">Hello, world</fontsize>\n
With the element.style object you can get the element's style attribute and manipulate it more generically, for example:
document.getElementById('yourElemId').style.fontSize = '0.7em';\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.small' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.small' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/small\n
String.prototype.substr(…) is not strictly deprecated (as in \"removed from the Web standards\"), it is considered a legacy function and should be avoided when possible. It is not part of the core JavaScript language and may be removed in the future. If at all possible, use the substring() method instead.The substr() method returns a portion of the string, starting at the specified index and extending for a given number of characters afterward.
str.substr(start[, length])
startlengthA new string containing the specified part of the given string.
substr() extracts length characters from a string, counting from the start index.
If start is a positive number, the index starts counting at the start of the string. Its value is capped at str.length.
If start is a negative number, the index starts counting from the end of the string. Its value is capped at -str.length.
Note: In Microsoft JScript, negative values of the start argument are not considered to refer to the end of the string.
If length is omitted, substr() extracts characters to the end of the string.
If length is undefined, substr() extracts characters to the end of the string.
If length is a negative number, it is treated as 0.
For both start and length, NaN is treated as 0.
substr()\nvar aString = 'Mozilla';\n\nconsole.log(aString.substr(0, 1)); // 'M'\nconsole.log(aString.substr(1, 0)); // ''\nconsole.log(aString.substr(-1, 1)); // 'a'\nconsole.log(aString.substr(1, -1)); // ''\nconsole.log(aString.substr(-3)); // 'lla'\nconsole.log(aString.substr(1)); // 'ozilla'\nconsole.log(aString.substr(-20, 2)); // 'Mo'\nconsole.log(aString.substr(20, 2)); // ''\n
Microsoft's JScript does not support negative values for the start index. To use this feature in JScript, you can use the following code:
// only run when the substr() function is broken\nif ('ab'.substr(-1) != 'b') {\n /**\n * Get the substring of a string\n * @param {integer} start where to start the substring\n * @param {integer} length how many characters to return\n * @return {string}\n */\n String.prototype.substr = function(substr) {\n return function(start, length) {\n // call the original method\n return substr.call(this,\n \t// did we get a negative start, calculate how much it is from the beginning of the string\n // adjust the start parameter for negative value\n start < 0 ? this.length + start : start,\n length)\n }\n }(String.prototype.substr);\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Defined in the (informative) Compatibility Annex B. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.substr' in that specification. | Standard | Defined in the (informative) Compatibility Annex B |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.substr' in that specification. | Standard | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.substr' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr\n
The repeat() method constructs and returns a new string which contains the specified number of copies of the string on which it was called, concatenated together.
str.repeat(count);\n
countA new string containing the specified number of copies of the given string.
RangeError: repeat count must be non-negative.RangeError: repeat count must be less than infinity and not overflow maximum string size.'abc'.repeat(-1); // RangeError\n'abc'.repeat(0); // ''\n'abc'.repeat(1); // 'abc'\n'abc'.repeat(2); // 'abcabc'\n'abc'.repeat(3.5); // 'abcabcabc' (count will be converted to integer)\n'abc'.repeat(1/0); // RangeError\n\n({ toString: () => 'abc', repeat: String.prototype.repeat }).repeat(2);\n// 'abcabc' (repeat() is a generic method)\n This method has been added to the ECMAScript 2015 specification and may not be available in all JavaScript implementations yet. However, you can polyfill String.prototype.repeat() with the following snippet:
if (!String.prototype.repeat) {\n String.prototype.repeat = function(count) {\n 'use strict';\n if (this == null) {\n throw new TypeError('can\\'t convert ' + this + ' to object');\n }\n var str = '' + this;\n count = +count;\n if (count != count) {\n count = 0;\n }\n if (count < 0) {\n throw new RangeError('repeat count must be non-negative');\n }\n if (count == Infinity) {\n throw new RangeError('repeat count must be less than infinity');\n }\n count = Math.floor(count);\n if (str.length == 0 || count == 0) {\n return '';\n }\n // Ensuring count is a 31-bit integer allows us to heavily optimize the\n // main part. But anyway, most current (August 2014) browsers can't handle\n // strings 1 << 28 chars or longer, so:\n if (str.length * count >= 1 << 28) {\n throw new RangeError('repeat count must not overflow maximum string size');\n }\n var maxCount = str.length * count;\n count = Math.floor(Math.log(count) / Math.log(2));\n while (count) {\n str += str;\n count--;\n }\n str += str.substring(0, maxCount - str.length);\n return str;\n }\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.repeat' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.repeat' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n41 | \nYes | \n24 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n36 | \nYes | \n24 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat\n
The slice() method extracts a section of a string and returns it as a new string, without modifying the original string.
str.slice(beginIndex[, endIndex])
beginIndexstrLength + beginIndex where strLength is the length of the string (for example, if beginIndex is -3 it is treated as strLength - 3). If beginIndex is greater than or equal to the length of the string, slice() returns an empty string.endIndexendIndex is omitted, slice() extracts to the end of the string. If negative, it is treated as strLength + endIndex where strLength is the length of the string (for example, if endIndex is -3 it is treated as strLength - 3).A new string containing the extracted section of the string.
slice() extracts the text from one string and returns a new string. Changes to the text in one string do not affect the other string.
slice() extracts up to but not including endIndex. str.slice(1, 4) extracts the second character through the fourth character (characters indexed 1, 2, and 3).
As an example, str.slice(2, -1) extracts the third character through the second to last character in the string.
slice() to create a new stringThe following example uses slice() to create a new string.
var str1 = 'The morning is upon us.', // the length of str1 is 23.\n str2 = str1.slice(1, 8),\n str3 = str1.slice(4, -2),\n str4 = str1.slice(12),\n str5 = str1.slice(30);\nconsole.log(str2); // OUTPUT: he morn\nconsole.log(str3); // OUTPUT: morning is upon u\nconsole.log(str4); // OUTPUT: is upon us.\nconsole.log(str5); // OUTPUT: \"\"\n
slice() with negative indexesThe following example uses slice() with negative indexes.
var str = 'The morning is upon us.';\nstr.slice(-3); // returns 'us.'\nstr.slice(-3, -1); // returns 'us'\nstr.slice(0, -1); // returns 'The morning is upon us'\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.slice' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.slice' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.slice' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The sup() method creates a <sup> HTML element that causes a string to be displayed as superscript.
str.sup()
A string containing a <sup> HTML element.
The sup() method embeds a string in a <sup> tag: \"<sup>str</sup>\".
sub() and sup() methodsThe following example uses the sub() and sup() methods to format a string:
var superText = 'superscript';\nvar subText = 'subscript';\n\nconsole.log('This is what a ' + superText.sup() + ' looks like.');\n// \"This is what a <sup>superscript</sup> looks like.\"\n\nconsole.log('This is what a ' + subText.sub() + ' looks like.');\n// \"This is what a <sub>subscript</sub> looks like.\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.sup' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.sup' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/sup\n
The substring() method returns the part of the string between the start and end indexes, or to the end of the string.
str.substring(indexStart[, indexEnd])
indexStartindexEndA new string containing the specified part of the given string.
substring() extracts characters from indexStart up to but not including indexEnd. In particular:
indexEnd is omitted, substring() extracts characters to the end of the string.indexStart is equal to indexEnd, substring() returns an empty string.indexStart is greater than indexEnd, then the effect of substring() is as if the two arguments were swapped; See example below.Any argument value that is less than 0 or greater than stringName.length is treated as if it were 0 and stringName.length respectively. Any argument value that is NaN is treated as if it were 0.
substring()\nThe following example uses substring() to display characters from the string 'Mozilla':
var anyString = 'Mozilla';\n\n// Displays 'M'\nconsole.log(anyString.substring(0, 1));\nconsole.log(anyString.substring(1, 0));\n\n// Displays 'Mozill'\nconsole.log(anyString.substring(0, 6));\n\n// Displays 'lla'\nconsole.log(anyString.substring(4));\nconsole.log(anyString.substring(4, 7));\nconsole.log(anyString.substring(7, 4));\n\n// Displays 'Mozilla'\nconsole.log(anyString.substring(0, 7));\nconsole.log(anyString.substring(0, 10));\n
substring() with length propertyThe following example uses the substring() method and length property to extract the last characters of a particular string. This method may be easier to remember, given that you don't need to know the starting and ending indices as you would in the above examples.
// Displays 'illa' the last 4 characters\nvar anyString = 'Mozilla';\nvar anyString4 = anyString.substring(anyString.length - 4);\nconsole.log(anyString4);\n\n// Displays 'zilla' the last 5 characters\nvar anyString = 'Mozilla';\nvar anyString5 = anyString.substring(anyString.length - 5);\nconsole.log(anyString5);\n
substring() and substr()\nThere's a subtle difference between the substring() and substr() methods, and you should be careful not get them confused.
The arguments of substring() represent the starting and ending indexes, while the arguments of substr() represent the starting index and the length of characters to include in the returned string.
var text = 'Mozilla';\nconsole.log(text.substring(2,5)); // => \"zil\"\nconsole.log(text.substr(2,3)); // => \"zil\"
The following example replaces a substring within a string. It will replace both individual characters and substrings. The function call at the end of the example changes the string 'Brave New World' to 'Brave New Web'.
// Replaces oldS with newS in the string fullS\nfunction replaceString(oldS, newS, fullS) {\n for (var i = 0; i < fullS.length; ++i) {\n if (fullS.substring(i, i + oldS.length) == oldS) {\n fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length);\n }\n }\n return fullS;\n}\n\nreplaceString('World', 'Web', 'Brave New World');\n Note that this can result in an infinite loop if oldS is itself a substring of newS — for example, if you attempted to replace 'World' with 'OtherWorld' here. A better method for replacing strings is as follows:
function replaceString(oldS, newS, fullS) {\n return fullS.split(oldS).join(newS);\n}\n The code above serves as an example for substring operations. If you need to replace substrings, most of the time you will want to use String.prototype.replace().
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.substring' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.substring' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.substring' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring\n
The toLocaleLowerCase() method returns the calling string value converted to lower case, according to any locale-specific case mappings.
str.toLocaleLowerCase()\nstr.toLocaleLowerCase(locale) \nstr.toLocaleLowerCase([locale, locale, ...])\n
locale Optional\nlocale parameter indicates the locale to be used to convert to lower case according to any locale-specific case mappings. If multiple locales are given in an Array, the best available locale is used. The default locale is the host environment’s current locale.A new string representing the calling string converted to lower case, according to any locale-specific case mappings.
RangeError (\"invalid language tag: xx_yy\") is thrown if a locale argument isn't a valid language tag.TypeError (\"invalid element in locales argument\") is thrown if an array element isn't of type string.The toLocaleLowerCase() method returns the value of the string converted to lower case according to any locale-specific case mappings. toLocaleLowerCase() does not affect the value of the string itself. In most cases, this will produce the same result as toLowerCase(), but for some locales, such as Turkish, whose case mappings do not follow the default case mappings in Unicode, there may be a different result.
toLocaleLowerCase()\n'ALPHABET'.toLocaleLowerCase(); // 'alphabet'\n\n'\\u0130'.toLocaleLowerCase('tr') === 'i'; // true\n'\\u0130'.toLocaleLowerCase('en-US') === 'i'; // false\n\nlet locales = ['tr', 'TR', 'tr-TR', 'tr-u-co-search', 'tr-x-turkish'];\n'\\u0130'.toLocaleLowerCase(locales) === 'i'; // true\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.toLocaleLowerCase' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.toLocaleLowerCase' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.toLocaleLowerCase' in that specification. | Draft | |
| ECMAScript Internationalization API 4.0 (ECMA-402) The definition of 'String.prototype.toLocaleLowerCase' in that specification. | Draft | ES Intl 2017 added the locale parameter. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
locale | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
locale | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
locale | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The sub() method creates a <sub> HTML element that causes a string to be displayed as subscript.
str.sub()
A string containing a <sub> HTML element.
The sub() method embeds a string in a <sub> tag: \"<sub>str</sub>\".
sub() and sup() methodsThe following example uses the sub() and sup() methods to format a string:
var superText = 'superscript'; \nvar subText = 'subscript'; \n\nconsole.log('This is what a ' + superText.sup() + ' looks like.'); \n// This is what a <sup>superscript</sup> looks like \n\nconsole.log('This is what a ' + subText.sub() + ' looks like.'); \n// This is what a <sub>subscript</sub> looks like.\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.sub' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.sub' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/sub\n
The toLocaleUpperCase() method returns the calling string value converted to upper case, according to any locale-specific case mappings.
str.toLocaleUpperCase()\nstr.toLocaleUpperCase(locale) \nstr.toLocaleUpperCase([locale, locale, ...])\n
locale Optional\nlocale parameter indicates the locale to be used to convert to upper case according to any locale-specific case mappings. If multiple locales are given in an Array, the best available locale is used. The default locale is the host environment’s current locale.A new string representing the calling string converted to upper case, according to any locale-specific case mappings.
RangeError (\"invalid language tag: xx_yy\") is thrown if a locale argument isn't a valid language tag.TypeError (\"invalid element in locales argument\") is thrown if an array element isn't of type string.The toLocaleUpperCase() method returns the value of the string converted to upper case according to any locale-specific case mappings. toLocaleUpperCase() does not affect the value of the string itself. In most cases, this will produce the same result as toUpperCase(), but for some locales, such as Turkish, whose case mappings do not follow the default case mappings in Unicode, there may be a different result.
Also notice that conversion is not necessarily a 1:1 character mapping, as some characters might result in two (or even more) characters when transformed to upper-case. Therefore the length of the result string can differ from the input length. This also implies that the conversion is not stable, so i.E. the following can return false:
x.toLocaleLowerCase() === x.toLocaleUpperCase().toLocaleLowerCase()
toLocaleUpperCase()\n'alphabet'.toLocaleUpperCase(); // 'ALPHABET'\n\n'Gesäß'.toLocaleUpperCase(); // 'GESÄSS'\n\n'i\\u0307'.toLocaleUpperCase('lt-LT'); // 'I'\n\nlet locales = ['lt', 'LT', 'lt-LT', 'lt-u-co-phonebk', 'lt-x-lietuva'];\n'i\\u0307'.toLocaleUpperCase(locales); // 'I' | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.toLocaleUpperCase' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.toLocaleUpperCase' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.toLocaleUpperCase' in that specification. | Draft | |
| ECMAScript Internationalization API 4.0 (ECMA-402) The definition of 'String.prototype.toLocaleUpperCase' in that specification. | Draft | ES Intl 2017 added the locale parameter. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
locale | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
locale | \n? | \n? | \n? | \n55 | \n? | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
locale | \n? | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase\n
The toString() method returns a string representing the specified object.
str.toString()
A string representing the calling object.
The String object overrides the toString() method of the Object object; it does not inherit Object.prototype.toString(). For String objects, the toString() method returns a string representation of the object and is the same as the String.prototype.valueOf() method.
toString()\nThe following example displays the string value of a String object:
var x = new String('Hello world');\n\nconsole.log(x.toString()); // logs 'Hello world'\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 3rd Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.toString' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.toString' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.toString' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toString\n
The startsWith() method determines whether a string begins with the characters of a specified string, returning true or false as appropriate.
str.startsWith(searchString[, position])
searchStringposition Optional\nsearchString; defaults to 0.true if the given characters are found at the beginning of the string; otherwise, false.
This method lets you determine whether or not a string begins with another string. This method is case-sensitive.
startsWith()\n//startswith\nvar str = 'To be, or not to be, that is the question.';\n\nconsole.log(str.startsWith('To be')); // true\nconsole.log(str.startsWith('not to be')); // false\nconsole.log(str.startsWith('not to be', 10)); // true\n This method has been added to the ECMAScript 2015 specification and may not be available in all JavaScript implementations yet. However, you can polyfill String.prototype.startsWith() with the following snippet:
if (!String.prototype.startsWith) {\n\tString.prototype.startsWith = function(search, pos) {\n\t\treturn this.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n\t};\n}\n A more robust (fully ES2015 specification compliant), but less performant and compact, Polyfill is available on GitHub by Mathias Bynens.
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.startsWith' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.startsWith' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n41 | \nYes | \n17 | \nNo | \n28 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \n36 | \nYes | \n17 | \nYes | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 4.0.0\n
| \n
String.prototype.endsWith()String.prototype.includes()String.prototype.indexOf()String.prototype.lastIndexOf()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n
Deprecated
This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.
The strike() method creates a <strike> HTML element that causes a string to be displayed as struck-out text.
str.strike()
A string containing a <strike> HTML element.
The strike() method embeds a string in a <strike> tag: \"<strike>str</strike>\".
strike()\nThe following example uses string methods to change the formatting of a string:
var worldString = 'Hello, world'; \n\nconsole.log(worldString.blink()); // <blink>Hello, world</blink> \nconsole.log(worldString.bold()); // <b>Hello, world</b> \nconsole.log(worldString.italics()); // <i>Hello, world</i> \nconsole.log(worldString.strike()); // <strike>Hello, world</strike>\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.strike' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.0. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.strike' in that specification. | Draft | Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/strike\n
The toLowerCase() method returns the calling string value converted to lower case.
str.toLowerCase()
A new string representing the calling string converted to lower case.
The toLowerCase() method returns the value of the string converted to lower case. toLowerCase() does not affect the value of the string str itself.
toLowerCase()\nconsole.log('ALPHABET'.toLowerCase()); // 'alphabet'\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.toLowerCase' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.toLowerCase' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.toLowerCase' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
String.prototype.toLocaleLowerCase()String.prototype.toLocaleUpperCase()String.prototype.toUpperCase()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase\n
The toUpperCase() method returns the calling string value converted to uppercase (the value will be converted to a string if it isn't one).
str.toUpperCase()
A new string representing the calling string converted to upper case.
The toUpperCase() method returns the value of the string converted to uppercase. This method does not affect the value of the string itself since JavaScript strings are immutable.
You cannot call this method on null or undefined (via Function.prototype.call, for example) , if you do, a TypeError will be thrown.
console.log('alphabet'.toUpperCase()); // 'ALPHABET'\n this values to stringsThis method will convert any non-string value to a string, when you set its this to a value that is not a string:
const a = String.prototype.toUpperCase.call({\n toString: function toString() {\n return 'abcdef';\n }\n});\n\nconst b = String.prototype.toUpperCase.call(true);\n\n// prints out 'ABCDEF TRUE'.\nconsole.log(a, b);\n undefined and null\n// TypeError\nString.prototype.toUpperCase.call(undefined);\n
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.0. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.toUpperCase' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.toUpperCase' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.toUpperCase' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
String.prototype.toLocaleLowerCase()String.prototype.toLocaleUpperCase()String.prototype.toLowerCase()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase\n
The trimStart() method removes whitespace from the beginning of a string. trimLeft() is an alias of this method.
str.trimStart();\nstr.trimLeft();
A new string representing the calling string stripped of whitespace from its beginning (left end).
The trimStart() / trimLeft() methods return the string stripped of whitespace from its left end. trimLeft() or trimStart() do not affect the value of the string itself.
For consistency with functions like String.prototype.padStart the standard method name is trimStart. However, for web compatibility reasons, trimLeft remains as an alias to trimStart. In some engines this means:
String.prototype.trimLeft.name === \"trimStart\";
trimStart()\nThe following example displays the lowercase string 'foo ':
var str = ' foo ';\n\nconsole.log(str.length); // 8\n\nstr = str.trimStart();\nconsole.log(str.length); // 5\nconsole.log(str); // 'foo '\n
| Specification | Status | Comment |
|---|---|---|
\nString.prototype.{trimStart,trimEnd} proposal | Stage 1 |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 66\n
| \n? | \n 61\n
| \nNo | \n53 | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n 66\n
| \n 66\n
| \n? | \n 61\n
| \n53 | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n10.0.0 | \n
//https://github.com/FabioVergani/js-Polyfill_String-trimStart\n\n(function(w){\n var String=w.String, Proto=String.prototype;\n\n (function(o,p){\n if(p in o?o[p]?false:true:true){\n var r=/^\\s+/;\n o[p]=o.trimLeft||function(){\n return this.replace(r,'')\n }\n }\n })(Proto,'trimStart');\n\n})(window); \n\n\n/*\nES6:\n(w=>{\n const String=w.String, Proto=String.prototype;\n\n ((o,p)=>{\n if(p in o?o[p]?false:true:true){\n const r=/^\\s+/;\n o[p]=o.trimLeft||function(){\n return this.replace(r,'')\n }\n }\n })(Proto,'trimStart');\n\n})(window);\n*/ \n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimStart\n
The valueOf() method returns the primitive value of a String object.
str.valueOf()
A string representing the primitive value of a given String object.
The valueOf() method of String returns the primitive value of a String object as a string data type. This value is equivalent to String.prototype.toString().
This method is usually called internally by JavaScript and not explicitly in code.
valueOf()\nvar x = new String('Hello world');\nconsole.log(x.valueOf()); // Displays 'Hello world'\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1. |
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.valueOf' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.valueOf' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.valueOf' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/valueOf\n
The buffer prototype property of the Memory object returns the buffer contained in the memory.
memory.buffer\n
The following example (see memory.html on GitHub, and view it live also) fetches and instantiates the loaded memory.wasm byte code using the WebAssembly.instantiateStreaming() method, while importing the memory created in the line above. It then stores some values in that memory, then exports a function and uses it to sum some values.
WebAssembly.instantiateStreaming(fetch('memory.wasm'), { js: { mem: memory } })\n.then(obj => {\n var i32 = new Uint32Array(memory.buffer);\n for (var i = 0; i < 10; i++) {\n i32[i] = i;\n }\n var sum = obj.instance.exports.accumulate(0, 10);\n console.log(sum);\n}); | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'buffer' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/buffer\n
The grow() protoype method of the Memory object increases the size of the memory instance by a specified number of WebAssembly pages.
memory.grow(number);\n
The previous size of the memory, in units of WebAssembly pages.
The following example creates a new WebAssembly Memory instance with an initial size of 1 page (64KiB), and a maximum size of 10 pages (640KiB).
var memory = new WebAssembly.Memory({initial:1, maximum:10}); We can then grow the instance by one page like so:
const bytesPerPage = 64 * 1024;\nconsole.log(memory.buffer.byteLength / bytesPerPage); // \"1\"\nconsole.log(memory.grow(1)); // \"1\"\nconsole.log(memory.buffer.byteLength / bytesPerPage); // \"2\"\n
Note the return value of grow() here is the previous number of WebAssembly pages.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'grow()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow\n
The static String.raw() method is a tag function of template literals, similar to the r prefix in Python or the @ prefix in C# for string literals (yet there is a difference: see explanations in this issue). It's used to get the raw string form of template strings, that is, substitutions (e.g. ${foo}) are processed, but escapes (e.g. \\n) are not.
String.raw(callSite, ...substitutions)\n\nString.raw`templateString`\n
callSite{ raw: ['foo', 'bar', 'baz'] }....substitutionstemplateString${...}).The raw string form of a given template string.
In most cases, String.raw() is used with template strings. The first syntax mentioned above is only rarely used, because the JavaScript engine will call this with proper arguments for you, just like with other tag functions.
String.raw() is the only built-in tag function of template strings; it works just like the default template function and performs concatenation. You can even re-implement it with normal JavaScript code.
String.raw()\nString.raw`Hi\\n${2+3}!`;\n// 'Hi\\n5!', the character after 'Hi'\n// is not a newline character,\n// '\\' and 'n' are two characters.\n\nString.raw`Hi\\u000A!`;\n// 'Hi\\u000A!', same here, this time we will get the\n// \\, u, 0, 0, 0, A, 6 characters.\n// All kinds of escape characters will be ineffective\n// and backslashes will be present in the output string.\n// You can confirm this by checking the .length property\n// of the string.\n\nlet name = 'Bob';\nString.raw`Hi\\n${name}!`;\n// 'Hi\\nBob!', substitutions are processed.\n\n// Normally you would not call String.raw() as a function,\n// but to simulate `t${0}e${1}s${2}t` you can do:\nString.raw({ raw: 'test' }, 0, 1, 2); // 't0e1s2t'\n// Note that 'test', a string, is an array-like object\n// The following is equivalent to\n// `foo${2 + 3}bar${'Java' + 'Script'}baz`\nString.raw({\n raw: ['foo', 'bar', 'baz'] \n}, 2 + 3, 'Java' + 'Script'); // 'foo5barJavaScriptbaz'\n\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.raw' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.raw' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n41 | \nYes | \n34 | \nNo | \nNo | \n10 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \n41 | \nYes | \n34 | \nNo | \n10 | \n4.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n4.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw\n
This is an experimental technology
Check the Browser compatibility table carefully before using this in production.
The WebAssembly.Instance.prototype property represents the prototype for the WebAssembly.Instance() constructor.
Property attributes of WebAssembly.Instance.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All WebAssembly.Instance instances inherit from Instance.prototype. The prototype object of the WebAssembly.Instance() constructor can be modified to affect all WebAssembly.Instance instances.
Instance.prototype.constructorWebAssembly.Instance() constructor.Instance.prototype.exports Read only \nNone.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly.Module()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
WebAssembly.Instance()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/prototype\n
The exports readonly property of the WebAssembly.Instance object prototype returns an object containing as its members all the functions exported from the WebAssembly module instance, to allow them to be accessed and used by JavaScript.
instance.exports
After fetching some WebAssembly bytecode using fetch, we compile and instantiate the module using the WebAssembly.instantiateStreaming() function, importing a JavaScript function into the WebAssembly Module in the process. We then call an Exported WebAssembly function that is exported by the Instance.
var importObject = {\n imports: {\n imported_func: function(arg) {\n console.log(arg);\n }\n }\n};\n\nWebAssembly.instantiateStreaming(fetch('simple.wasm'), importObject)\n.then(obj => obj.instance.exports.exported_func()); Note: You can also find this example as instantiate-streaming.html on GitHub (view it live also).
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly.Instance objects' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance/exports\n
This is an experimental technology
Check the Browser compatibility table carefully before using this in production.
The WebAssembly.Memory.prototype property represents the prototype for the WebAssembly.Memory() constructor.
Property attributes of WebAssembly.Memory.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All WebAssembly.Memory instances inherit from Memory.prototype. The prototype object of the WebAssembly.Memory() constructor can be modified to affect all WebAssembly.Memory instances.
Memory.prototype.constructorWebAssembly.Memory() constructor.Memory.prototype.bufferMemory.prototype.grow()| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'Memory' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
WebAssembly.Memory()\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/prototype\n
The trimEnd() method removes whitespace from the end of a string. trimRight() is an alias of this method.
str.trimEnd();\nstr.trimRight();
A new string representing the calling string stripped of whitespace from its (right) end.
The trimEnd() / trimRight() methods return the string stripped of whitespace from its right end. trimEnd() or trimRight() do not affect the value of the string itself.
For consistency with functions like String.prototype.padEnd the standard method name is trimEnd. However, for web compatibility reasons, trimRight remains as an alias to trimEnd. In some engines this means:
String.prototype.trimRight.name === \"trimEnd\";
trimEnd()\nThe following example displays the lowercase string ' foo':
var str = ' foo ';\n\nconsole.log(str.length); // 8\n\nstr = str.trimEnd();\nconsole.log(str.length); // 6\nconsole.log(str); // ' foo'\n
| Specification | Status | Comment |
|---|---|---|
\nString.prototype.{trimStart,trimEnd} proposal | Stage 1 |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 66\n
| \n? | \n 61\n
| \nNo | \n53 | \n? | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n 66\n
| \n 66\n
| \n? | \n 61\n
| \n53 | \n? | \n? | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n10.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimEnd\n
The [@@iterator]() method returns a new Iterator object that iterates over the code points of a String value, returning each code point as a String value.
str[Symbol.iterator]
A new Iterator object.
[@@iterator]()\nvar str = 'A\\uD835\\uDC68';\n\nvar strIter = str[Symbol.iterator]();\n\nconsole.log(strIter.next().value); // \"A\"\nconsole.log(strIter.next().value); // \"\\uD835\\uDC68\"\n
[@@iterator]() with for..of\nvar str = 'A\\uD835\\uDC68B\\uD835\\uDC69C\\uD835\\uDC6A';\n\nfor (var v of str) {\n console.log(v);\n}\n// \"A\"\n// \"\\uD835\\uDC68\"\n// \"B\"\n// \"\\uD835\\uDC69\"\n// \"C\"\n// \"\\uD835\\uDC6A\"\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype[@@iterator]()' in that specification. | Standard | Initial definition. |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype[@@iterator]()' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n 36\n
| \nNo | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nNo | \nNo | \n? | \n 36\n
| \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n0.12 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/@@iterator\n
The WebAssembly.customSections() function returns a copy of the contents of all custom sections in the given module with the given string name.
var custSec = WebAssembly.Module.customSections(module, sectionName);
WebAssembly.Module object whose custom sections are being considered.A (possibly empty) array containing ArrayBuffer copies of the contents of all custom sections matching sectionName.
If module is not a WebAssembly.Module object instance, a TypeError is thrown.
A wasm module is comprised of a sequence of sections. Most of these sections are fully specified and validated by the wasm spec, but modules can also contain custom sections that are ignored and skipped over during validation. (Read High level structure for information on section structures, and how normal sections (\"known sections\") and custom sections are distinguished.)
This provides developers with a way to include custom data inside wasm modules for other purposes, for example the name custom section, which allows developers to provide names for all the functions and locals in the module (like \"symbols\" in a native build).
Note that the WebAssembly text format currently doesn't have a syntax specified for adding new custom sections; you can however add a name section to your wasm during conversion from text format over to .wasm. The wast2wasm command available as part of the wabt tool has a --debug-names option — specify this during conversion to get a .wasm with a names custom section, for example:
wast2wasm simple-name-section.was -o simple-name-section.wasm --debug-names
The following example (see the custom-section.html source and live example) compiles the loaded simple-name-section.wasm byte code.
We then do a check using WebAssembly.Module.customSections, looking to see whether the module instance contains a \"name\" custom section by checking that its length is more than 0. Since there is a \"name\" section in the example, an ArrayBuffer object is returned.
WebAssembly.compileStreaming(fetch('simple-name-section.wasm'))\n.then(function(mod) {\n var nameSections = WebAssembly.Module.customSections(mod, \"name\");\n if (nameSections.length != 0) {\n console.log(\"Module contains a name section\");\n console.log(nameSections[0]);\n };\n}); | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'customSections()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/customSections\n
The WebAssembly.exports() function returns an array containing descriptions of all the declared exports of the given Module.
var exports = WebAssembly.Module.exports(module);
WebAssembly.Module object.An array containing objects representing the exported functions of the given module.
If module is not a WebAssembly.Module object instance, a TypeError is thrown.
The following example (see our index-compile.html demo on GitHub, and view it live also) compiles the loaded simple.wasm byte code using the WebAssembly.compileStreaming() method and then sends it to a worker using postMessage().
var worker = new Worker(\"wasm_worker.js\");\n\nWebAssembly.compileStreaming(fetch('simple.wasm'))\n.then(mod =>\n worker.postMessage(mod)\n); In the worker (see wasm_worker.js) we define an import object for the module to use, then set up an event handler to receive the module from the main thread. when the module is received, we create an instance from it using the WebAssembly.Instantiate() method, invoke an exported function from inside it, then show how we can return information on the available exports on a module using WebAssembly.Module.exports.
var importObject = {\n imports: {\n imported_func: function(arg) {\n console.log(arg);\n }\n }\n};\n\nonmessage = function(e) {\n console.log('module received from main thread');\n var mod = e.data;\n\n WebAssembly.instantiate(mod, importObject).then(function(instance) {\n instance.exports.exported_func();\n });\n\n var exports = WebAssembly.Module.exports(mod);\n console.log(exports[0]);\n}; The exports[0] output looks like this:
{ name: \"exported_func\", kind: \"function\" } | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'exports()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/exports\n
The WebAssembly.imports() function returns an array containing descriptions of all the declared imports of the given Module.
var custSec = WebAssembly.Module.imports(module);
WebAssembly.Module object.An array containing objects representing the imported functions of the given module.
If module is not a WebAssembly.Module object instance, a TypeError is thrown.
The following example (see imports.html source code; see it live also) compiles the loaded simple.wasm module. This module is then queried for its imports.
WebAssembly.compileStreaming(fetch('simple.wasm'))\n.then(function(mod) {\n var imports = WebAssembly.Module.imports(mod);\n console.log(imports[0]);\n});\n The output looks like this:
{ module: \"imports\", name: \"imported_func\", kind: \"function\" } | Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'imports()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/imports\n
The WebAssembly.Module.prototype property represents the prototype for the WebAssembly.Module() constructor.
Property attributes of WebAssembly.Module.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All WebAssembly.Module instances inherit from Module.prototype. The prototype object of the WebAssembly.Module() constructor can be modified to affect all WebAssembly.Module instances.
Module.prototype.constructorWebAssembly.Module() constructor.Module.prototype[@@toStringTag]None.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly.Module()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module/prototype\n
The trim() method removes whitespace from both ends of a string. Whitespace in this context is all the whitespace characters (space, tab, no-break space, etc.) and all the line terminator characters (LF, CR, etc.).
str.trim()
A new string representing the calling string stripped of whitespace from both ends.
The trim() method returns the string stripped of whitespace from both ends. trim() does not affect the value of the string itself.
trim()\nThe following example displays the lowercase string 'foo':
var orig = ' foo ';\nconsole.log(orig.trim()); // 'foo'\n\n// Another example of .trim() removing whitespace from just one side.\n\nvar orig = 'foo ';\nconsole.log(orig.trim()); // 'foo'\n
Running the following code before any other code will create trim() if it's not natively available.
if (!String.prototype.trim) {\n String.prototype.trim = function () {\n return this.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n };\n}\n | Specification | Status | Comment |
|---|---|---|
| ECMAScript 5.1 (ECMA-262) The definition of 'String.prototype.trim' in that specification. | Standard | Initial definition. Implemented in JavaScript 1.8.1. |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'String.prototype.trim' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'String.prototype.trim' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n3.5 | \n9 | \n10.5 | \n5 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim\n
This is an experimental technology
Check the Browser compatibility table carefully before using this in production.
The WebAssembly.Table.prototype property represents the prototype for the WebAssembly.Table() constructor.
Property attributes of WebAssembly.Table.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All WebAssembly.Table instances inherit from Table.prototype. The prototype object of the WebAssembly.Table() constructor can be modified to affect all WebAssembly.Table instances.
Table.prototype.constructorWebAssembly.Table() constructor.Table.prototype.lengthTable.prototype.get()Table.prototype.grow()Table.prototype.set()| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'Table' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
WebAssembly.Table\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/prototype\n
The set() prototype method of the WebAssembly.Table object mutates a reference stored at a given index to a different value.
table.set(index, value);\n
Void.
Table.prototype.length, a RangeError is thrown.null, a TypeError is thrown.The following example (see table2.html source code and live version) creates a new WebAssembly Table instance with an initial size of 2 references. We then print out the table length and contents of the two indexes (retrieved via Table.prototype.get()) to show that the length is two, and the indexes currently contain no function references (they currently return null).
var tbl = new WebAssembly.Table({initial:2, element:\"anyfunc\"});\nconsole.log(tbl.length);\nconsole.log(tbl.get(0));\nconsole.log(tbl.get(1)); We then create an import object that contains a reference to the table:
var importObj = {\n js: {\n tbl:tbl\n }\n}; Finally, we load and instantiate a wasm module (table2.wasm) using the WebAssembly.instantiateStreaming(), log the table length, and invoke the two referenced functions that are now stored in the table (the table2.wasm module (see text representation) adds two function references to the table, both of which print out a simple value):
WebAssembly.instantiateStreaming(fetch('table2.wasm'), importObject)\n.then(function(obj) {\n console.log(tbl.length);\n console.log(tbl.get(0)());\n console.log(tbl.get(1)());\n}); Note how you've got to include a second function invocation operator at the end of the accessor to actually invoke the referenced function and log the value stored inside it (e.g. get(0)() rather than get(0)) .
This example shows that we're creating and accessing the table from JavaScript, but the same table is visible and callable inside the wasm instance too.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'set()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/set\n
The WebAssembly.Global.prototype property represents the prototype for the WebAssembly.Global() constructor.
Property attributes of WebAssembly.Global.prototype\n | |
|---|---|
| Writable | no |
| Enumerable | no |
| Configurable | no |
All WebAssembly.Global instances inherit from Global.prototype. The prototype object of the WebAssembly.Global() constructor can be modified to affect all WebAssembly.Global instances.
Global.prototype.constructorWebAssembly.Global() constructor.Global.prototype[@@toStringTag]Global.prototype.valueGlobal.prototype.valueOf()| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'WebAssembly.Global()' in that specification. | Working Draft | Initial draft definition. |
No compatibility data found. Please contribute data for \"javascript.builtins.WebAssembly.Global.prototype\" (depth: 1) to the MDN compatibility data repository.
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global/prototype\n
The get() prototype method of the WebAssembly.Table() object retrieves a function reference stored at a given index.
var funcRef = table.get(index);\n
A function reference — this is an exported WebAssembly function, a JavaScript wrapper for an underlying wasm function.
If index is greater than or equal to Table.prototype.length, a RangeError is thrown.
The following example (see table.html on GitHub, and view it live also) compiles and instantiates the loaded table.wasm byte code using the WebAssembly.instantiateStreaming() method. It then retrieves the references stored in the exported table.
WebAssembly.instantiateStreaming(fetch('table.wasm'))\n.then(function(obj) {\n var tbl = obj.instance.exports.tbl;\n console.log(tbl.get(0)()); // 13\n console.log(tbl.get(1)()); // 42\n}); Note how you've got to include a second function invocation operator at the end of the accessor to actually retrieve the value stored inside the reference (e.g. get(0)() rather than get(0)) — it is a function rather than a simple value.
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'get()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/get\n
The grow() prototype method of the WebAssembly.Table object increases the size of the Table instance by a specified number of elements.
table.grow(number);\n
The previous length of the table.
If the grow() operation fails for whatever reason, a RangeError is thrown.
The following example creates a new WebAssembly Table instance with an initial size of 2 and a maximum size of 10.
var table = new WebAssembly.Table({ element: \"anyfunc\", initial: 2, maximum: 10 }); You can then grow the table by 1 with the following:
console.log(table.length); // \"2\"\nconsole.log(table.grow(1)); // \"2\"\nconsole.log(table.length); // \"3\"\n
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'grow()' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/grow\n
The length prototype property of the WebAssembly.Table object returns the length of the table, i.e. the number of elements in the table.
table.length;\n
The following example creates a new WebAssembly Table instance with an initial size of 2 and a maximum size of 10.
var table = new WebAssembly.Table({ element: \"anyfunc\", initial: 2, maximum: 10 }); You can then grow the table by 1 with the following:
console.log(table.length); // \"2\"\nconsole.log(table.grow(1)); // \"2\"\nconsole.log(table.length); // \"3\"\n
| Specification | Status | Comment |
|---|---|---|
| WebAssembly JavaScript Interface The definition of 'length' in that specification. | Working Draft | Initial draft definition. |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n57 | \n16 | \n 52\n
| \nNo | \n44 | \n11 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n57 | \n57 | \n Yes\n
| \n 52\n
| \n? | \n11 | \n7.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n8.0.0 | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table/length\n
The arguments.callee property contains the currently executing function.
callee is a property of the arguments object. It can be used to refer to the currently executing function inside the function body of that function. This is useful when the name of the function is unknown, such as within a function expression with no name (also called \"anonymous functions\").
arguments.callee() in strict mode. Avoid using arguments.callee() by either giving function expressions a name or use a function declaration where a function must call itself.arguments.callee removed from ES5 strict mode?(adapted from a Stack Overflow answer by olliej)
Early versions of JavaScript did not allow named function expressions, and for this reason you could not make a recursive function expression.
For example, this syntax worked:
function factorial (n) {\n return !(n > 1) ? 1 : factorial(n - 1) * n;\n}\n\n[1, 2, 3, 4, 5].map(factorial); but:
[1, 2, 3, 4, 5].map(function(n) {\n return !(n > 1) ? 1 : /* what goes here? */ (n - 1) * n;\n}); did not. To get around this arguments.callee was added so you could do
[1, 2, 3, 4, 5].map(function(n) {\n return !(n > 1) ? 1 : arguments.callee(n - 1) * n;\n}); However, this was actually a really bad solution as this (in conjunction with other arguments, callee, and caller issues) make inlining and tail recursion impossible in the general case (you can achieve it in select cases through tracing, etc., but even the best code is suboptimal due to checks that would not otherwise be necessary.) The other major issue is that the recursive call will get a different this value, e.g.:
var global = this;\n\nvar sillyFunction = function(recursed) {\n if (!recursed) { return arguments.callee(true); }\n if (this !== global) {\n alert('This is: ' + this);\n } else {\n alert('This is the global');\n }\n}\n\nsillyFunction(); ECMAScript 3 resolved these issues by allowing named function expressions. For example:
[1, 2, 3, 4, 5].map(function factorial(n) {\n return !(n > 1) ? 1 : factorial(n - 1)*n;\n}); This has numerous benefits:
Another feature that was deprecated was arguments.callee.caller, or more specifically Function.caller. Why is this? Well, at any point in time you can find the deepest caller of any function on the stack, and as I said above looking at the call stack has one single major effect: it makes a large number of optimizations impossible, or much much more difficult. For example, if you cannot guarantee that a function f will not call an unknown function, it is not possible to inline f. Basically it means that any call site that may have been trivially inlinable accumulates a large number of guards:
function f(a, b, c, d, e) { return a ? b * c : d * e; } If the JavaScript interpreter cannot guarantee that all the provided arguments are numbers at the point that the call is made, it needs to either insert checks for all the arguments before the inlined code, or it cannot inline the function. Now in this particular case a smart interpreter should be able to rearrange the checks to be more optimal and not check any values that would not be used. However in many cases that's just not possible and therefore it becomes impossible to inline.
arguments.callee in an anonymous recursive functionA recursive function must be able to refer to itself. Typically, a function refers to itself by its name. However, an anonymous function (which can be created by a function expression or the Function constructor) does not have a name. Therefore if there is no accessible variable referring to it, the only way the function can refer to itself is by arguments.callee.
The following example defines a function, which, in turn, defines and returns a factorial function. This example isn't very practical, and there are nearly no cases where the same result cannot be achieved with named function expressions.
function create() {\n return function(n) {\n if (n <= 1)\n return 1;\n return n * arguments.callee(n - 1);\n };\n}\n\nvar result = create()(5); // returns 120 (5 * 4 * 3 * 2 * 1) arguments.callee with no good alternativeHowever, in a case like the following, there are not alternatives to arguments.callee, so its deprecation could be a bug (see bug 725398):
function createPerson(sIdentity) {\n var oPerson = new Function('alert(arguments.callee.identity);');\n oPerson.identity = sIdentity;\n return oPerson;\n}\n\nvar john = createPerson('John Smith');\n\njohn(); | Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.2 |
| ECMAScript 5.1 (ECMA-262) The definition of 'Arguments Object' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Arguments Exotic Objects' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Arguments Exotic Objects' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \n6 | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee\n
The initial value of the @@iterator property is the same function object as the initial value of the Array.prototype.values property.
arguments[Symbol.iterator]()
for...of loopfunction f() {\n // your browser must support for..of loop\n // and let-scoped variables in for loops\n for (let letter of arguments) {\n console.log(letter);\n }\n}\nf('w', 'y', 'k', 'o', 'p');\n | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n52 | \n? | \n46 | \nNo | \nYes | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n52 | \n52 | \n? | \n46 | \nYes | \n9 | \n6.0 | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/@@iterator\n
Obsolete
This feature is obsolete. Although it may still work in some browsers, its use is discouraged since it could be removed at any time. Try to avoid using it.
The obsolete arguments.caller property used to provide the function that invoked the currently executing function. This property has been removed and no longer works.
This property is not available anymore, but you can still use Function.caller.
function whoCalled() {\n if (whoCalled.caller == null)\n console.log('I was called from the global scope.');\n else\n console.log(whoCalled.caller + ' called me!');\n} The following code was used to check the value of arguments.caller in a function, but doesn't work anymore.
function whoCalled() {\n if (arguments.caller == null)\n console.log('I was called from the global scope.');\n else\n console.log(arguments.caller + ' called me!');\n}\n Not part of any standard. Implemented in JavaScript 1.1 and removed in bug 7224 due to potentially vulnerable for security.
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support \n | \nNo | \nNo | \nNo | \n? — 9 | \nNo | \nNo | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support \n | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \nNo | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support \n | \nNo | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/caller\n
The arguments.length property contains the number of arguments passed to the function.
arguments.length
The arguments.length property provides the number of arguments actually passed to a function. This can be more or less than the defined parameter's count (see Function.length).
arguments.length\nIn this example we define a function that can add two or more numbers together.
function adder(base /*, n2, ... */) {\n base = Number(base);\n for (var i = 1; i < arguments.length; i++) {\n base += Number(arguments[i]);\n }\n return base;\n}\n Note the difference between Function.length and arguments.length
| Specification | Status | Comment |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | Standard | Initial definition. Implemented in JavaScript 1.1 |
| ECMAScript 5.1 (ECMA-262) The definition of 'Arguments Object' in that specification. | Standard | |
| ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Arguments Exotic Objects' in that specification. | Standard | |
| ECMAScript Latest Draft (ECMA-262) The definition of 'Arguments Exotic Objects' in that specification. | Draft |
| \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \nYes | \nYes | \n1 | \nYes | \nYes | \nYes | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \nYes | \nYes | \nYes | \n4 | \nYes | \nYes | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \nYes | \n
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/length\n
Below, you'll find a list of errors which are thrown by JavaScript. These errors can be a helpful debugging aid, but the reported problem isn't always immediately clear. The pages below will provide additional details about these errors. Each error is an object based upon the Error object, and has a name and a message.
Errors displayed in the Web console may include a link to the corresponding page below to help you quickly comprehend the problem in your code.
In this list, each page is listed by name (the type of error) and message (a more detailed human-readable error message). Together, these two properties provide a starting point toward understanding and resolving the error. For more information, follow the links below!
\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors\n
JavaScript classes, introduced in ECMAScript 2015, are primarily syntactical sugar over JavaScript's existing prototype-based inheritance. The class syntax does not introduce a new object-oriented inheritance model to JavaScript.
Classes are in fact \"special functions\", and just as you can define function expressions and function declarations, the class syntax has two components: class expressions and class declarations.
One way to define a class is using a class declaration. To declare a class, you use the class keyword with the name of the class (\"Rectangle\" here).
class Rectangle {\n constructor(height, width) {\n this.height = height;\n this.width = width;\n }\n} An important difference between function declarations and class declarations is that function declarations are hoisted and class declarations are not. You first need to declare your class and then access it, otherwise code like the following will throw a ReferenceError:
const p = new Rectangle(); // ReferenceError\n\nclass Rectangle {}\n A class expression is another way to define a class. Class expressions can be named or unnamed. The name given to a named class expression is local to the class's body. (it can be retrieved through the class's (not an instance's) name property, though).
// unnamed\nlet Rectangle = class {\n constructor(height, width) {\n this.height = height;\n this.width = width;\n }\n};\nconsole.log(Rectangle.name);\n// output: \"Rectangle\"\n\n// named\nlet Rectangle = class Rectangle2 {\n constructor(height, width) {\n this.height = height;\n this.width = width;\n }\n};\nconsole.log(Rectangle.name);\n// output: \"Rectangle2\"\n Note: Class expressions are subject to the same hoisting restrictions as described in the Class declarations section.
The body of a class is the part that is in curly brackets {}. This is where you define class members, such as methods or constructor.
The body of a class is executed in strict mode, i.e., code written here is subject to stricter syntax for increased performance, some otherwise silent errors will be thrown, and certain keywords are reserved for future versions of ECMAScript.
The constructor method is a special method for creating and initializing an object created with a class. There can only be one special method with the name \"constructor\" in a class. A SyntaxError will be thrown if the class contains more than one occurrence of a constructor method.
A constructor can use the super keyword to call the constructor of the super class.
See also method definitions.
class Rectangle {\n constructor(height, width) {\n this.height = height;\n this.width = width;\n }\n // Getter\n get area() {\n return this.calcArea();\n }\n // Method\n calcArea() {\n return this.height * this.width;\n }\n}\n\nconst square = new Rectangle(10, 10);\n\nconsole.log(square.area); // 100 The static keyword defines a static method for a class. Static methods are called without instantiating their class and cannot be called through a class instance. Static methods are often used to create utility functions for an application.
class Point {\n constructor(x, y) {\n this.x = x;\n this.y = y;\n }\n\n static distance(a, b) {\n const dx = a.x - b.x;\n const dy = a.y - b.y;\n\n return Math.hypot(dx, dy);\n }\n}\n\nconst p1 = new Point(5, 5);\nconst p2 = new Point(10, 10);\n\nconsole.log(Point.distance(p1, p2)); // 7.0710678118654755 When a static or prototype method is called without a value for this, the this value will be undefined inside the method. This behavior will be the same even if the \"use strict\" directive isn't present, because code within the class body's syntactic boundary is always executed in strict mode.
class Animal { \n speak() {\n return this;\n }\n static eat() {\n return this;\n }\n}\n\nlet obj = new Animal();\nobj.speak(); // Animal {}\nlet speak = obj.speak;\nspeak(); // undefined\n\nAnimal.eat() // class Animal\nlet eat = Animal.eat;\neat(); // undefined If the above is written using traditional function-based syntax, then autoboxing in method calls will happen in non–strict mode based on the initial this value. If the initial value is undefined, this will be set to the global object.
Autoboxing will not happen in strict mode, the this value remains as passed.
function Animal() { }\n\nAnimal.prototype.speak = function() {\n return this;\n}\n\nAnimal.eat = function() {\n return this;\n}\n\nlet obj = new Animal();\nlet speak = obj.speak;\nspeak(); // global object\n\nlet eat = Animal.eat;\neat(); // global object\n Instance properties must be defined inside of class methods:
class Rectangle {\n constructor(height, width) { \n this.height = height;\n this.width = width;\n }\n} Static class-side properties and prototype data properties must be defined outside of the ClassBody declaration:
Rectangle.staticWidth = 20;\nRectangle.prototype.prototypeWidth = 25;\n
Public and private field declarations are an experimental feature (stage 3) proposed at TC39, the JavaScript standards committee. Support in browsers is limited, but the feature can be used through a build step with systems like Babel.
With the JavaScript field declaration syntax, the above example can be written as:
class Rectangle {\n height = 0;\n width;\n constructor(height, width) { \n this.height = height;\n this.width = width;\n }\n}\n By declaring fields up-front, class definitions become more self-documenting, and the fields are always present.
As seen above, the fields can be declared with or without a default value.
Using private fields, the definition can be refined as below.
class Rectangle {\n #height = 0;\n #width;\n constructor(height, width) { \n this.#height = height;\n this.#width = width;\n }\n}\n It's an error to reference private fields from outside of the class; they can only be read or written within the class body. By defining things which are not visible outside of the class, you ensure that your classes' users can't depend on internals, which may change version to version.
Private fields can only be declared up-front in a field declaration.
Private fields cannot be created later through assigning to them, the way that normal properties can.
extends\nThe extends keyword is used in class declarations or class expressions to create a class as a child of another class.
class Animal { \n constructor(name) {\n this.name = name;\n }\n \n speak() {\n console.log(this.name + ' makes a noise.');\n }\n}\n\nclass Dog extends Animal {\n constructor(name) {\n super(name); // call the super class constructor and pass in the name parameter\n }\n\n speak() {\n console.log(this.name + ' barks.');\n }\n}\n\nlet d = new Dog('Mitzie');\nd.speak(); // Mitzie barks.\n If there is a constructor present in the subclass, it needs to first call super() before using \"this\".
One may also extend traditional function-based \"classes\":
function Animal (name) {\n this.name = name; \n}\n\nAnimal.prototype.speak = function () {\n console.log(this.name + ' makes a noise.');\n}\n\nclass Dog extends Animal {\n speak() {\n console.log(this.name + ' barks.');\n }\n}\n\nlet d = new Dog('Mitzie');\nd.speak(); // Mitzie barks.\n Note that classes cannot extend regular (non-constructible) objects. If you want to inherit from a regular object, you can instead use Object.setPrototypeOf():
const Animal = {\n speak() {\n console.log(this.name + ' makes a noise.');\n }\n};\n\nclass Dog {\n constructor(name) {\n this.name = name;\n }\n}\n\n// If you do not do this you will get a TypeError when you invoke speak\nObject.setPrototypeOf(Dog.prototype, Animal);\n\nlet d = new Dog('Mitzie');\nd.speak(); // Mitzie makes a noise.\n You might want to return Array objects in your derived array class MyArray. The species pattern lets you override default constructors.
For example, when using methods such as map() that returns the default constructor, you want these methods to return a parent Array object, instead of the MyArray object. The Symbol.species symbol lets you do this:
class MyArray extends Array {\n // Overwrite species to the parent Array constructor\n static get [Symbol.species]() { return Array; }\n}\n\nlet a = new MyArray(1,2,3);\nlet mapped = a.map(x => x * x);\n\nconsole.log(mapped instanceof MyArray); // false\nconsole.log(mapped instanceof Array); // true\n super\nThe super keyword is used to call corresponding methods of super class. This is one advantage over prototype-based inheritance.
class Cat { \n constructor(name) {\n this.name = name;\n }\n \n speak() {\n console.log(`${this.name} makes a noise.`);\n }\n}\n\nclass Lion extends Cat {\n speak() {\n super.speak();\n console.log(`${this.name} roars.`);\n }\n}\n\nlet l = new Lion('Fuzzy');\nl.speak(); \n// Fuzzy makes a noise.\n// Fuzzy roars.\n Abstract subclasses or mix-ins are templates for classes. An ECMAScript class can only have a single superclass, so multiple inheritance from tooling classes, for example, is not possible. The functionality must be provided by the superclass.
A function with a superclass as input and a subclass extending that superclass as output can be used to implement mix-ins in ECMAScript:
let calculatorMixin = Base => class extends Base {\n calc() { }\n};\n\nlet randomizerMixin = Base => class extends Base {\n randomize() { }\n};\n A class that uses these mix-ins can then be written like this:
class Foo { }\nclass Bar extends calculatorMixin(randomizerMixin(Foo)) { } | \n | Desktop | \n|||||
|---|---|---|---|---|---|---|
| \n | Chrome | \nEdge | \nFirefox | \nInternet Explorer | \nOpera | \nSafari | \n
| Basic support | \n 49\n
| \n13 | \n45 | \nNo | \n36 | \n9 | \n
constructor | \n 49\n
| \n13 | \n45 | \nNo | \n36 | \n9 | \n
extends | \n 49\n
| \n13 | \n45 | \nNo | \n36 | \n9 | \n
static | \n 49\n
| \n13 | \n45 | \nNo | \n36 | \n9 | \n
| \n | Mobile | \n||||||
|---|---|---|---|---|---|---|---|
| \n | Android webview | \nChrome for Android | \nEdge Mobile | \nFirefox for Android | \nOpera for Android | \niOS Safari | \nSamsung Internet | \n
| Basic support | \n? | \nYes | \n13 | \n45 | \n? | \n9 | \nYes | \n
constructor | \n? | \nYes | \n13 | \n45 | \n? | \n9 | \nYes | \n
extends | \n? | \nYes | \n13 | \n45 | \n? | \n9 | \nYes | \n
static | \n? | \nYes | \n13 | \n45 | \n? | \n9 | \nYes | \n
| \n | Server | \n
|---|---|
| \n | Node.js | \n
| Basic support | \n 6.0.0\n
| \n
constructor | \n 6.0.0\n
| \n
extends | \n 6.0.0\n
| \n
static | \n 6.0.0\n
| \n
A class can't be redefined. If you're playing with code in Scratchpad (Firefox menu Tools > Web Developer > Scratchpad) and you 'Run' a definition of a class with the same name twice, you'll get a confusing SyntaxError: redeclaration of let <class-name>.
To re-run a definition, use Scratchpad's menu Execute > Reload and Run.
Please vote for bug #1428672.
class declarationclass expressionsuper\n © 2005–2018 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
\n https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes\n