Madame Lelica

Introduction

ECMAScript 6, Ook bekend als ECMAScript 2015, is de nieuwste versie van de ECMAScript-standaard. ES6 is een belangrijke update van de taal, en de eerste update van de taal sinds ES5 werd gestandaardiseerd in 2009. De implementatie van deze functies in de belangrijkste JavaScript-engines is nu aan de gang.

zie de ES6-standaard voor de volledige specificatie van de ECMAScript 6-taal.,

ES6 bevat de volgende nieuwe functies:

• pijlen
• klassen
• verbeterde objectletters
• template strings
• destructuring
• default + rest + spread
• let + const
• iterators + for..,van
• generatoren
• unicode
• modules
• module loaders)
• kaart + set + weakmap + weakset
• proxy ‘ s
• symbolen
• subclassable ingebouwde-ins
• beloften
• wiskunde + aantal + string + array + object Api ‘ s
• binaire en octaal letters
• spiegelen api
• staart oproepen

ECMAScript 6 Functies

Pijltjes

Pijlen zijn een functie van sneltoetsen met behulp van de => syntaxis. Ze zijn syntactisch vergelijkbaar met de gerelateerde functie in C#, Java 8 en CoffeeScript., Ze ondersteunen zowel statement block bodies als expression bodies die de waarde van de expressie retourneren. In tegenstelling tot functies delen pijlen dezelfde lexicale this als hun omringende code.

Meer info: MDN Arrow-functies

klassen

ES6-klassen zijn een eenvoudige suiker ten opzichte van het op prototype gebaseerde OO-patroon. Het hebben van een enkele handige declaratieve vorm maakt klassepatronen gemakkelijker te gebruiken en bevordert interoperabiliteit. Klassen ondersteunen prototype-gebaseerde erfenis, super calls, instantie en statische methoden en constructeurs.,

Meer info: MDN-klassen

Enhanced Object Literals

Object literals worden uitgebreid om het prototype bij de bouw te ondersteunen, steno voor foo: foo toewijzingen, het definiëren van methoden, het maken van super calls, en het berekenen van eigenschappennamen met expressies. Samen brengen deze ook object-literals en klassenverklaringen dichter bij elkaar, en laten object-based design profiteren van een aantal van dezelfde gemakken.,

Meer info: MDN grammatica en types: Object literals

Template Strings

Template strings bieden syntactische suiker voor het construeren van strings. Dit is vergelijkbaar met string interpolatie functies in Perl, Python en meer. Optioneel kan een tag worden toegevoegd om de stringconstructie aan te passen, het vermijden van injectieaanvallen of het construeren van gegevensstructuren op een hoger niveau van de stringinhoud.

Meer info: MDN Template Strings

Destructuring

Destructuring maakt binding mogelijk met behulp van patroonfiltering, met ondersteuning voor overeenkomende arrays en objecten., Vernietiging is fail-soft, vergelijkbaar met standaard object lookup foo, produceert undefined waarden wanneer deze niet worden gevonden.

Meer info: MDN-Destructietoewijzing

standaard + Rest + Spread

Callee-geëvalueerde standaardparameterwaarden. Verander een array in opeenvolgende argumenten in een functie aanroep. Bind de achterliggende parameters aan een array. Rest vervangt de behoefte aan arguments en behandelt veelvoorkomende gevallen directer.,

function f(x, y=12) { // y is 12 if not passed (or passed as undefined) return x + y;}f(3) == 15

function f(x, ...y) { // y is an Array return x * y.length;}f(3, "hello", true) == 6

function f(x, y, z) { return x + y + z;}// Pass each elem of array as argumentf(...) == 6

More MDN info: Default parameters, Rest parameters, Spread Operator

Let + Const

Block-scoped binding constructs. let is the new var. const is single-assignment. Static restrictions prevent use before assignment.

function f() { { let x; { // okay, block scoped name const x = "sneaky"; // error, const x = "foo"; } // error, already declared in block let x = "inner"; }}

More MDN info: let statement, const statement

Iterators + For..,Van

Iteratorobjecten maken aangepaste iteratie mogelijk, zoals CLR IEnumerable of Java Iterable. Generaliseer for..in naar aangepaste iterator-gebaseerde iteratie met for..of. Niet vereisen het realiseren van een array, waardoor luie design patronen zoals LINQ.

iteratie is gebaseerd op deze duck-type interfaces (met behulp van TypeScript type syntaxis alleen voor expositie):

Meer info: MDN voor…van

generatoren

generatoren vereenvoudigen iterator-authoring met function* en yield., Een functie gedeclareerd als functie * geeft een generator instantie terug. Generatoren zijn subtypes van iteratoren die extra next en throwbevatten. Hiermee kunnen waarden terugvloeien naar de generator, dus yield is een expressievorm die een waarde retourneert (of gooit).

opmerking: kan ook worden gebruikt om ‘wait’-achtige Async-programmering in te schakelen, zie ook ES7 await voorstel.,

De generator interface is (met behulp van TypeScript type syntaxis alleen voor expositie):

interface Generator extends Iterator { next(value?: any): IteratorResult; throw(exception: any);}

een extra voorzieningen zijn onder export default en export *:

// lib/mathplusplus.jsexport * from "lib/math";export var e = 2.71828182846;export default function(x) { return Math.log(x);}

// app.jsimport ln, {pi, e} from "lib/mathplusplus";alert("2π = " + ln(e)*pi*2);

Meer MDN info: instructie import, instructie exporteren

Module Loaders)

Module laders ondersteuning:

• Dynamisch laden
• Staat isolement
• Global namespace isolatie
• Compilatie haken
• Geneste virtualisatie

De standaard module loader kan worden geconfigureerd, en nieuwe laders kan worden gebouwd om te evalueren en de belasting code in geïsoleerde of beperkt contexten.,

Map + Set + WeakMap + WeakSet

efficiënte datastructuren voor gemeenschappelijke algoritmen. WeakMaps biedt lekvrije object-key ‘ d bijzettafels.

meer MDN-informatie: Map, Set, WeakMap, WeakSet

proxy ‘s

proxy’ s maken het mogelijk om objecten te maken met het volledige scala aan gedrag dat beschikbaar is om objecten te hosten. Kan worden gebruikt voor onderschepping, object virtualisatie, logging / profiling, enz.

Er zijn traps beschikbaar voor alle meta-bewerkingen op runtime-niveau:

Meer info: MDN-Proxy

symbolen

symbolen maken toegangscontrole voor de objectstatus mogelijk., Symbolen staan toe dat eigenschappen worden ingetoetst met string (zoals in ES5) of symbol. Symbolen zijn een nieuw primitief type. Optioneel description parameter gebruikt in debugging – maar maakt geen deel uit van identiteit. Symbolen zijn uniek (zoals gensym), maar niet privé omdat ze worden weergegeven via reflectiefuncties zoals Object.getOwnPropertySymbols.

Meer info: MDN-symbool

Subclassable Built-ins

in ES6 kunnen ingebouwde opties als Array, Date en DOM Elements worden gesubclasseerd.,

Objectconstructie voor een functie genaamd Ctor gebruikt nu twee-fasen (beide vrijwel verzonden):

• aanroep Ctor om het object toe te wijzen, elk speciaal gedrag installeren
• roep constructor op nieuwe instantie aan om

de bekende @@create symbool is beschikbaar via Symbol.create. Ingebouwde instellingen tonen nu hun @@create expliciet.,

Math + Number + String + Array + Object API ‘ s

veel nieuwe bibliotheek toevoegingen, waaronder core wiskunde bibliotheken, Array conversie helpers, string helpers, en Object.toewijzen voor kopiëren.

meer MDN info: Number, Math, Array.Uit, Array.van, Array.prototype.copyWithin, Object.toewijzen

binaire en octale Literalen

twee nieuwe numerieke letterlijke vormen worden toegevoegd voor binair (b) en octaal (o).

0b111110111 === 503 // true0o767 === 503 // true

Promises

Promises zijn een bibliotheek voor asynchrone programmering., Beloften zijn een eersteklas representatie van een waarde die in de toekomst beschikbaar kan worden gesteld. Beloften worden gebruikt in veel bestaande JavaScript-bibliotheken.

Meer info: MDN Promise

Reflect API

volledige reflectie API die de meta-bewerkingen op runtime-niveau op objecten blootlegt. Dit is effectief de inverse van de Proxy API, en maakt het mogelijk om gesprekken die overeenkomen met dezelfde meta-operaties als de proxy traps. Vooral handig voor het implementeren van volmachten.,

// No sample yet

Meer info: MDN Reflect

Tail Calls

Calls in tail-positie zijn gegarandeerd dat de stack niet ongebonden groeit. Maakt recursieve algoritmen veilig in het gezicht van onbegrensde ingangen.