In the lexical this the ES6 and ES5 (1st variant) examples doesn't really show any difference. The this in lambda depends on the context where the lambda was created. Here both are assumed to be global. Had the ES6 example kept such that the lambda was created inside another function/context where the this object is something other than the global this, then it would make more sense!

The const keyword simply means variables can't be reassigned or rebound to new objects.

Example:

const name = "Jamon"
name = "Not Jamon"
name
// "Jamon"

However, the objects they are bound to can be mutated.

const mut = {}
mut.name = "I mutated"
mut
// Object {name: "I mutated"}

Hey Ralf, great work on es6-features.org Would be nice to have each feature classified with their support status, and also I couldn't find list comprehensions, are they there and I can't find them or is it missing? Keep it up!

I see that in the source code viewers there's a modernized vs traditional mode, the modernized not containing any semicolons. What makes this any modern than the semicoloned version? I personally think it's a bad practice. Worse yet, the modernized is the default for ES6, suggesting that no semicolons should be used for ES6 code.

Not that it really matters... but ya this way looks way better and doesn't have any drawbacks as far as I can tell it's the exact same as the example.

Placing a function declaration inside another function declaration has been valid JavaScript since Netscape 2.0, and moreover has never been disallowed by strict mode.

In http://es6-features.org/#Proxing:

Instead of:

let proxy = new Proxy(target, {
    get (receiver, name) {
        return `Hello, ${name}!!`
    }
})

Shouldn't it be:

let proxy = new Proxy(target, {
    get: function (receiver, name) {
        return `Hello, ${name}!!`
    }
})

?

Currently the examples default to ES6 using the Modernized style (no semicolons) and ES5 using the Traditional style (with semicolons). This introduces a misleading and orthogonal extra diff when comparing the various examples. Please consider making Modernized/Traditional a single setting that modifies both the ES6 and ES5 example code at the same time. And please consider defaulting it to traditional. As it stands, I hesitate to forward a link to this site to my coworkers who are just getting started with ES6 since it adds unnecessary confusion and will trigger a knee-jerk reaction against ES6 due to "ES6 is anti-semicolons!" :wink:

The Map/Set example doesn't work

https://github.com/rse/es6-features/blob/38f6a8499116f5207806272eaa6a4a9153293068/features.txt

let m = new Map()
m.set("hello", 42)
m.set(s, 34)

It seems like semicolons doesn't appear on ES6 examples on the pages. If you look at features.txt:605 you see semicolons even though they're not visible on the site.

Hello! I thought it might be interesting to introduce another way of using default parameters ECMA5

From:

function f (x, y, z) {
    if (y === undefined)
        y = 7;
    if (z === undefined)
        z = 42;
    return x + y + z;
};
f(1) === 50;

To (using OR):

function f (x, y, z) {
    if (y === undefined)
        y = 7;
    z = z || 42;
    return x + y + z;
};
f(1) === 50;

The result from ES6 Array Matching is not what it is expected to be with syntactic sugar which is the default.

var list = [ 1, 2, 3 ]
var [ a, , b ] = list
[ b, a ] = [ a, b ]

The result is supposed to be a is 3 and b is 1, but due to the syntactic sugar, a and b are all undefined. That is because the code will be like

var [ a, , b ] = list[ b, a ] = [ a, b ]

Therefore, I just put square brackets for the last sentence.

There is a problem in the following example:

https://github.com/rse/es6-features/blob/75bf0b4ea1b1922f80d759977c138f14ecf24d91/features.txt#L1340-L1362

Manipulating username on line 1361/1353 cannot work. The username is UI8 array and the setter just manipulates the first byte only.

After this assignment:

https://github.com/rse/es6-features/blob/75bf0b4ea1b1922f80d759977c138f14ecf24d91/features.txt#L1322

See the following lines:

https://github.com/rse/es6-features/blob/75bf0b4ea1b1922f80d759977c138f14ecf24d91/features.txt#L1323-L1324

Those basically test if value null is in the map/set, not if foo is still in the map/set. There exists no way to check whether the value is in the map/set when the last reference is lost, so those tests actually do not test what they are trying to show.

To improve user's experience and site's visual appeal I've modified overflow behavior (on content and sidebar) so that it's visible or hidden as per requirement.

Also, I've improved spacing around texts in the sidebar to make it feel less cluttered and a bit easier on eyes + visually appealing.

I have a code that i was expecting will return 'undefined' or any error but it gives output as mentioned.

let i = (x, c) => { c(x); }; i(20, (undefined) => { let j = undefined; console.log(j); // output 20 });

function y(undefined) { let a = undefined; console.log(a); //output 90 } y(90); // same result with let,promise,map,filter How keywords works and change behavior if used as function arguments?