Arrow functions are also known as fat arrow functions. It is a function and is similar to what we use in C#, Java, and Coffee Script. Statements and expression bodies are supported by arrows. The lexical of arrows is similar to its surrounding code. This is not the case in functions.

As the name suggests, arrow functions use a shorter syntax, an arrow (=>), for definition and in syntax.

For example, look at the following example:

// An empty arrow function returns undefined
let empty =()=>{};

(()=>"pine")()// returns "pine"

var simple = a => a >20?20: a;
simple(20);// 20
simple(10);// 10

let max =(a, b)=> a > b ?a : b;

// Easy array filtering, mapping, ...

varsampleArray=[7,4,1,0,3,5,11];
var sum =sampleArray.reduce((a, b)=> a + b);// The answer is 29
var even =sampleArray.filter(v => v %2==0);// The answer is [4, 0]
var odd =sampleArray.filter(v => v %2!=0);// The answer is [7, 1, 3, 5, 11]
var double =sampleArray.map(v => v *2);// The answer is[14, 8, 2, 0, 6, 10, 22]

An arrow function expression or a fat arrow function are shorter in syntax when compared with function expressions. Arrow function is used to bind the value of this. (It does not binds its own arguments, super, this or new.target). Arrow functions are anonymous.

The yield keyword is used to pause and resume a generator function (function* function keyword with an asterisk defines a generator function that returns a Generator object).

ES6 classes' syntax is simpler and easier than that of area syntactical sugar over the prototype-based object-oriented pattern. It is a syntactical sugar. One-time declaration makes class patterns easier to use and simplifies the use of class patterns. Classes support constructors, instance, prototype-based inheritance, static methods, and super calls.

Here is an example of writing a class in ES6 and ES5:

//ES5
functionsomeES5Class(fname, age) { // standard way to create an object prototype i.e. constructor function
  this.fname = fname;
  this.age = age;
}

someES5Class.prototype.sayName = function() { //prototype property enables us to add new functions to an existing prototype
  console.log(this.fname);
}

someES5Class.prototype.sayAge = function() { //prototype property enables us to add new functions to an existing prototype
  console.log(this.age);
}

varmyInstance = new someES5Class('Talha', 25); //new keyword is used with a constructor function to create new objects from the same prototype
myInstance.sayName(); //the new method can then be called as a regular member
myInstance.sayAge();

/*Output:
Talha
25*/

//ES6
classsomeES6Class { // ES6 class
  constructor(fname, age) { // a constructor is defined with default parameters
    this.fname = fname;
    this.age = age;
  }

  sayName() { //functions can be added to the class
    console.log(this.fname);
  }

  sayAge() { //functions can be added to the class
    console.log(this.age);
  }
}

varmyInstance = new someES6Class('Talha', 25); //new keyword is used to create new objects from the class
myInstance.sayName(); //functions are the class members and can be called directly
myInstance.sayAge();
/*Output:
Talha
25*/

Object literals is one of the most popular patterns of JavaScript. JSON is based on object literals. The reason for its popularity is that it provides a very quick, short, and neat way to do key:value assignments, define methods, evaluate expressions, and make super calls. ES6 has extended the object literal syntax in various ways. This makes them more useful. Two types of extensions for object literals are explained here.

functioncreateStudent(StudentID, name, class) {
  return {
    StudentID: StudentID,
    name: name,
    class: class,
  };
}

functioncreateStudent(StudentID, name, class) {
  return {
    StudentID,
    name,
    class,
  };
}

varcustomer = {
  name: "Samantha",
  logName: function() {
    console.log(this.name);
  }
};

varcustomer = {
  name: "Samantha",
  logName() {
    console.log(this.name);
  }
};
person.logName();varobject = {
  // __prototype__
  __prototype__: theProtoTypeObj,
  // Shorthand for 'handler: handler'
  handler,
  // Methods
  toString() {
    // Super calls
    return "x " + super.toString();
  },
  // Dynamic property names
  [ 'property_' + (() => 20)() ]: 20
};

Template strings amplify ECMAScript with syntactic sugar to build string. This component is like string introduction highlights in Perl, Python, and so on. You can likewise add a tag to permit redid string development, staying away from and counteracting infusion assaults or building complex information structures from string substance. They also enable us to create domain-specific languages (DSLs) to deal with content in a safe way.

Instead of adding more extending functionality to JavaScript strings, template strings provide a total new approach for string interpolation.

literal${substitution_variable}literal

letbasic_string = `Kung Fu Panda`;

console.log(basic_string);               // "Kung Fu Panda"
console.log(typeofbasic_string);        // "string"
console.log(basic_string.length);        // 13

letbasic_string = ``Kung Fu` Panda.`;      // `Kung Fu' Panda

letmultiline_string = "Kung Fu Panda, 

Releasing in 2016";

console.log(multiline_string);

Kung Fu Panda
Releasing in 2016

In JavaScript, destructuring means pattern matching. In ES6, we can do efficient pattern matching in objects and arrays. Earlier, this was a long and complicated task. Here are some working examples written in a client console.

Fetching data from objects and arrays is very common in JavaScript. Object properties are usually stored in local variables for instant access. Let's take a look at the following code snippet:

var settings = {
  replay: true,
  save: false
};

// later

varlocalReplay = options.replay,
localSave = options.save;

ES6 made this easier by introducing destructuring assignments, which goes through an object or an array and stores specified values in the local variables. It allows binding using pattern matching for objects and arrays.

var [ first, last ] = ["one", "hundred"] // initialize
console.log(first + " to " + last); // one to hundred

[first, last] = [last, first] // variable swapping
console.log(first + " to " + last); // hundred to one

function dob() {
  return [29, "November", 1990, "Thursday"];
}
var [date, month, year, day] = dob();
console.log("My date of birth is on " + date + " " + month); // My date of birth is on 29 November

function dob() {
  return {
    date: 29,
    month: "November",
    year: 1990,
    time: {
      hour: 12, // nested
      minute: 35,
      meridian: "AM"
    }
  };
}

var { date: d, month: m, time : { hour: h, meridian: p } } = dob();
// h is the nested property while year and minute is skipped

console.log("I was born on " + d + " " + m + " at " + h + " " + p); // I was born on 29 November at 12 AM

Functions are an important and fundamental part of any language. ES6 has introduced a number of incremental improvements in functions. This makes them less error prone and more powerful.

Functions allow any number of parameters to be passed irrespective of the number of parameters in the function definition. There are three types of these parameters that could be passed to functions:

function multiply(x, y) {
  y = typeofy !== 'undefined' ?  y : 1;

  returnx*y;
}

multiply(10);

//Rest Parameter
function sum(…nums) {
  var result = 0;
  nums.forEach(function(number) {
    result += number;
  });
  return result;
}
console.log(sum(1)); // 1
console.log(sum(1, 2, 3)); // 6 

//Spread Operator
functionsum2(a, b, c) {
  return a + b + c;
}
varargs = [1, 2];
console.log(sum(…args, …args, 3)); // 6

function sum() {
  return ;
}
console.log(sum(
(1, 2)
//Spread Operator

//Rest Parameter
//Default Parameter Values
//Default Parameter Values
functioninc(num, increment = 1) {
  returnnum + increment;
}
console.log(inc(2, 2)); // 4
console.log(inc(4)); // 5

The let keyword is a new var. The declaration syntax for the let keyword is the same as for var. You can basically replace var with let to declare a variable but keep its scope to the current code:

functiongetCuisine(condition) {

  if (condition) {
    letcuisine = "Mediterranean";

    // other code

    returncuisine;
  }
  else {

    // cuisine does not exist here

    return null;
  }

  // cuisine does not exist here
}

Variables defined using const are considered to be constants, so the value cannot be changed once set. For this reason, every const variable has to be initialized:

// Valid constant
const ITEMS = 10;

// Syntax error: missing initialization
const ITEM;

We use iterators to allow customization of an object's iteration method/behavior, such as CLRIE numerable or Java Iterable. Generalize the for..in operator to custom iterator-based iteration with for..of. Iterators are an important feature of ECMAScript 6. When used in combination with new array methods and new types of collections (for example, sets and maps), iterators become even more important for the efficient processing of data.

Fibonacci numbers, or the Fibonacci arrangement, are the numbers in the accompanying whole number succession:

let fibonacci = {
  [Symbol.iterator]() {
    let x = 0, y = 1;
    return {
      next() {
        [x, y] = [y, x + y];
        return { done: false, value: y }
      }
    }
  }
}

for (vari of fibonacci) {
  // truncate the sequence at 3000
  if (i> 3000)
  break;
  console.log(i);
}

Custom iterators are a useful tool but it requires careful programming so that it can maintain its internal state explicitly. ES6 introduced generators which provide a powerful alternative. Generator allows us to create an iteration algorithm by writing a single function. This single function is able to maintain its own state.

A generator is a function that returns an iterator. The generator functions are denoted by embedding an asterisk (*) after the function keyword. A normal function becomes a generator if it contains a yield expression and uses function* syntax.

The yield keyword is utilized within the generators function to indicate the qualities that the iterator must return when the next() method is called. So, in the event that you need to return unique values for each progressive call to next():

We can convert the previous iterator example to use a generator, as shown here:

let fibonacci = {
  *[Symbol.iterator]() {
    let prex = 0, cury = 1
    for (;;) {
      [ prex, cury ] = [ cury, prex+curv ] = [
        yield cury
    }
  }
}

for (let ni of fibonacci) {
  if (ni> 3000)
  break
  console.log(ni)
}

ES6 supports Unicode, including new Unicode literal form in strings, new RegExp u mode to handle code points, as well as new APIs to process strings at the 21-bit code points level. These updates enable us to create global apps in JavaScript. ECMAScript 6 enforces encoding of strings in UTF.

The supported Unicode examples are as follows:

// same as ECMAScript 5
"▯".length == 2

// new RegExpbehaviour, opt-in 'u'
"▯".match(/./u)[0].length == 2

// new form
"u{1D306}"=="▯"=="uD834uDF06"

// new String ops
"▯".codePointAt(0) == 0x20BB7

// for-of iterates code points
for(var c of "▯") {
  console.log(c);
}

ECMAScript 6 enables us to export and import symbols to and from modules without polluting the global namespace. It provides added support for modules for component definition. Runtime behavior is defined by a host-defined default loader. It is an implicitly asynchronous model; no code is executed until the necessary modules are available and processed:

export function sum(x, y, {
  return x + y
}

console.log("4π = " + math.sum(math.pi, math.pi, math.pi, math.pi));

console.log("2π = " + sum(pi, pi));

Some additional features include export default and export *, as shown in the following code snippet:

exportvar e = 2.71828182846;

export default function(x) {
  returnMath.log(x);
}
console.log("2π = " + ln(e)*pi*2);

Module loaders are used primarily to resolve module specifiers, loading modules, and so on. They are responsible for downloading the required modules and binding them asynchronously. This brings to light the dependencies of a client script. The constructor is Reflect.Loader.

Module loaders support:

System.import('libraries/math').then(function(mx) {
  console.log("π = " + (mx.pi));
});

// Create execution sandboxes – new Loaders
var loader = new Loader({
  global: fixup(window)
});
loader.eval("console.log('live to code!');");

// Directly manipulate module cache
System.get('jquery');
System.set('jquery', Module({$: $}));

Collections are used to create unique values collections of any type in JavaScript. In a collection of values, you can also add and remove values. There is no direct access to values in collection, and these are of array type.

In ECMAscript 6, collections are a new efficient way to store data. JavaScript arrays are similar to other programming language arrays with index. By use of these arrays, you can pull double and triple data and also stack data. There are many new types of collections in JavaScript. Here are some examples:

Var students=new set();
Students.add(10);
Students.add("Ali");

varmyMap=newMap();
myMap.set("pine","apple");
myMap.set(1,"apple");

myMap.size;// 2
myMap.has("cone");// will return false

myMap.has("pine")// will return true

varmyMap=newMap();
myMap.set("pine","apple");

myMap.delete("apple");// Returns true. Successfully removed.
myMap.has("apple");// Returns false. The "apple" element is no longer present.

varmyMap=newMap();
myMap.set("0","pine");
myMap.set(1,"apple");
myMap.set({},"cone");

varmapIter=myMap.entries();

console.log(mapIter.next().value);// ["0", "pine"]
console.log(mapIter.next().value);// [1, "apple"]
console.log(mapIter.next().value);// [Object, "cone"]

functionlogMapElements(value, key, map) {
  console.log("m["+ key +"] = "+ value);
}
Map([["foo",3],["apple",{}],["cone", undefined]]).forEach(logMapElements);
// logs:
// "m[pine] = 3"
// "m[apple] = [object Object]"
// "m[cone] = undefined"

varmyMap=newMap();
myMap.set("apple","pine");

myMap.get("apple");// Returns "apple".
myMap.get("cone");// Returns undefined.

varmyMap=newMap();
myMap.set("apple","pine");

myMap.has("apple");// returns true
myMap.has("cone");// returns false

varmyMap=newMap();
myMap.set("0","pine");
myMap.set(1,"apple");
myMap.set({},"cone");

varmapIter=myMap.keys();

console.log(mapIter.next().value);// "0"
console.log(mapIter.next().value);// 1
console.log(mapIter.next().value);// Object

varmyMap=newMap();

// Add new elements to the map
myMap.set("apple","pine");
myMap.set(1,"pineapple");

// Update an element in the map
myMap.set("apple","custard");

varmyMap = new Map();

varkeyObj = {},
keyFunc = function () {},
keyString = "This is a sample string";

// setting the values
myMap.set(keyString, "value associated to 'This is a sample string'");
myMap.set(keyObj, "value associated to a keyObj");
myMap.set(keyFunc, "value associated to a keyFunc");

myMap.size; // 3

// getting the values
myMap.get(keyString);    // "value associated to 'This is a sample string'"
myMap.get(keyObj);       // "value associated to a keyObj"
myMap.get(keyFunc);      // "value associated to a keyFunc"

myMap.get("a string");   // "value associated to 'This is a sample string'"
// because keyString === 'a string'
myMap.get({});           // undefined, because keyObj !== {}
myMap.get(function() {}) // undefined, because keyFunc !== function () {}

varmyWeakMap1 = new WeakMap(),
myWeakMap2 = new WeakMap(),
varo1 = {},
o2 = function(){},
o3 = window;

myWeakMap1.set(o1, 37);
myWeakMap1.set(o2, "pineapple");
myWeakMap2.set(o1, o2); 
myWeakMap2.set(o3, undefined);
myWeakMap2.set(myWeakMap1, myWeakMap2);

myWeakMap1.get(o2); // "pineapple"
myWeakMap2.get(o2); // undefined, because there is no value for o2 on myWeakMap2
myWeakMap2.get(o3); // undefined, because that is the set value

myWeakMap1.has(o2); // will return true
myWeakMap2.has(o2); // will return false
myWeakMap2.has(o3); // will return true

myWeakMap1.has(o1); // will return true
myWeakMap1.delete(o1);
myWeakMap1.has(o1); // will return false

varwm = new WeakMap();
varobject = {};

wm.set(object, "pine");
wm.set(window, "apple");

wm.has(object); // will return true
wm.has(window); // will return true

wm.clear();

wm.has(object)  // will return false
wm.has(window)  // will return false

varwm = new WeakMap();
wm.set(window, "pineapple");

wm.delete(window); // Returns true. Successfully removed.

wm.has(window);    // Returns false. The window object is no longer in the WeakMap.

varwm = new WeakMap();
wm.set(window, "pine");

wm.get(window); // Returns "pine".
wm.get("apple");  // Returns undefined.

varwm = new WeakMap();
wm.set(window, "pine");

wm.has(window); // returns true
wm.has("apple");  // returns false

varwm = new WeakMap();
varobject = {};

// Add new elements to the WeakMap
wm.set(object, "pine").set(window, "apple"); // chainable

// Update an element in the WeakMap
wm.set(object, "cone");

varmyWeakSet=newWeakSet();

myWeakSet.add(window);// add the window object to the WeakSet created above

myWeakSet.has(window);// will return true

varmyWeakSet=newWeakSet();
varmyObject={};

myWeakSet.add(window);

myWeakSet.delete(myObject);// Will return false
myWeakSet.delete(window);// Will return true.

myWeakSet.has(window);// Will return false.

varws=newWeakSet();
varobject={};
ws.add(window);

mySet.has(window);  // will return true
mySet.has(object);  // will return false

// Sets
varmySet = new Set();
mySet.add("apple").add("candy");
mySet.size === 2;
mySet.has("hello") === false;

// Maps
varmyMap = new Map();
myMap.set("boy", 27);
myMap.set(f, 25);
myMap.get(f) == 25;

// Weak Maps
varmyWeakMap = new WeakMap();
myWeakMap.set(s, { extra: 99 });
myWeakMap.size === undefined

// Weak Sets
varmyWeakSet = new WeakSet();
myWeakSet.add({ data: 99 });

Proxies enable object creation with a wide range of behaviors available to host objects. They can be used for object virtualization, interception, logging/profiling, and so on. Proxies provide developers with an unprecedented control over objects and unlimited possibilities to define new interaction patterns.

Here is an example:

vartargetObject = {};
varhandlerObject = {
  get: function (receiver, book) {
    return `Title, ${name}!`;
  }
};

varproxyObject = new Proxy(target, handler);
proxyObject.world === 'Lahore!';

// Proxying a function object
vartargetObject = function () { return 'Target, I am'; };
varhandlerObject = {
  apply: function (receiver, ...args) {
    return 'Le proxy';
  }
};

var p = new Proxy(target, handler);
p() === 'Le proxy';

A symbol is a unique type which can be used as an identifier for object properties. The symbol object is an implicit object wrapper for the symbol primitive data type.

Here is how you can create a new primitive symbol:

var symb = Symbol(); 

OR

var symb = Symbol('abc');

The preceding code creates two new symbols. Symbol('abc') does not force converts abc into an object but creates a new separate object.

Symbol('abc') === Symbol('abc'); //false

Using Symbol() with new keyword will throw a type error.

var symb = new Symbol(); // TypeError

This prevents creation of an explicit Symbol wrapper object instead of a new symbol value. Creating an explicit wrapper object around primitive data types were only supported until ES5. However, existing primitive wrapper objects like new Boolean, new String and new Number can still be created for legacy reasons.

And if it is necessary to create Symbol wrapper object, you can use the Object() function:

var symb = Symbol("abc");
typeof symb;     // "symbol" 
var symbObj = Object(symb);
typeof symbObj;  // "object"

The Object.getOwnPropertySymbols() method returns an array of symbols and lets you find symbol properties on a given object.

Here is an example:

varSomeClass = (function() {

  var key = Symbol("key");

  functionSomeClass(privateData) {
    this[key] = privateData;
  }

  SomeClass.prototype = {
    doStuff: function() {
      ... this[key] ...
    }
  };

  returnSomeClass;
})();

var c = new SomeClass("bye")
c["key"] === undefined

In ECMAScript 6, built-ins such as Date, Array, and DOM elements can be subclassed. Object construction for a function named Ctor now uses two phases:

The known @@create symbol is available via Symbol.create. Built-ins now expose their @@create syntax explicitly.

Here is an example:

// Pseudo-code of Array
classSomeArray {
  constructor(...args) { /* ... */ }
  static [Symbol.create]() {

  }
}

// User code of Array subclass
classSomeArray extends Array {
  constructor(...args) { super(...args); }
}

// Two-phase 'new':
// 1) Call @@create to allocate object
// 2) Invoke constructor on new instance
vararr = new SomeArray();
arr[1] = 123;
arr.length == 1

ECMAScript 6 introduced promises. It is a library used for asynchronous programming. It is a first-class representation of a value that may be made available in the future. Many existing JavaScript libraries already use promises.

Some of the methods for promises in ES6 are mentioned here.

varprom1 = 6000;
varprom2 = new Promise(function(resolve, reject) {
  setTimeout(resolve, 100, "Here");
}); 

Promise.all([prom1, prom2]).then(function(values) {
  console.log(values); // [6000, "Here"]
});

varprom1= new Promise(function(resolve, reject) {
  resolve('This was Successful!!');
});

prom1.then(function(value) {
  console.log(value); // "This was Successful!!"
  throw 'oh, no!';
}).catch(function(e) {
  console.log(e); // "Error found"
}).then(function() {
  console.log('Catch Done!');
}, function () {
  console.log('Not fired due to the catch');
});

varprom1=newPromise(function(resolve, reject) {
  resolve("This was a Success!");
  // or
  // reject ("Error Found Try Again!");
});

prom1.then(function(value) {
  console.log(value);//This was a Success!
},function(reason){
  console.log(reason);// Error Found Try Again!
});

varp2=newPromise(function(resolve, reject) {
  resolve(1);
});

p2.then(function(value) {
  console.log(value);// 1
  return value +1;
}).then(function(value) {
  console.log(value);// 2
});

p2.then(function(value) {
  console.log(value);// 1
});

functionfetch_current_data() {
  returnfetch("current-data.json").then((response)=> {
    if(response.headers.get("content-type")!="application/json") {
      thrownewTypeError();
    }
    var j =response.json();
    // maybe do something with j
    return j;// fulfillment value given to user of
    // fetch_current_data().then()
  });
}

Promise.reject("Testing Promise reject").then(function(reason) {
  // not called
},function(reason) {
  console.log(reason);// "Testing Promise reject"
});

Promise.reject(newError("fail")).then(function(error) {
  // not called
},function(error) {
  console.log(error);// Stacktrace
});

varmyPromise1=newPromise(function(resolve, reject) {
  setTimeout(resolve,800,"first");
});
varmyPromise2=newPromise(function(resolve, reject) {
  setTimeout(resolve,300,"second");
});

Promise.race([myPromise1,myPromise2]).then(function(value) {
  console.log(value);// "second"
  // Both resolve, but myPromise2 is faster
});

ECMAScript 6 has made several new extensions to the prebuilt libraries, including core Math libraries, arrays, string helpers, and Object.assign for copying. These new methods help in speeding up the execution process, hence resulting in enhancing the performance of applications that may perform calculations and string manipulation. It also improves the speed of applications that must perform many calculations and string manipulations.

Numerous new library increases, including core Math libraries, array conversion helpers, string helpers, and Object.assign for copying. An example of using the Core Math Library APIs is as follows:

Number.EPSILON
Number.isInteger(Infinity) // will return false
Number.isNaN("NaN") // will return false

Math.acosh(3) // 1.762747174039086
Math.hypot(3, 4) // 5
Math.imul(Math.pow(2, 32) - 1, Math.pow(2, 32) - 2) // 2

"Neptune".includes("cd") // This will return false
"Mars".repeat(4) // This will be "MarsMarsMarsMars"

Array.from(document.querySelectorAll('*')) // Returns a real Array
Array.of(1, 2, 3) // Similar to new Array(...), but without special one-arg behavior
[0, 0, 0].fill(2, 1) // [0,2,2]
[24, 14, 23, 57, 89, 75, 33].find(x => x == 33) // 33
[24, 14, 23, 57, 89, 75, 33].findIndex(x => x == 14) // 1
[1, 2, 3, 4, 5].copyWithin(3, 0) // [1, 2, 3, 1, 2]
["x", "y", "z"].entries() // iterator [0, "x"], [1,"y"], [2,"z"]
["x", "y", "z"].keys() // iterator 0, 1, 2

ECMAScript 6 introduced binary and octal literal notations, for binary (b) and octal (o). Both these notations are a little similar to hexadecimal literal notation for prepending 0x or 0X to a value.

The new octal literal format begins with 0o or 0O, while the new binary literal format begins with 0b or 0B. Each literal type must be followed by one or more digits; 0-7 for octal and 0-1 for binary. Here's an example:

// ECMAScript 6
varvalue11 = 0o65;      // 53 in decimal
varvalue22 = 0b100;     // 4 in decimal

0b111110111 === 503 // will return true
0o767 === 503 // will return true

The reflect object is a single object that contains functions related to the reflection API. As the name suggests, it is merely a reflection of the objects so that one can observe them closely, regardless of who the object was created by. The reflect object is not a function object. It does not have a constructor method. It cannot be invoked as a function, because it does not have a call method.

Reflect API is known to be the inverse of Proxy API.

Here is a list of methods a reflect object has.

// Object
varobject={a:4,b:5};
Reflect.get(object,"b");// 5

// Array
Reflect.get(["first","second"],1);// "second", since array starts with 0 index

// Proxy with a get handler
var x ={p:9};
varobject=newProxy(x, {
  get(a,b,c){returnb +"meow";}
});
Reflect.get(object,"woof");// "woofbar"

// Object
varobject={};
Reflect.set(object,"property","value");// will return true
object.property;// "value"

// Array
vararr=["cow","cow","cow"];
Reflect.set(arr,1,"goat");// will return true
arr[1];// "goat"

// It can truncate an array.
Reflect.set(arr,"length",1);// will return true
arr;// ["goat"];

// With just one argument, propertyKey and value are "undefined".
varobject={};
Reflect.set(object);// will return true
Reflect.getOwnPropertyDescriptor(object,"undefined");
// { value: undefined, writable: true, enumerable: true, configurable: true }

Reflect.has({a:0},"a");// will return true
Reflect.has({a:0},"b");// will return false

// returns true for properties in the prototype chain
Reflect.has({a:0},"toString");

// Proxy with .has() handler method
object=newProxy({}, {
  has(s,d){returns.startsWith("cat");}
});
Reflect.has(object,"catastrophe");// will return true
Reflect.has(object,"camel");// will return false

Reflect.apply(Math.floor, undefined,[3.999]);
// 3;

Reflect.apply(String.fromCharCode, undefined,[80, 97, 107, 105, 115, 116, 97, 110]);
// "Pakistan"

Reflect.apply("".charAt,"stars",[2]);
// "a"

var d =Reflect.construct(Date,[2015,1,5]);
dinstanceofDate;// will return true
d.getFullYear();// 2015

functionmyConstructor(){}
var result =Reflect.construct(Array,[],myConstructor);

Reflect.getPrototypeOf(result);// myConstructor.prototype
Array.isArray(result);// will return true

Reflect.getOwnPropertyDescriptor({a:"bye"},"a");
// {value: "bye", writable: true, enumerable: true, configurable: true}

Reflect.getOwnPropertyDescriptor({x:"bye"},"y");
// undefined

Reflect.getOwnPropertyDescriptor([],"length");
// {value: 0, writable: true, enumerable: false, configurable: false}

Reflect.getOwnPropertyDescriptor("woof",0);
// TypeError: "woof" is not non-null object

Object.getOwnPropertyDescriptor("dummy",0);
// { value: "d", writable: false, enumerable: true, configurable: false }

http://haseeb.deeurl.com/client-demos/everydayadvice/v3/={};
Reflect.defineProperty(object,"x",{value:7});// will return true
object.x;// 7

if(Reflect.defineProperty(target, property, attributes)) {
  // will return success
}
else{
  // will return failure
}

Reflect.getPrototypeOf({});// Object.prototype
Reflect.getPrototypeOf(Object.prototype);// will return null
Reflect.getPrototypeOf(Object.create(null));// will return null

Reflect.setPrototypeOf({},Object.prototype);// will return true
Reflect.setPrototypeOf({},null);// will return true

Reflect.setPrototypeOf(Object.freeze({}),null);// will return false

var target ={};
varprototype=Object.create(target);
Reflect.setPrototypeOf(target,prototype);// will return false

varobject={a:11,b:12};
Reflect.deleteProperty(object,"a");// will return true
object;// { y: 12 }

vararr=[11,12,13,14,15];
Reflect.deleteProperty(arr,"3");// will return true
arr;// [11, 12, 13, , 15]

// Returns true if no such property exists
Reflect.deleteProperty({},"bar");// will return true

// Returns false if a property is unconfigurable
Reflect.deleteProperty(Object.freeze({bar:1}),"bar");// will return false

varobject={a:98,b:99};

for(var name ofReflect.enumerate(object)) {
  console.log(name);
}
// logs "a" and "b"

varblank={};
Reflect.isExtensible(blank);// === will return true

Reflect.preventExtensions(blank);
Reflect.isExtensible(blank);// === will return false

var blank ={};
Reflect.isExtensible(blank);

Reflect.ownKeys({a:5,b:6,c:7});
Reflect.ownKeys([]);

varsymbol=Symbol.for("dirt");
varsymbolb=Symbol.for("sky");
varobject={[symbol]:0,"string":0,"99":0,"4":0,
[symbolb]:0,"100":0,"-7":0,"second string":0};
Reflect.ownKeys(object);

Calls in tail position won't be able to grow the stack without any limits. It helps in making recursive algorithms safe and secure in the safe of unbounded inputs.

function factorial(n, acc) {
 'use strict';
 if (n <= 1) return acc;
 return factorial(n - 1, n * acc);
}
console.log(factorial(5, 1)); //120
console.log(factorial(200, 1)); //Infinity

// Stack overflow in most implementations today,
// but safe on arbitrary inputs in ES6
console.log(factorial(10000000, 1));