ecma262

There are many cases in which JavaScript's type-coercing equality operator is not transitive. For example, see " JavaScript equality transitivity is weird ." However, are there any cases in which == isn't symmetric ? That is, where a == b is true and b == a is false ? SLaks In Javascript, == is always symmetric . The spec says : NOTE 2 The equality operators maintain the following invariants: A != B is equivalent to !(A == B) . A == B is equivalent to B == A , except in the order of evaluation of A and B . It's supposed to be symmetric. However, there is an asymmetric case in some versions of

I'm reading about JavaScript closures . I'm familiar with Execution Contexts , how the Lexical Environment is maintained, and very familiar with Lexical Scoping . I want to know how closures in JavaScript are created and maintained . Sometimes it's hard for me to grasp such important concepts without knowing how it is actually doing it. I know that, according to Wikipedia, a closure is is a function or reference to a function together with a referencing environment—a table storing a reference to each of the non-local variables (also called free variables) of that function. But my question is,

So Safari and Chrome have started in their betas to implement some ES5 stuff. For instance Object.create is in them. Do any of you know if there is a website that shows the progress made in the browsers? ATM i need to use Object.freeze, and wanted to see which browsers (if any) supported that yet. Tihauan Here's an up to date list for major engines: http://kangax.github.com/es5-compat-table/ 来源： https://stackoverflow.com/questions/2280115/ecmascript-5-browser-implementation

Is the term "activation object" just another name of "variable object" or is there actually any difference between them? I have been reading a few JavaScript articles about how variable scopes are formed in an execution context, and from my point of view it seems that in most of the articles they use these two terms interchangeably. Well, I just learned something :). From this article , it would appear that within the execution context of a function , the Activation Object is used as the Variable Object: When an execution context is created a number of things happen in a defined order. First,

Is there anyway to check if strict mode 'use strict' is enforced , and we want to execute different code for strict mode and other code for non-strict mode. Looking for function like isStrictMode();//boolean The fact that this inside a function called in the global context will not point to the global object can be used to detect strict mode: var isStrict = (function() { return !this; })(); Demo: > echo '"use strict"; var isStrict = (function() { return !this; })(); console.log(isStrict);' | node true > echo 'var isStrict = (function() { return !this; })(); console.log(isStrict);' | node false

Configurable properties seem to be deletable: var o = {}; Object.defineProperty(o, 'prop', { configurable: true, value: 'val' }); delete o.prop; // true o.prop; // undefined But it doesn't work in the following case, at least on Firefox and Chrome: var form = document.createElement('form'), input = document.createElement('input'); form.appendChild(input); var elems = form.elements; Object.getOwnPropertyDescriptor(form, 0) .configurable; // true <────────────────────── !!! delete elems[0]; // false │ elems[0]; // input │ (function(){ 'use strict'; // V delete elems[0]; // TypeError: property 0

Could someone clarify what the difference is between these two, as they exist in the Execution context? It's hard for me to read the ECMA 262 v 5 specification and clearly see the difference. Thank You, Bergi Both are components (of the same type) of Execution Contexts, but they serve distinct purposes ( from the spec ): LexicalEnvironment Identifies the Lexical Environment used to resolve identifier references made by code within this execution context. VariableEnvironment Identifies the Lexical Environment whose environment record holds bindings created by VariableStatements and

Why does JSON only allow a string to be a key of a pair? Why not other types such as null , number , bool , object , array ? Considering JSON is tightly related with JavaScript, could I conclude the reason from JavaScript specification (ECMA-262)? I'm totally a newbie to JavaScript, could you help me to point it out. The JSON format is deliberately based on a subset of JavaScript object literal syntax and array literal syntax, and JavaScript objects can only have strings as keys - thus JSON keys are strings too. (OK, you can sort of use numbers as JavaScript object keys, but really they get