From ac7dabf61c4c08d65b35d52462558bddd4f5c95e Mon Sep 17 00:00:00 2001 From: Filipe Linhares Date: Tue, 13 May 2014 08:16:01 -0300 Subject: [PATCH 1/2] Corrigindo pequenos erros --- README.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 23b9f89..776f549 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ ES6 inclui as seguintes novas funcionalidades: ### Arrows -_Arrows_ são abreviações de func'ões usando a sintaxe `=>`. Elas são semelhantes semanticamente ao recurso equivalente do C#, Java 8 e do CoffeeScript. Elas supotam expressões ou conjuntos de instruções. Ao conrário de _function_, _arrows_ compartilham o mesmo `this` que o do código que o envolve. +_Arrows_ são abreviações de funções usando a sintaxe `=>`. Elas são semelhantes semanticamente ao recurso equivalente do C#, Java 8 e do CoffeeScript. Elas suportam expressões ou conjuntos de instruções. Ao contrário de _function_, _arrows_ compartilham o mesmo `this` que o do código que o envolve. ```JavaScript // Expressões @@ -103,7 +103,7 @@ var obj = { ``` ### Template Strings -Template strings tornam muito fácil gerar _strings_. Ë semelhante à interpolação de _strings_ do Perl, Python e outros. Opcionalmente podmeos adicionar uma _tag_ que permitem a construção de uma string personalizada, evitando ataques com inserção de código ou montando estruturas de dados a partir do conteúdo de _strings_. +Template strings tornam muito fácil gerar _strings_. Ë semelhante à interpolação de _strings_ do Perl, Python e outros. Opcionalmente podemos adicionar uma _tag_ que permitem a construção de uma string personalizada, evitando ataques com inserção de código ou montando estruturas de dados a partir do conteúdo de _strings_. ```JavaScript // Construção básica de uma string literal @@ -151,7 +151,7 @@ a === undefined; ``` ### Default + Rest + Spread -Valores padrão nas chamadas de funções. Transformação de um array em argumentos consegutivos em uma chamada de função, Vincular parametros sequenciais em um _array_. Substitui a necessidade de _arguments_ e casos mais comuns. +Valores padrão nas chamadas de funções. Transformação de um array em argumentos consegutivos em uma chamada de função, Vincular parametros sequenciais em um _array_. Substitui a necessidade de _arguments_ e casos mais comuns. ```JavaScript function f(x, y=12) { @@ -176,7 +176,7 @@ f(...[1,2,3]) == 6 ``` ### Let + Const -Blocos com escopo vinculado. `let` é o novo `var`. `const` é definido uam evz apenas. Restrições estáticas previnem o uso antes da declaração. +Blocos com escopo vinculado. `let` é o novo `var`. `const` é definido uma vez apenas. Restrições estáticas previnem o uso antes da declaração. ```JavaScript @@ -196,7 +196,7 @@ function f() { ``` ### Iterators + For..Of -Objetos Iterator permitem iterações como CLR IEnumerable ou Java Iteratable. Generalizar o `for..in` para uma iteração customizada com `for..of`. Não é necessário executar em um _array_, permitindo padrões mais flexíveis, como LINQ. +Objetos Iterator permitem iterações como CLR IEnumerable ou Java Iteratable. Generalizar o `for..in` para uma iteração customizada com `for..of`. Não é necessário executar em um _array_, permitindo padrões mais flexíveis, como LINQ. ```JavaScript let fibonacci = { @@ -235,7 +235,7 @@ interface Iterable { ``` ### Generators -_Generators_ simplificam a criação de iterações usando `function*` e `yield`. Uma func'ão declarada como _funcion*_ retorna uma instancia de um _Generator_. _Generators_ são subtipos de _iterators_ que incluem métodos adicionais, `next` e `throw`. Eles permitem que valores sejam retornados ao _generator_, então `yield` é uma forma de expressão que retorna um valor. +_Generators_ simplificam a criação de iterações usando `function*` e `yield`. Uma função declarada como _function*_ retorna uma instância de um _Generator_. _Generators_ são subtipos de _iterators_ que incluem métodos adicionais, `next` e `throw`. Eles permitem que valores sejam retornados ao _generator_, então `yield` é uma forma de expressão que retorna um valor. Nota: Também pode ser usados para permitir 'esperar' como em programação assíncrona, veja também a proposta do ES7, `await`. @@ -404,7 +404,7 @@ ws.add({ data: 42 }); ``` ### Proxies -_Proxies_ permitem a criação de objetos com todos os comportamentos disponíveis no opjeto que o contém, Podem ser usados para interceptação, virtualização de objetos, _logs_, _profiles_, etc. +_Proxies_ permitem a criação de objetos com todos os comportamentos disponíveis no objeto que o contém, Podem ser usados para interceptação, virtualização de objetos, _logs_, _profiles_, etc. ```JavaScript // Proxying a normal object @@ -433,7 +433,7 @@ var p = new Proxy(target, handler); p() === 'I am the proxy'; ``` -Existem métodos disponíveis para todas as meta-operaçoes em tempo de execução: +Existem métodos disponíveis para todas as meta-operações em tempo de execução: ```JavaScript var handler = @@ -487,7 +487,7 @@ Contrução de objetos para uma função chamada `Ctor` agora levam duas etapas - Chame `Ctor[@@create]` para alocar o objeto, instalando qualquer comportamento especial - Chame o construtor ou uma nova instancia para inicializar -O simbolo `@@create` estádisponível través de `Symbol.create`. Objetos nativos agora expôem seus métodos `@@create` explicitamente.. +O simbolo `@@create` está disponível través de `Symbol.create`. Objetos nativos agora expôem seus métodos `@@create` explicitamente.. ```JavaScript // Pseudo-código de Array @@ -539,7 +539,7 @@ Object.assign(Point, { origin: new Point(0,0) }) ``` ### Binary and Octal Literals -Duas novas formas de numeros literais foram adicionadas, para binários (`b`) e octais (`o`). +Duas novas formas de números literais foram adicionadas, para binários (`b`) e octais (`o`). ```JavaScript 0b111110111 === 503 // true From 8ff33499e23fb55e79f9a429b5db951c2ff47a4d Mon Sep 17 00:00:00 2001 From: Filipe Linhares Date: Tue, 13 May 2014 08:17:48 -0300 Subject: [PATCH 2/2] Deletando README-pt-br.md --- README-pt-br.md | 661 ------------------------------------------------ 1 file changed, 661 deletions(-) delete mode 100644 README-pt-br.md diff --git a/README-pt-br.md b/README-pt-br.md deleted file mode 100644 index ce06b94..0000000 --- a/README-pt-br.md +++ /dev/null @@ -1,661 +0,0 @@ -# ECMAScript 6 [git.io/es6features](http://git.io/es6features) - -## Introduction -ECMAScript 6 is the upcoming version of the ECMAScript standard. This standard is targeting ratification in December 2014. ES6 is a significant update to the language, and the first update to the language since ES5 was standardized in 2009. Implementation of these features in major JavaScript engines is [underway now](http://kangax.github.io/es5-compat-table/es6/). - -ECMAScript 6 é a próxima versão do padrão ECMAScript. A norma deverá ser ratificada em Dezembro de 2014. ES6 é um upgrade significativo na linguagem, e a primeira atualização desde que foi padronizada em 2009. A Veja a implementação dessas funcionalidades noas principais engines de javascript no link [Tabela de Compatibilidade do ECMAScript 6](http://kangax.github.io/es5-compat-table/es6/). - -See the [draft ES6 standard](https://people.mozilla.org/~jorendorff/es6-draft.html) for full specification of the ECMAScript 6 language. - -Veja o [proposta de padrão ES6] (https://people.mozilla.org/ ~ jorendorff/es6-draft.html) para a especificação completa da linguagem ECMAScript 6. - -ES6 includes the following new features: -ES inclui as seguintes novas funcionalidades: -- [arrows](#arrows) -- [classes](#classes) -- [enhanced object literals](#enhanced-object-literals) -- [template strings](#template-strings) -- [destructuring](#destructuring) -- [default + rest + spread](#default--rest--spread) -- [let + const](#let--const) -- [iterators + for..of](#iterators--forof) -- [generators](#generators) -- [comprehensions](#comprehensions) -- [unicode](#unicode) -- [modules](#modules) -- [module loaders](#module-loaders) -- [map + set + weakmap + weakset](#map--set--weakmap--weakset) -- [proxies](#proxies) -- [symbols](#symbols) -- [subclassable built-ins](#subclassable-built-ins) -- [promises](#promises) -- [math + number + string + object APIs](#math--number--string--object-apis) -- [binary and octal literals](#binary-and-octal-literals) -- [reflect api](#reflect-api) -- [tail calls](#tail-calls) - -## ECMAScript 6 Features -## Funcionalidades ECMAScript 6 - -### Arrows -Arrows are a function shorthand using the `=>` syntax. They are syntactically similar to the related feature in C#, Java 8 and CoffeeScript. They support both expression and statement bodies. Unlike functions, arrows share the same lexical `this` as their surrounding code. - -_Arrows_ são abreviações de func'ões usando a sintaxe `=>`. Elas são semelhantes semanticamente ao recurso equivalente do C#, Java 8 e do CoffeeScript. Elas supotam expressões ou conjuntos de instruções. Ao conrário de _function_, _arrows_ compartilham o mesmo `this` que o do código que o envolve. - -```JavaScript -// Expression bodies -var odds = evens.map(v => v + 1); -var nums = evens.map((v, i) => v + i); -// Expressões -var oares = evens.map(v => v + 1); -var numeros = evens.map((v, i) => v + i); - -// Statement bodies -// Conjuntos de instruções -numeros.forEach(v => { - if (v % 5 === 0) - listaCincos.push(v); -}); - -// Lexical this -var bob = { - _name: "Bob", - _friends: [], - printFriends() { - this._friends.forEach(f => - console.log(this._name + " knows " + f)); - } -} -// "this" léxico -var joao = { - _nome: "João", - _amigos: [], - listaAmigos() { - this._amigos.forEach(f => - console.log( this._nome + " conhece " + f) ); - } -} -``` - -### Classes - -ES6 classes are a simple sugar over the prototype-based OO pattern. Having a single convenient declarative form makes class patterns easier to use, and encourages interoperability. Classes support prototype-based inheritance, super calls, instance and static methods and constructors. - -Classes ES6 são o padrão _prototype_ melhorado. Ter uma única e conveniente forma declarativa fazem os padrões de classes mais fáceis de usar e icentivam a interoperabilidade. Classes suportam herança no modelo _ prototype, _super calls_, instanciamento, métodos estáticos e construtores. - -```JavaScript -class SkinnedMesh extends THREE.Mesh { - constructor(geometry, materials) { - super(geometry, materials); - - this.idMatrix = SkinnedMesh.defaultMatrix(); - this.bones = []; - this.boneMatrices = []; - //... - } - update(camera) { - //... - super.update(); - } - static defaultMatrix() { - return new THREE.Matrix4(); - } -} -``` - -### Enhanced Object Literals -### Object Literals aprimorados - -Object literals are extended to support setting the prototype at construction, shorthand for `foo: foo` assignments, defining methods and making super calls. Together, these also bring object literals and class declarations closer together, and let object-based design benefit from some of the same conveniences. - -_Object literals_ foram extendidos para facilitar definir o _prototype_ construção, uma abreviação para definições `foo: foo` , definir métodos e fazer _super calls_. Juntos, eles também trazem literais de objeto e declarações de classe mais próximos, e deixam benefício design baseado em objeto de algumas das mesmas conveniências. - -```JavaScript -var obj = { - // __proto__ - __proto__: theProtoObj, - // Shorthand for ‘handler: handler’ - handler, - // Methods - toString() { - // Super calls - return "d " + super.toString(); - }, - // Computed (dynamic) property names - [ 'prop_' + (() => 42)() ]: 42 -}; -``` - -### Template Strings -Template strings provide syntactic sugar for constructing strings. This is similar to string interpolation features in Perl, Python and more. Optionally, a tag can be added to allow the string construction to be customized, avoiding injection attacks or constructing higher level data structures from string contents. -Template strings tornam muito fácil gerar _strings_. Ë semelhante à interpolação de _strings_ do Perl, Python e outros. Opcionalmente podmeos adicionar uma _tag_ que permitem a construção de uma string personalizada, evitando ataques com inserção de código ou montando estruturas de dados a partir do conteúdo de _strings_. - -```JavaScript -// Basic literal string creation -`In JavaScript '\n' is a line-feed.` -// Construção básica de uma string literal -`Em javascript '\n' é uam quebra de linha.` - -// Multiline strings -`In JavaScript this is - not legal.` -// Strings multilinha -`Isto não funciona - em Javascript.` - -// Construct a DOM query -var name = "Bob", time = "today"; -`Hello ${name}, how are you ${time}?` -// Contruindo uma query ao DOM -`Olá ${nome}, como está o ${nome_amigo}?` - -// Montar um prefixo de requisição HTTP para interpretar as substituições e construção -// Construct an HTTP request prefix is used to interpret the replacements and construction -GET`http://foo.org/bar?a=${a}&b=${b} - Content-Type: application/json - X-Credentials: ${credentials} - { "foo": ${foo}, - "bar": ${bar}}`(myOnReadyStateChangeHandler); -``` - -### Destructuring -Destructuring allows binding using pattern matching, with support for matching arrays and objects. Destructuring is fail-soft, similar to standard object lookup `foo["bar"]`, producing `undefined` values when not found. -Destructuring permite vincular usando padrões de expressões regulares, com suporte à _arrays_ e _objects_. Destructuring é _fail-soft_, semelhante à busca padrão em objetos `foo["bar"]`, retornando o valor `undefined` quando não encontra. - -```JavaScript -// list matching -var [a, , b] = [1,2,3]; - -// object matching -var { op: a, lhs: { op: b }, rhs: c } - = getASTNode() - -// object matching shorthand -// binds `op`, `lhs` and `rhs` in scope -var {op, lhs, rhs} = getASTNode() - -// Can be used in parameter position -function g({name: x}) { - console.log(x); -} -g({name: 5}) - -// Fail-soft destructuring -var [a] = []; -a === undefined; -``` - -### Default + Rest + Spread -Callee-evaluated default parameter values. Turn an array into consecutive arguments in a function call. Bind trailing parameters to an array. Rest replaces the need for `arguments` and addresses common cases more directly. -Valores padrão nas chamadas de funções. Transformação de um array em argumentos consegutivos em uma chamada de função, Vincular parametros sequenciais em um _array_. Substitui a necessidade de _arguments_ e casos mais comuns. - -```JavaScript -function f(x, y=12) { - // y is 12 if not passed (or passed as undefined) - // y vale 12 se não for passado (ou passado como undefined) - return x + y; -} -f(3) == 15 -``` -```JavaScript -function f(x, ...y) { - // y é um Array - return x * y.length; -} -f(3, "hello", true) == 6 -``` -```JavaScript -function f(x, y, z) { - return x + y + z; -} -// Passa cada emelento do array como um argumentoargument -f(...[1,2,3]) == 6 -``` - -### Let + Const -Block-scoped binding constructs. `let` is the new `var`. `const` is single-assignment. Static restrictions prevent use before assignment. -Blocos com escopo vinculado. `let` é o novo `var`. `const` é definido uam evz apenas. Restrições estáticas previnem o uso antes da declaração. - - -```JavaScript -function f() { - { - let x; - { - // okay, block scoped name - // funciona, nome com escopo definido no bloco - const x = "sneaky"; - // error, const - x = "foo"; - } - // error, already declared in block - // erro, já definido no bloco - let x = "inner"; - } -} -``` - -### Iterators + For..Of -Iterator objects enable custom iteration like CLR IEnumerable or Java Iteratable. Generalize `for..in` to custom iterator-based iteration with `for..of`. Don’t require realizing an array, enabling lazy design patterns like LINQ. -Objetos Iterator permitem iterações como CLR IEnumerable ou Java Iteratable. Generalizar o `for..in` para uma iteração customizada com `for..of`. Não é necessário executar em um _array_, permitindo padrões mais flexíveis, como LINQ. - -```JavaScript -let fibonacci = { - [Symbol.iterator]() { - let pre = 0, cur = 1; - return { - next() { - [pre, cur] = [cur, pre + cur]; - return { done: false, value: cur } - } - } - } -} - -for (var n of fibonacci) { - // truncate the sequence at 1000 - // para a sequencia em 1000 - if (n > 1000) - break; - print(n); -} -``` - -Iteration is based on these duck-typed interfaces (using [TypeScript](http://typescriptlang.org) type syntax for exposition only): -A sintaxe de _Iteration_ é baseada nas interfaces (usando sintaxe do[TypeScript] (http://typescriptlang.org) para demonstração apenas): -```TypeScript -interface IteratorResult { - done: boolean; - value: any; -} -interface Iterator { - next(): IteratorResult; -} -interface Iterable { - [Symbol.iterator](): Iterator -} -``` - -### Generators -Generators simplify iterator-authoring using `function*` and `yield`. A function declared as function* returns a Generator instance. Generators are subtypes of iterators which include additional `next` and `throw`. These enable values to flow back into the generator, so `yield` is an expression form which returns a value (or throws). -_Generators_ simplificam a criação de iterações usando `function*` e `yield`. Uma func'ão declarada como _funcion*_ retorna uma instancia de um _Generator_. _Generators_ são subtipos de _iterators_ que incluem métodos adicionais, `next` e `throw`. Eles permitem que valores sejam retornados ao _generator_, então `yield` é uma forma de expressão que retorna um valor. - -Note: Can also be used to enable ‘await’-like async programming, see also ES7 `await` proposal. -Nota: Também pode ser usados para permitir 'esperar' como em programação assíncrona, veja também a proposta do ES7, `await`. - -```JavaScript -var fibonacci = { - [Symbol.iterator]: function*() { - var pre = 0, cur = 1; - for (;;) { - var temp = pre; - pre = cur; - cur += temp; - yield cur; - } - } -} - -for (var n of fibonacci) { - // truncate the sequence at 1000 - if (n > 1000) - break; - print(n); -} -``` - -The generator interface is (using [TypeScript](http://typescriptlang.org) type syntax for exposition only): -A interface do generator é (usando a sintaxe do [TypeScript](http://typescriptlang.org) para demonstração apenas): - -```TypeScript -interface Generator extends Iterator { - next(value?: any): IteratorResult; - throw(exception: any); -} -``` - -### Comprehensions -Array and generator comprehensions provide simple declarative list processing similar as used in many functional programming patterns. -_Comprehensions_ de arrays e _generator_ fornecem um processamento declarativo simples, semelhante ao usado em muitos padrões de programação funcional. - -```JavaScript -// Array comprehensions -var results = [ - for(c of customers) - if (c.city == "Seattle") - { name: c.name, age: c.age } -] - -// Generator comprehensions -var results = ( - for(c of customers) - if (c.city == "Seattle") - { name: c.name, age: c.age } -) -``` - -### Unicode -Non-breaking additions to support full Unicode, including new unicode literal form in strings and new RegExp `u` mode to handle code points, as well as new APIs to process strings at the 21bit code points level. These additions support building global apps in JavaScript. -Adições retroativas para suporte completo a Unicode, incluindo a nova forma literal do unicode em strings e o novo modo do RegExp `u`, para lidar com pontos no código, assim como novas APIs para processar _strings_ em códigos 21bit. Essas adições auxiliam a contrução de _apps_ globais em Javascript. - -```JavaScript -// same as ES5.1 -// o mesmo que no ES5.1 -"𠮷".length == 2 - -// new RegExp behaviour, opt-in ‘u’ -// novo comportamento RegExp, opcionalopt-in ‘u’ -"𠮷".match(/./u)[0].length == 2 - -// new form -// nova sintaxe -"\u{20BB7}"=="𠮷"=="\uD842\uDFB7" - -// new String ops -// nova opção para string -"𠮷".codePointAt(0) == 0x20BB7 - -// for-of iterates code points -// for-of itera em pontos de código -for(var c of "𠮷") { - console.log(c); -} -``` - -### Modules -Language-level support for modules for component definition. Codifies patterns from popular JavaScript module loaders (AMD, CommonJS). Runtime behaviour defined by a host-defined default loader. Implicitly async model – no code executes until requested modules are available and processed. -Suporte nativo para módulos e definição de componentes. Códifica padrões de carregamento de módulo populares (AMD, CommonJS). Comportamento de carregamento em tempo de execução definido por um padrão no _host_. Modelos implícitos assíncronos , nenhum código é executado até que os módulos requisitados estejam disponíveis e processados. - -```JavaScript -// lib/math.js -export function sum(x, y) { - return x + y; -} -export var pi = 3.141593; -``` -```JavaScript -// app.js -module math from "lib/math"; -alert("2π = " + math.sum(math.pi, math.pi)); -``` -```JavaScript -// otherApp.js -import {sum, pi} from "lib/math"; -alert("2π = " + sum(pi, pi)); -``` - -Some additional features include `export default` and `export *`: -Algumas funcionalidades adicionais incluem `export default` e `export *`: - -```JavaScript -// lib/mathplusplus.js -export * from "lib/math"; -export var e = 2.71828182846; -export default function(x) { - return Math.exp(x); -} -``` -```JavaScript -// app.js -module math from "lib/mathplusplus"; -import exp from "lib/mathplusplus"; -alert("2π = " + exp(math.pi, math.e)); -``` - -### Module Loaders -Module loaders support: -- Dynamic loading -- State isolation -- Global namespace isolation -- Compilation hooks -- Nested virtualization -_Module loaders_ suportam: -- carregamento dinâmico -- isolamento de estado -- isolamento de _namespace_ global -- _hooks_ de compilação -- virtualização aninhada - -The default module loader can be configured, and new loaders can be constructed to evaluated and load code in isolated or constrained contexts. -O _module loader_ padrão pode ser configurado e novos _loaders_ podem ser contruídos para avaliar e carregar código em contexto isolado ou restrito - -```JavaScript -// Dynamic loading – ‘System’ is default loader -// Carregamento dinamico – ‘System’ é o loader padrão -System.import('lib/math').then(function(m) { - alert("2π = " + m.sum(m.pi, m.pi)); -}); - -// Create execution sandboxes – new Loaders -// Cria sandboxes de execução – novos Loaders -var loader = new Loader({ - global: fixup(window) // replace ‘console.log’ -}); -loader.eval("console.log('hello world!');"); - -// Directly manipulate module cache -// Manipulação do módulo cache -System.get('jquery'); -System.set('jquery', Module({$: $})); // WARNING: not yet finalized -System.set('jquery', Module({$: $})); // WARNING: não finalizado ainda -``` - -### Map + Set + WeakMap + WeakSet -Efficient data structures for common algorithms. WeakMaps provides leak-free object-key’d side tables. -Estruturas de dados eficientes para algorítimos comuns. _WeakMaps_ fornecem um mapa seguro de - -```JavaScript -// Sets -var s = new Set(); -s.add("hello").add("goodbye").add("hello"); -s.size === 2; -s.has("hello") === true; - -// Maps -var m = new Map(); -m.set("hello", 42); -m.set(s, 34); -m.get(s) == 34; - -// Weak Maps -var wm = new WeakMap(); -wm.set(s, { extra: 42 }); -wm.size === undefined - -// Weak Sets -var ws = new WeakSet(); -ws.add({ data: 42 }); -// Because the added object has no other references, it will not be held in the set -``` - -### Proxies -Proxies enable creation of objects with the full range of behaviors available to host objects. Can be used for interception, object virtualization, logging/profiling, etc. -_Proxies_ permitem a criação de objetos com todos os comportamentos disponíveis no opjeto que o contém, Podem ser usados para interceptação, virtualização de objetos, _logs_, _profiles_, etc. - -```JavaScript -// Proxying a normal object -// Proxy em um objeto normal -var target = {}; -var handler = { - get: function (receiver, name) { - return `Hello, ${name}!`; - } -}; - -var p = new Proxy(target, handler); -p.world === 'Hello, world!'; -``` - -```JavaScript -// Proxying a function object -// Proxy em um objeto função -var target = function () { return 'I am the target'; }; -var handler = { - apply: function (receiver, ...args) { - return 'I am the proxy'; - } -}; - -var p = new Proxy(target, handler); -p() === 'I am the proxy'; -``` - -There are traps available for all of the runtime-level meta-operations: -Existem métodos disponíveis para todas as meta-operaçoes em tempo de execução: - -```JavaScript -var handler = -{ - get:..., - set:..., - has:..., - deleteProperty:..., - apply:..., - construct:..., - getOwnPropertyDescriptor:..., - defineProperty:..., - getPrototypeOf:..., - setPrototypeOf:..., - enumerate:..., - ownKeys:..., - preventExtensions:..., - isExtensible:... -} -``` - -### Symbols -Symbols enable access control for object state. Symbols allow properties to be keyed by either `string` (as in ES5) or `symbol`. Symbols are a new primitive type. Optional `name` parameter used in debugging - but is not part of identity. Symbols are unique (like gensym), but not private since they are exposed via reflection features like `Object.getOwnPropertySymbols`. -_Symbols_ permitem controle sobre o estado do objeto. _Symbols_ permitem que propriedades sejam indexadas tanto por _string_ (como no ES5) como _symbol_. _Symbols_ são um novo tipo primitivo. Parâmetro opcional, `name` , usado em _debug_, mas não é parte da identidade. _Symbols_ são únicos (como gensym), mas não são privados já que são expostos em funcionalidades como`Object.getOwnPropertySymbols`. - -```JavaScript -(function() { - - // module scoped symbol - // symbol no escopo do módulo - var key = Symbol("key"); - - function MyClass(privateData) { - this[key] = privateData; - } - - MyClass.prototype = { - doStuff: function() { - ... this[key] ... - } - }; - -})(); - -var c = new MyClass("hello") -c["key"] === undefined -``` - -### Subclassable Built-ins -In ES6, built-ins like `Array`, `Date` and DOM `Element`s can be subclassed. -No ES6, objetos nativos como `Array`, `Date` e DOM `Element`s podem ter subclasses. - -Object construction for a function named `Ctor` now uses two-phases (both virtually dispatched): -Contrução de objetos para uma função chamada `Ctor` agora levam duas etapas (ambas disparadas virtualmente): -- Call `Ctor[@@create]` to allocate the object, installing any special behavior -- Chame `Ctor[@@create]` para alocar o objeto, installing any special behavior -- Invoke constructor on new instance to initialize - -The known `@@create` symbol is available via `Symbol.create`. Built-ins now expose their `@@create` explicitly. - -```JavaScript -// Pseudo-code of Array -class Array { - constructor(...args) { /* ... */ } - static [Symbol.create]() { - // Install special [[DefineOwnProperty]] - // to magically update 'length' - } -} - -// User code of Array subclass -class MyArray extends Array { - constructor(...args) { super(...args); } -} - -// Two-phase 'new': -// 1) Call @@create to allocate object -// 2) Invoke constructor on new instance -var arr = new MyArray(); -arr[1] = 12; -arr.length == 2 -``` - -### Math + Number + String + Object APIs -Many new library additions, including core Math libraries, Array conversion helpers, and Object.assign for copying. - -```JavaScript -Number.EPSILON -Number.isInteger(Infinity) // false -Number.isNaN("NaN") // false - -Math.acosh(3) // 1.762747174039086 -Math.hypot(3, 4) // 5 -Math.imul(Math.pow(2, 32) - 1, Math.pow(2, 32) - 2) // 2 - -"abcde".contains("cd") // true -"abc".repeat(3) // "abcabcabc" - -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(7, 1) // [0,7,7] -[1,2,3].findIndex(x => x == 2) // 1 -["a", "b", "c"].entries() // iterator [0, "a"], [1,"b"], [2,"c"] -["a", "b", "c"].keys() // iterator 0, 1, 2 -["a", "b", "c"].values() // iterator "a", "b", "c" - -Object.assign(Point, { origin: new Point(0,0) }) -``` - -### Binary and Octal Literals -Two new numeric literal forms are addded for binary (`b`) and octal (`o`). - -```JavaScript -0b111110111 === 503 // true -0o767 === 503 // true -``` - -### Promises -Promises are a library for asynchronous programming. Promises are a first class representation of a value that may be made available in the future. Promises are used in many existing JavaScript libraries. - -```JavaScript -function timeout(duration = 0) { - return new Promise((resolve, reject) => { - setTimeout(resolve, duration); - }) -} - -var p = timeout(1000).then(() => { - return timeout(2000); -}).then(() => { - throw new Error("hmm"); -}).catch(err => { - return Promise.all([timeout(100), timeout(200)]); -}) -``` - -### Reflect API -Full reflection API exposing the runtime-level meta-operations on objects. This is effectively the inverse of the Proxy API, and allows making calls corresponding to the same meta-operations as the proxy traps. Especially useful for implementing proxies. - -```JavaScript -// No sample yet -``` - -### Tail Calls -Calls in tail-position are guaranteed to not grow the stack unboundedly. Makes recursive algorithms safe in the face of unbounded inputs. - -```JavaScript -function factorial(n, acc = 1) { - 'use strict'; - if (n <= 1) return acc; - return factorial(n - 1, n * acc); -} - -// Stack overflow in most implementations today, -// but safe on arbitrary inputs in eS6 -factorial(100000) -```