Thehandler.has() method is a trap for the[[HasProperty]]object internal method, which is used by operations such as thein operator.

Try it

const handler = {  has(target, key) {    if (key[0] === "_") {      return false;    }    return key in target;  },};const monster = {  _secret: "easily scared",  eyeCount: 4,};const proxy = new Proxy(monster, handler);console.log("eyeCount" in proxy);// Expected output: trueconsole.log("_secret" in proxy);// Expected output: falseconsole.log("_secret" in monster);// Expected output: true

Syntax

new Proxy(target, {  has(target, property) {  }})

Parameters

The following parameters are passed tohas() method.this is bound to the handler.

target

The target object.

property

A string orSymbol representing the property name.

Return value

Thehas() method must return aBoolean indicating whether or not the property exists. Other values arecoerced to booleans.

Description

Interceptions

This trap can intercept these operations:

• Thein operator:foo in proxy
• with check:with(proxy) { (foo); }
• Reflect.has()

Or any other operation that invokes the[[HasProperty]]internal method.

Invariants

The proxy's[[HasProperty]] internal method throws aTypeError if the handler definition violates one of the following invariants:

• A property cannot be reported as non-existent, if it exists as a non-configurable own property of the target object. That is, ifReflect.getOwnPropertyDescriptor() returnsconfigurable: false for the property ontarget, the trap must returntrue.
• A property cannot be reported as non-existent, if it exists as an own property of the target object and the target object is not extensible. That is, ifReflect.isExtensible() returnsfalse ontarget, andReflect.getOwnPropertyDescriptor() returns a property descriptor for the property ontarget, the trap must returntrue.

Examples

Trapping the in operator

The following code traps thein operator.

const p = new Proxy(  {},  {    has(target, prop) {      console.log(`called: ${prop}`);      return true;    },  },);console.log("a" in p);// "called: a"// true

The following code violates an invariant.

const obj = { a: 10 };Object.preventExtensions(obj);const p = new Proxy(obj, {  has(target, prop) {    return false;  },});"a" in p; // TypeError is thrown

Specifications

Browser compatibility

See also

• Proxy
• Proxy() constructor
• in
• Reflect.has()