HTML: Markup language
CSS: Styling language
JavaScript: Scripting language
Web APIs: Programming interfaces
All web technology
Learn web development
Discover our tools
Get to know MDN better
Esta página foi traduzida do inglês pela comunidade. Saiba mais e junte-se à comunidade MDN Web Docs.
View in English Always switch to English
Começando com ECMAScript 6, o JavaScript ganha suporte para os objetos Proxy e Reflect, permitindo você interceptar e definir o comportamento personalizado para operações fundamentais da linguagem (por exemplo, pesquisa de propriedade, atribuição, enumeração, invocação de função, etc). Com a ajuda destes dois objetos você será capaz de programar a nível meta em JavaScript.
Proxy
Reflect
Introduzido em ECMAScript 6, objetos Proxy permitem que você intercepte determinadas operações e implementar comportamentos personalizados. Por exemplo, receber uma propriedade em um objeto:
var handler = { get: function (target, name) { return name in target ? target[name] : 42; }, }; var p = new Proxy({}, handler); p.a = 1; console.log(p.a, p.b); // 1, 42
O objeto Proxy define um target (um objeto vazio aqui) e um objeto handler em que um get trap é implementado. Aqui, um objeto que está em proxy não retornará indefinido quando receber propriedades indefinidas, mas, ao contrário, retornar o número 42.
target
handler
get
Exemplos adicionais estão disponíveis na página de referência de Proxy .
Os seguintes termos são usados quando se fala sobre a funcionalidade de proxies.
Espaço reservado de objeto que contenha traps.
Os métodos que fornecem acesso de propriedade. Isto é análogo ao conceito de traps em sistemas operacionais.
Objeto que o proxy está virtualizando. Ele é frequentemente usado como backend de armazenamento para o proxy. Invariantes (semânticas que permanecem inalteradas) relativas a objetos que não podem ser extendidos ou propriedades que não podem ser configuradas são comparadas com o target.
Semânticas que permanecem inalteradas na execução de operações personalizadas são chamados de invariantes. Se você violar as invariantes de um manipulador, um TypeError será lançado.
TypeError
A tabela a seguir resume as traps disponíveis aos objetos do tipo Proxy. Veja as páginas de referência para explicações detalhadas e exemplos.
handler.getPrototypeOf()
Object.getPrototypeOf()
Reflect.getPrototypeOf()
__proto__
Object.prototype.isPrototypeOf()
instanceof
getPrototypeOf
null
Object.getPrototypeOf(proxy)
Object.getPrototypeOf(target)
handler.setPrototypeOf()
Object.setPrototypeOf()
Reflect.setPrototypeOf()
Se target não puder ser extendido, o parâmetro prototype dever ter o mesmo valor que Object.getPrototypeOf(target).
prototype
handler.isExtensible()
Object.isExtensible()
Reflect.isExtensible()
Object.isExtensible(proxy)
Object.isExtensible(target)
handler.preventExtensions()
Object.preventExtensions()
Reflect.preventExtensions()
Object.preventExtensions(proxy)
true
false
handler.getOwnPropertyDescriptor()
Object.getOwnPropertyDescriptor()
Reflect.getOwnPropertyDescriptor()
getOwnPropertyDescriptor
undefined
Object.getOwnPropertyDescriptor(target)
Object.defineProperty
handler.defineProperty()
Object.defineProperty()
Reflect.defineProperty()
Object.defineProperty(target, prop, descriptor)
defineProperty
handler.has()
foo in proxy
foo in Object.create(proxy)
Reflect.has()
handler.get()
proxy[foo]
proxy.bar
Object.create(proxy)[foo]
Reflect.get()
handler.set()
proxy[foo] = bar
proxy.foo = bar
Object.create(proxy)[foo] = bar
Reflect.set()
set
handler.deleteProperty()
delete proxy[foo]
delete proxy.foo
Reflect.deleteProperty()
handler.enumerate()
for (var name in proxy) {...}
Reflect.enumerate()
O método enumerate deve retornar um objeto.
enumerate
handler.ownKeys()
Object.getOwnPropertyNames()
Object.getOwnPropertySymbols()
Object.keys()
Reflect.ownKeys()
ownKeys
String
Symbol
handler.apply()
proxy(..args)
Function.prototype.apply()
Function.prototype.call()
Reflect.apply()
Não há invariantes para o método handler.apply
handler.apply
handler.construct()
new proxy(...args)
Reflect.construct()
Object
O método Proxy.revocable() é utilizado para criar um objeto Proxy revogável. Isso significa que o proxy pode ser revogado através da função revoke, desligando-o. Depois disso, qualquer operação com o proxy lançará um TypeError.
Proxy.revocable()
revoke
var revocable = Proxy.revocable( {}, { get: function (target, name) { return "[[" + name + "]]"; }, }, ); var proxy = revocable.proxy; console.log(proxy.foo); // "[[foo]]" revocable.revoke(); console.log(proxy.foo); // TypeError é lançado proxy.foo = 1; // TypeError novamente delete proxy.foo; // ainda um TypeError typeof proxy; // "object", typeof não desencadeia nenhuma trap
Reflect é um objeto embutido que contém métodos que permitem a criação de operações interceptáveis em JavaScript. Os métodos são iguais àqueles de proxy handlers. Reflect não é um objeto do tipo function.
Reflect auxilia no encaminhamento de operações padrão do handler para o target.
Reflect.has(), por exemplo, tem o mesmo efeito prático que o operador in, com a facilidade de ser utilizado como uma função:
Reflect.has(Object, "assign"); // true
apply
Em ES5, você normalmente utiliza o método Function.prototype.apply() para invocar uma função com um dado valor para this e arguments fornecido como um array (ou um objeto parecido com um array).
this
arguments
Function.prototype.apply.call(Math.floor, undefined, [1.75]);
Com Reflect.apply essa operação se torna menos verbosa e mais fácil de compreender:
Reflect.apply
Reflect.apply(Math.floor, undefined, [1.75]); // 1; Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]); // "hello" Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index; // 4 Reflect.apply("".charAt, "ponies", [3]); // "i"
Com Object.defineProperty, a qual retorna um object em caso de sucesso ou lança um TypeError em caso contrário, você utilizaria um bloco try...catch para capturar qualquer erro que tenha ocorrido ao definir uma propriedade. Devido ao fato de Reflect.defineProperty retornar um status do tipo Boolean, você pode simplesmente utilizar aqui um bloco if...else:
object
try...catch
Reflect.defineProperty
Boolean
if...else
if (Reflect.defineProperty(target, property, attributes)) { // success } else { // failure }