I understand about how `eval()` works in non-strict contexts, however the case of using `eval()` in strict mode has completely befuddled me.  When `eval()` is called directly in the global scope, variables are kept inside the new `eval()` scope:

    &#39;use strict&#39;;
    eval(&#39;var a = 1;&#39;);
    console.log(a); // ReferenceError: a is not defined

However, if I perform an _indirect_ call to `eval()` in the global scope (should be the same thing, right?), it acts as though it is not in strict mode (if you don&#39;t believe me, see [this JSFiddle][7]):

    &#39;use strict&#39;;
    (0, eval)(&#39;var a = 1;&#39;); // indirect call to eval
    console.log(a); // 1???

&lt;sub&gt;For an explanation of what `(0, eval)` does: see [Why does google main page use (0, obj.func)(args) syntax?](https://stackoverflow.com/questions/19535601/why-does-google-main-page-use-0-obj-funcargs-syntax).&lt;/sub&gt;

At least according to my understanding of how `eval()` is supposed to work in strict mode, it is meant to (no matter whether `eval()` is called directly or indirectly) create a new scope for variables defined in the `eval()` call, however this doesn&#39;t seem to be the case here. (ECMA-262 spec 5th ed [10.4.2][1])

This is the case in all major browsers (including Internet Explorer 10, Chrome 30 and Firefox 24) so I don&#39;t think it&#39;s a bug.  Aren&#39;t they both meant to do the same thing, and if not, why is this the case?

&lt;sub&gt;Note: yes, I know the &quot;dangers&quot; of using `eval()` - I simply want to understand the logic behind this :)&lt;/sub&gt;
      
[1]: http://ecma-international.org/ecma-262/5.1/#sec-10.4.2 &quot;link to this section&quot;
[2]: http://ecma-international.org/ecma-262/5.1/#sec-15.1.2.1.1
[3]: http://ecma-international.org/ecma-262/5.1/#sec-10.4.1.1
[4]: http://ecma-international.org/ecma-262/5.1/#sec-10.3
[5]: http://ecma-international.org/ecma-262/5.1/#sec-10.5
[6]: http://ecma-international.org/ecma-262/5.1/#sec-10.2.2.2
[7]: http://jsfiddle.net/hSLJq/3/

Indirect eval call in strict mode

What is the difference between a shim an a sham?

Is it enough to include es5-shim.min.js and es6-shim.min.js or should I also include es5-sham.min.js and es6-sham.min.js?

Shim vs. Sham: What is the difference?

Anyone know the time-complexity of ECMAScript5&#39;s Object.keys() in common implementations?  Is it `O(n)` for `n` keys?  Is time proportional to the size of the hash table, assuming a hash implementation?

I&#39;m looking for either guarantees by language implementors or some real world benchmarking.

Object.keys() complexity?

I&#39;m wondering what is the difference between `let` and `const` in **ES6**. Both of them are block scoped, as the example in the following code:

       
    const PI = 3.14;
    console.log(PI);
    
    PI = 3;
    console.log(PI);
    
    const PI = 4;
    console.log(PI);
    
    var PI = 5;
    console.log(PI);

In ES5 the output will be:

    3.14
    3.14
    3.14
    3.14

But in ES6 it will be:

    3.14
    3
    4
    5

I&#39;m wondering why **ES6** allows the change of `const` value, the question is why should we use &#39;const&#39; now? we can use &#39;let&#39; instead?

**Note**: [jsbin][1] can be used for testing, choose **JavaScript** to run **ES5** code and **Traceur** to run it with **ES6** capabilities.


  [1]: http://jsbin.com/nularebi/2/edit

What is the difference between &#39;let&#39; and &#39;const&#39; ECMAScript 2015 (ES6)?

I just heard about the JavaScript methods `freeze` and `seal`, which can be used to make any Object immutable.

Here&#39;s a short example how to use it:

    var o1 = {}, o2 = {};
    Object.freeze(o2);

    o1[&quot;a&quot;] = &quot;worked&quot;;
    o2[&quot;a&quot;] = &quot;worked&quot;;

    alert(o1[&quot;a&quot;]);   //prints &quot;worked&quot;
    alert(o2[&quot;a&quot;]);   //prints &quot;undefined&quot;

What is the difference between `freeze` and `seal`? Can they increase performance?

Difference between freeze and seal

I was looking at some snippets of code, and I found multiple elements calling a function over a node list with a forEach applied to an empty array.

For example I have something like:

    [].forEach.call( document.querySelectorAll(&#39;a&#39;), function(el) {
       // whatever with the current node
    });

but I can&#39;t understand how it works. Can anyone explain me the behaviour of the empty array in front of the forEach and how the `call` works?

What does [].forEach.call() do in JavaScript?

I use Traceur Compiler to have advantage with ES6 features now. 

I want to implement this stuff from ES5:

    function Animal() {
        var self = this,
            sayHi;
        
        sayHi  = function() {
            self.hi();
        };
    
        this.hi = function() {/* ... */}
    }

Currently traceur does not support `private` and `public` keywords ([from harmony][1]). And ES6 class syntax does not allow to use simple `var` (or `let`) statements in class body. 

The only way that I am find is to simulate privates before class declaration. Something like:

    var sayHi = function() {
        // ... do stuff
    };
    
    class Animal {
    ...

It is better then nothing but as expected you can not pass correct `this` to private method without `apply`-ing or `bind`-ing it every time.

So, is there any possibility to use private data in ES6 class compatible with traceur compiler?


  [1]: http://wiki.ecmascript.org/doku.php?id=harmony:classes

How to implement private method in ES6 class with Traceur

When I reduce the array, I am trying to get the number zero, but I dont clearly understand the behaviour of the function

	[].reduce(function(previousValue, currentValue){
	  return Number(previousValue) + Number(currentValue);
	});

result

	TypeError: Reduce of empty array with no initial value

seems that if the array is empty I can&#39;t reduce it

	[&quot;&quot;].reduce(function(previousValue, currentValue){
	  return Number(previousValue) + Number(currentValue);
	});

result

	&quot;&quot;

If the only element in the array is an empty string, retrieves an empty string

Javascript Reduce an empty array

I&#39;ve run into the following code in the es-discuss mailing list:

    Array.apply(null, { length: 5 }).map(Number.call, Number);
    
This produces
 
    [0, 1, 2, 3, 4]

Why is this the result of the code? What&#39;s happening here?


Creating range in JavaScript - strange syntax

I have an object that could be any number of levels deep and could have any existing properties.
For example:

&lt;!-- language: lang-js --&gt;

    var obj = {
        db: {
            mongodb: {
                host: &#39;localhost&#39;
            }
        }
    };

On that I would like to set (or overwrite) properties like so:

&lt;!-- language: lang-js --&gt;

    set(&#39;db.mongodb.user&#39;, &#39;root&#39;);
    // or:
    set(&#39;foo.bar&#39;, &#39;baz&#39;);

Where the property string can have any depth, and the value can be any type/thing.  
Objects and arrays as values don&#39;t need to be merged, should the property key already exist.

Previous example would produce following object:

&lt;!-- language: lang-js --&gt;

    var obj = {
        db: {
            mongodb: {
                host: &#39;localhost&#39;,
                user: &#39;root&#39;
            }
        },
        foo: {
            bar: baz
        }
    };

How can I realize such a function?

Dynamically set property of nested object

Why are objects not iterable by default?

**I see questions all the time related to iterating objects, the common solution being to iterate over an object&#39;s properties and accessing the values within an object that way. This seems so common that it makes me wonder why objects themselves aren&#39;t iterable.**

Statements like the ES6 [`for...of`][1] would be nice to use for objects by default. Because these features are only available for special &quot;iterable objects&quot; which don&#39;t include `{}` objects, we have to go through hoops to make this work for objects we want to use it for. 

&gt; The for...of statement creates a loop Iterating over **iterable objects**
&gt; (including Array, Map, Set, arguments object and so on)...

For example using an ES6 [generator function][2]:

    var example = {a: {e: &#39;one&#39;, f: &#39;two&#39;}, b: {g: &#39;three&#39;}, c: {h: &#39;four&#39;, i: &#39;five&#39;}};
    
    function* entries(obj) {
       for (let key of Object.keys(obj)) {
         yield [key, obj[key]];
       }
    }
    
    for (let [key, value] of entries(example)) {
      console.log(key);
      console.log(value);
      for (let [key, value] of entries(value)) {
        console.log(key);
        console.log(value);
      }
    }

The above properly logs data in the order I expect it to when I run the code in Firefox (which supports [ES6][3]):

![output of hacky for...of][4]

**By default, `{}` objects are not iterable, but why? Would the disadvantages outweigh the potential benefits of objects being iterable? What are the issues associated with this?**

In addition, because `{}` objects are different from &quot;Array-like&quot; collections and &quot;iterable objects&quot; such as [`NodeList`][7], [`HtmlCollection`][8], and [`arguments`][9], they can&#39;t be converted into Arrays.

For example:

`var argumentsArray = Array.prototype.slice.call(arguments);` 

or be used with Array methods:

`Array.prototype.forEach.call(nodeList, function (element) {})`.

**Besides the questions I have above, I would love to see a working example on how to make `{}` objects into iterables, especially from those who have mentioned the `[Symbol.iterator]`.** This should allow these new `{}` &quot;iterable objects&quot; to use statements like `for...of`. Also, I wonder if making objects iterable allow them to be converted into Arrays.

I tried the below code, but I get a `TypeError: can&#39;t convert undefined to object`.

    var example = {a: {e: &#39;one&#39;, f: &#39;two&#39;}, b: {g: &#39;three&#39;}, c: {h: &#39;four&#39;, i: &#39;five&#39;}};
    
    // I want to be able to use &quot;for...of&quot; for the &quot;example&quot; object.
    // I also want to be able to convert the &quot;example&quot; object into an Array.
    example[Symbol.iterator] = function* (obj) {
       for (let key of Object.keys(obj)) {
         yield [key, obj[key]];
       }
    };
    
    for (let [key, value] of example) { console.log(value); } // error
    console.log([...example]); // error


  [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of
  [2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*
  [3]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla
  [4]: http://i.stack.imgur.com/SSJbr.png
  [5]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in
  [6]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for
  [7]: https://developer.mozilla.org/en-US/docs/Web/API/NodeList
  [8]: https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection
  [9]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments
  [10]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols

Why are Objects not Iterable in JavaScript?

I&#39;m playing with Node.js and Mongoose — trying to find specific comment in deep comments nesting with recursive function and `forEach` within. Is there a way to stop Node.js `forEach`? As I understand every `forEach` iteration is a function and and I can&#39;t just do `break`, only `return` but this won&#39;t stop `forEach`.

```js
function recurs(comment) {
    comment.comments.forEach(function(elem) {

        recurs(elem);

        //if(...) break;

    });
}
```

how to stop Javascript forEach?

I would like to get the keys of a JavaScript object as an array, either in jQuery or pure JavaScript.

Is there a less verbose way than this?

    var foo = { &#39;alpha&#39; : &#39;puffin&#39;, &#39;beta&#39; : &#39;beagle&#39; };
    var keys = [];
    for (var key in foo) {
        keys.push(key);
    }


Get array of object&#39;s keys

I am trying to run this code but it is giving me following errors:

&gt; Animal.ts(10,13): error TS1056: Accessors are only available when
&gt; targeting ECMAScript 5 and higher. Animal.ts(14,13): error TS1056:
&gt; Accessors are only available when targeting ECMAScript 5 and higher.


    interface IAnimal{
        name : string;
        sayName():string;
    }

    class AnimalImpm implements IAnimal{
        private _name : string = &#39;[Animal]&#39;;
        get name():string{
            return this._name;
        }

        set name(name:string){
            this._name = name;
        }

        constructor(name:string){
            this.name = name;
        }

        sayName():string {
            console.log(`My name is ${this.name}`);
            return &quot;Hello&quot;;
        }
    }


Accessors are only available when targeting ECMAScript 5 and higher

Is there anyway to check if strict mode &#39;use strict&#39; 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`

Is there any way to check if strict mode is enforced?

JavaScript 1.8.5 (ECMAScript 5) adds some interesting methods that **prevent future modifications** of a passed object, with varying degrees of thoroughness:

 - [`Object.preventExtensions(obj)`][1]
 - [`Object.seal(obj)`][2] 
 - [`Object.freeze(obj)`][3] 

Presumably the main point of these is to catch mistakes: if you know that you don&#39;t want to modify an object after a certain point, you can lock it down so that an error will be thrown if you inadvertently try to modify it later. (Providing you&#39;ve done `&quot;use strict&quot;;` that is.)

**My question:** in modern JS engines such as V8, is there any performance benefit (eg, faster property look-ups, reduced memory footprint) in locking down objects using the above methods?

(See also [John Resig&#39;s nice explanation][4] – doesn&#39;t mention performance, though.)

  [1]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/preventExtensions
  [2]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/seal
  [3]: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/freeze
  [4]: http://ejohn.org/blog/ecmascript-5-objects-and-properties/

Any performance benefit to &quot;locking down&quot; JavaScript objects?

I don&#39;t find anything about my question here on MDC or the ECMAscript specifications. Probably somebody knows a more &#39;hacky&#39; way to solve this.

I&#39;m calling `&quot;use strict&quot;` on every javascript file in my environment. All my files start like this

    (function(win, doc, undef) {
        &quot;use strict&quot;;

        // code &amp; functions
    }(window, window.document));

Now, I have a custom function which handles errors. That functions uses the `.caller` property to provide a *context stack trace*. Looks like this:

    var chain = (function() {
        var _parent = _error,
            _ret = &#39;&#39;;
								
        while( _parent.caller ) {
            _ret += &#39; -&gt; &#39; + _parent.caller.name;
            _parent = _parent.caller;
        }

        return _ret;
    }());

But of course, in strict mode `.caller` is a non-deletable prop which throws when retrieved. So my question is, is anybody aware of way to *disable* strict more &quot;function-wise&quot; ?

`&quot;use strict&quot;;` is inherited by all functions after it was called. Now we have the possibilty to just use strict mode in specific functions by just calling `&quot;use strict&quot;;` at the top of those, but is there a way to achieve the opposite ?



Can I disable ECMAscript strict mode for specific functions?

If I type `019 &gt; 020` in the JavaScript console (tested in both Chrome and Firefox), I get the answer `true`.

This is due to `020` being interpreted as an [`OctalIntegerLiteral`][1] (equals `16`) whereas `019` is apparently being interpreted as [`DecimalLiteral`][2] (and equals `19`). As `19` is greater than `16`, `019 &gt; 020` is `true`.

What puzzles me is why `019` is interpreted as a `DecimalLiteral` in first place. Which production is it? `DecimalIntegerLiteral` does not allow `019`:

    DecimalIntegerLiteral ::
        0
        NonZeroDigit DecimalDigits_opt

`OctalIntegerLiteral` also does not allow `019` (as `9` is not an octal digit):

    OctalIntegerLiteral ::
        0 OctalDigit
        OctalIntegerLiteral OctalDigit
    
    OctalDigit :: one of
        0 1 2 3 4 5 6 7

So from what I see in the specification, `019` should actually be rejected, I don&#39;t see why it is interpreted as a decimal integer.

I guess there&#39;s some kind of compatibility rule in place here but I have failed to find a formal definition. Could please anyone help me with this?

(Why I need this: I&#39;m developing a [JavaScript/ECMAScript parser for Java with JavaCC][3] and have to pay a special attention to the specification - and deviations thereof.)


  [1]: http://www.ecma-international.org/ecma-262/5.1/#sec-B.1.1
  [2]: http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.3
  [3]: https://github.com/highsource/javascript-codemodel

Why is 019 not a JavaScript syntax error? Or why is 019 &gt; 020

&gt; ***NOTE**: This question was asked from the viewpoint of ECMAScript version 3 or 5. The answers might become outdated with the introduction of new features in the release of ECMAScript 6.*

What exactly is the function of the `var` keyword in JavaScript, and what is the difference between

    var someNumber = 2;
    var someFunction = function() { doSomething; }
    var someObject = { }
    var someObject.someProperty = 5;

and

    someNumber = 2;
    someFunction = function() { doSomething; }
    someObject = { }
    someObject.someProperty = 5;

?

When would you use either one, and why/what does it do?


What is the purpose of the var keyword and when should I use it (or omit it)?

I&#39;m wondering when I should use 

    Object.defineProperty

to create new properties for an object. I&#39;m aware that I&#39;m able to set things like 

    enumerable: false

but when do you need this really? If you just set a property like

    myObject.myprop = 5;

its descriptors are all set to true, right? I&#39;m actually more curious when you guys use that rather verbose call to .defineProperty() and for what reasons.


when do you use Object.defineProperty()

I&#39;m fairly new to javascript. I noticed that apparently when operating in &quot;use strict&quot; mode, you can&#39;t delete objects. I&#39;m not a huge fan of deleting things (since, in theory, scope should take care of that anyway), but I wonder what was the motivation behind removing this feature?

All Ecmascript 5 Solutions on Gang of Coders

Total of 21 Ecmascript 5 Solutions