Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
JavaScript Proxy intercepts operations on an object; Reflect supplies callable versions of the ordinary internal operations you usually want to forward. Use a proxy when you need policy at an object boundary—validation, auditing, virtual properties, formatting, or coordination between objects. Use Reflect inside the handler when your custom code should wrap normal JavaScript semantics instead of replacing them. The combination is powerful, but it has strict invariants, receiver-sensitive behavior, and hard limits around private fields and built-ins such as Map. This guide maps every trap, shows safe forwarding code, explains recursion and descriptor errors, and gives practical patterns you can adapt without accidentally changing the language rules your target object depends on.
What is a JavaScript Proxy?
A Proxy is an object that wraps a target object and lets a handler intercept fundamental operations performed on that target. The constructor is new Proxy(target, handler). The target can be an object or function, and the handler contains optional methods called traps. If a handler is empty, ordinary operations are forwarded as if you were using the target directly, although the proxy is still a distinct object.
As an Amazon Associate I earn from qualifying purchases.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteTraps cover language-level operations rather than individual library methods. Reading user.name invokes the get trap; 'name' in user invokes has; delete user.name invokes deleteProperty. A call expression can invoke apply, and new user() can invoke construct when the target is constructable. Array methods and other built-ins may trigger several traps indirectly as they read, write, or inspect their receiver.
The handler decides whether to return a value, report success, or forward the operation. It cannot, however, contradict protected facts about the target. The engine checks those rules after a trap returns and throws a TypeError when the result would make a non-configurable descriptor, a non-extensible target, or another invariant appear inconsistent.
Popular on Amazon
- Read Before You Buy — No Video Output: These adapters support charging and USB 2.0 data transfer, but cannot transmit video signals. Except for standard USB webcams (which use USB data only), they are not compatible with HDMI/DisplayPort cables, video-capable USB-C hubs, or docking stations with video output.
- Convert USB-A Ports to USB-C: Designed to connect USB-C earphones, cables, flash drives, card readers, and other USB-C accessories to standard USB-A ports. Plug-and-play with no drivers or software required.
- Aluminum Alloy Housing: Built with a sturdy aluminum alloy shell that aids in heat dissipation and protects against daily wear and scratches. Designed to maintain a stable and secure connection.
- Compact & Travel-Friendly: The ultra-compact design allows the adapter to stay plugged into your device without blocking adjacent ports or adding bulk, reducing wear and tear on your original USB ports.
- 12-Month Warranty: Backed by a 12-month manufacturer warranty for peace of mind. Designed to meet strict quality control standards for reliable everyday performance.
How do Proxy traps map to JavaScript operations?
Each trap corresponds to a family of object internal methods. The matching Reflect method is generally the safest default forwarder because it returns the operation’s ordinary result instead of requiring you to recreate edge-case semantics.
| Operation family | Proxy trap | Typical Reflect forwarder | Trap result |
|---|---|---|---|
| Property read | get |
Reflect.get(target, property, receiver) |
Any value |
| Property write | set |
Reflect.set(target, property, value, receiver) |
Boolean success |
in operator |
has |
Reflect.has(target, property) |
Boolean |
| Deletion | deleteProperty |
Reflect.deleteProperty(target, property) |
Boolean success |
| Own-key enumeration | ownKeys |
Reflect.ownKeys(target) |
Array of strings and symbols |
| Descriptor lookup | getOwnPropertyDescriptor |
Reflect.getOwnPropertyDescriptor(target, property) |
Descriptor or undefined |
| Define a property | defineProperty |
Reflect.defineProperty(target, property, descriptor) |
Boolean success |
| Prototype read | getPrototypeOf |
Reflect.getPrototypeOf(target) |
Object or null |
| Prototype write | setPrototypeOf |
Reflect.setPrototypeOf(target, prototype) |
Boolean success |
| Extensibility check | isExtensible |
Reflect.isExtensible(target) |
Boolean |
| Prevent extensions | preventExtensions |
Reflect.preventExtensions(target) |
Boolean success |
| Function call | apply |
Reflect.apply(target, thisArg, argumentsList) |
Call result |
Construction with new |
construct |
Reflect.construct(target, argumentsList, newTarget) |
New object |
The table describes the direct operation. A single source statement can cause more than one trap. For example, an assignment may perform a set operation and, when the receiver differs from the target, eventually define a property on that receiver.
Free tools Windows power users keep installed
One-click scans. No signup required.
What is Reflect, and how is it different from Proxy?
Reflect is a namespace object, not a constructor and not a proxy. Its static methods expose callable forms of JavaScript’s interceptable object internal methods. They are useful even when no proxy exists: Reflect.defineProperty reports a Boolean rather than forcing exception handling, and Reflect.apply gives a direct function-call form.
The roles are complementary:
- Proxy customizes or observes. A handler decides what happens when code reads, writes, calls, constructs, enumerates, or changes the target.
- Reflect performs the default operation. A handler can add a check, log an event, or transform a value, then delegate to the corresponding Reflect method.
- Reflect does not remove a proxy. Calling
Reflect.get(proxy, key)still operates on the proxy and can invoke itsgettrap. To avoid that, pass the underlying target explicitly.
Use a proxy when interception itself is the requirement. Use Reflect directly when you need predictable, Boolean-returning object operations without interception.
How do I build a safe forwarding proxy?
Start with a target reference and forward through that reference, preserving the receiver supplied by the language. Add custom behavior around the forwarding call rather than manually reading or writing the target.
- Create the target. Keep the original object in a variable that the handler can close over or receive as its first argument.
- Implement only the traps you need. Unimplemented traps use the proxy’s default forwarding behavior.
- Forward with the matching Reflect method. Pass
targetas the first argument and preservereceiverforgetandset. - Return the correct type. A
settrap must return a Boolean-like success result; agettrap returns the property value. - Exercise protected descriptors and accessors in tests. A proxy that works for ordinary writable properties can still fail on frozen or accessor-based objects.
const target = {
firstName: 'Ada',
get label() {
return this.firstName;
}
};
const proxy = new Proxy(target, {
get(target, property, receiver) {
console.log('read', property);
return Reflect.get(target, property, receiver);
},
set(target, property, value, receiver) {
console.log('write', property, value);
return Reflect.set(target, property, value, receiver);
}
});With this pattern, proxy.label invokes the getter with the appropriate receiver, and an assignment reports the Boolean result produced by the normal [[Set]] operation. Logging does not replace ordinary descriptor checks or setter behavior.
Why does Reflect.get recurse inside my trap?
Recursion occurs when the trap calls Reflect on the proxy instead of on the target. Reflect follows the object you pass; it does not “de-proxify” that object.
const target = { name: 'Ada' };
const proxy = new Proxy(target, {
get(target, property, receiver) {
return Reflect.get(receiver, property, receiver); // receiver is proxy: recurse
}
});Reading proxy.name enters get, then calls Reflect.get with receiver set to the same proxy. That operation enters get again indefinitely until the call stack overflows. The safe form is Reflect.get(target, property, receiver). The same rule applies to Reflect.set, Reflect.has, and other methods: pass the non-proxy target when you intend ordinary forwarding.
Also popular on Amazon
- 5-in-1 USB-C Hub: Experience comprehensive connectivity featuring a Power Delivery input, two USB-A 2.0 ports, a USB-A 3.0 port, and an HDMI port. (Note: The USB-C power delivery input port is only for connecting an external wall charger to power your laptop and cannot power peripheral devices.)
- 90W Pass-Through Charging: Achieve optimal charging with 90W pass-through power to your laptop, supported by a total input of 100W, with the hub reserving 10W for operational efficiency. (Note: Wall charger not included.)
- Quick Data Transfers: Accelerate your productivity with rapid data transfers using a high-speed 5Gbps USB 3.0 port and two 480Mbps USB 2.0 ports.
- 4K HDMI Display: Enhance your visual experience with a hub capable of delivering 4K resolution at 30Hz in both mirror and extend modes. Please note that this hub is compatible with MacBook (macOS 12 and newer), Windows 10 and 11, ChromeOS, and laptops equipped with DP Alt Mode and Power Delivery. Note: This device is not compatible with Linux.
- What You Get: Anker USB-C Hub (5-in-1, 4K HDMI), welcome guide, 18-month warranty, and our friendly customer service.
What does the receiver argument change?
The receiver is the object that should act as this when a getter or setter runs. It is often the proxy, even though the target is where the property lookup begins. Preserving it keeps inheritance and accessor semantics consistent.
const base = {
get greeting() {
return `Hello, ${this.name}`;
}
};
const target = Object.create(base);
target.name = 'Ada';
const proxy = new Proxy(target, {
get(target, property, receiver) {
return Reflect.get(target, property, receiver);
}
});If you replace receiver with target unconditionally, the getter may observe the target instead of a derived object or the proxy. That can change subclass behavior and can bypass state a caller intentionally exposes through the receiver. Conversely, deliberately passing the target can be useful when you are building a tightly controlled wrapper, but it is a semantic change that should be documented and tested.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
What do traps return, and which invariants can make them throw?
Trap return values are part of the contract. Boolean traps communicate success or failure; value-producing traps supply data. The engine then validates the answer against the target’s descriptors and extensibility state.
getmust not report a value that contradicts a non-writable, non-configurable data property on the target.setcannot report success with a different value for that same kind of fixed data property.setcannot report success for a non-configurable accessor property whose setter is absent.ownKeysmust include required non-configurable own keys and cannot invent a key on a non-extensible target.getOwnPropertyDescriptoranddefinePropertymust describe properties consistently with configurability and extensibility.isExtensibleandpreventExtensionsmust agree with the target’s actual extensibility state.getPrototypeOfandsetPrototypeOfcannot claim a prototype relationship that the target’s non-extensible state forbids.
These are engine-enforced consistency rules, not optional style guidance. A trap can hide a configurable property, reject a write, or synthesize a missing value, but it cannot make protected target metadata appear different. When a TypeError mentions an invariant, inspect the target descriptor with Object.getOwnPropertyDescriptor and check whether the target is extensible before changing the handler.
How can a set trap validate data without breaking normal assignment?
A validation trap should reject invalid input before forwarding valid input, and it should return the Boolean result from Reflect.set. In strict mode, a false result causes the assignment expression to throw; in non-strict code, the assignment fails silently.
const account = { age: 30 };
const checkedAccount = new Proxy(account, {
set(target, property, value, receiver) {
if (property === 'age' && (!Number.isInteger(value) || value < 0)) {
return false;
}
return Reflect.set(target, property, value, receiver);
}
});
checkedAccount.age = 31; // succeeds
// checkedAccount.age = -1; // rejected by the trapDo not return true after rejecting a value: that tells the caller the write succeeded even though the target was not updated. Also avoid silently converting a value unless the API explicitly promises that normalization; conversion is observable behavior and can surprise code that relies on the original type.
How are logging, defaults, and virtual properties implemented?
Logging and auditing
Read and write events can be recorded around the corresponding Reflect call. Add deleteProperty and defineProperty when the audit requirement includes removal or descriptor changes. Record the property key, operation, and outcome rather than assuming every trap call succeeds.
const audited = new Proxy(target, {
get(target, property, receiver) {
const value = Reflect.get(target, property, receiver);
audit('read', property, value);
return value;
},
deleteProperty(target, property) {
const ok = Reflect.deleteProperty(target, property);
audit('delete', property, ok);
return ok;
}
});Defaults and virtual properties
A get trap can synthesize a value when the target has no property, then delegate existing properties unchanged. Use an own-property or membership check so a legitimate stored falsy value such as 0 is not mistaken for absence.
Also popular on Amazon
- Sleek 7-in-1 USB-C Hub: Features an HDMI port, two USB-A 3.0 ports, and a USB-C data port, each providing 5Gbps transfer speeds. It also includes a USB-C PD input port for charging up to 100W and dual SD and TF card slots, all in a compact design.
- Flawless 4K@60Hz Video with HDMI: Delivers exceptional clarity and smoothness with its 4K@60Hz HDMI port, making it ideal for high-definition presentations and entertainment. (Note: Only the HDMI port supports video projection; the USB-C port is for data transfer only.)
- Double Up on Efficiency: The two USB-A 3.0 ports and a USB-C port support a fast 5Gbps data rate, significantly boosting your transfer speeds and improving productivity.
- Fast and Reliable 85W Charging: Offers high-capacity, speedy charging for laptops up to 85W, so you spend less time tethered to an outlet and more time being productive.
- What You Get: Anker USB-C Hub (7-in-1), welcome guide, 18-month warranty, and our friendly customer service.
const settings = new Proxy({ theme: 'dark' }, {
get(target, property, receiver) {
if (!(property in target) && property === 'locale') {
return 'en-US';
}
return Reflect.get(target, property, receiver);
}
});Sanitization and formatting
A set trap can normalize input before forwarding, while a get trap can format a value for presentation. Keep storage and presentation rules distinct when callers need the unformatted value for calculations.
Coordinating related objects
In browser code, a proxy can coordinate attributes across related DOM nodes: a write to one exposed property can update another node before or after the underlying object is changed. DOM objects have their own host-object behavior, so keep the target explicit and test the exact browser interfaces you wrap.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Why are assignment and defineProperty different through a proxy?
Ordinary assignment follows the internal [[Set]] method. Object.defineProperty, class-field initialization, and similar operations follow [[DefineOwnProperty]]. They can therefore activate different traps and produce different receiver behavior.
For example, proxy.value = 1 normally starts with set. If the assignment must create a property on a receiver, the operation can eventually involve defineProperty. By contrast, Object.defineProperty(proxy, 'value', descriptor) directly targets the defineProperty trap. A handler that validates only set can therefore miss class fields or explicit descriptor updates.
When a policy applies to all writes, decide whether it governs values, descriptors, or both. Implement both traps when necessary, and forward with Reflect.defineProperty so descriptor compatibility and the Boolean success result remain intact.
Why do private fields fail through a Proxy?
Private class fields are tied to the original class instance, not to a proxy object that happens to wrap it. A method or getter that evaluates this.#secret checks the private-brand identity of this. When this is the proxy, the check can fail with a “Cannot read private member” error even though the target instance owns the field.
Preserving the receiver is normally correct for public getters, but it exposes this private-brand boundary. Possible designs include exposing public methods that are explicitly bound to the target, avoiding a proxy at that boundary, or writing a specialized handler that calls methods with the original instance. Each choice changes how this behaves, so test inherited methods, accessors, and callbacks rather than applying a blanket binding rule.
Why does a Map fail when it is wrapped in a Proxy?
A Map method such as get expects its this value to carry the Map’s internal [[MapData]] slot. A transparent-looking proxy does not acquire that internal slot. Calling proxyMap.get('key') can therefore throw an incompatible-receiver error.
Also popular on Amazon
- Dual Converters, Infinite Potential：Includes 2× USB C male to USB A female adapters and 2× USB A male to USB C female adapters. Perfect for a wide range of uses—tablets with Bluetooth keyboards, expand USB ports on macbook, and more. Two different converters for all your daily needs
- Next-Level 10Gbps & 3A Charging: No more slow 480Mbps, this usb to usb c adapter has a transfer speed of up to 10Gbps, allowing you to do more transferring in less time. This usb adapter fits both USB A and USB C charger, supporting up to 3A fast charging
- Upgraded Exquisite Craftsmanship: With an aluminum alloy housing and metal connector, the usbc to usb adapter is extremely durable and sturdy. Rigorously tested to withstand more than 10,000 times of plugging and unplugging, ensuring long-lasting performance
- Broad Compatible: The usb c to usb adapter widely supports all USB C/ USB A devices like laptops, tablets, cellphones, car chargers, and phone chargers. Such as compatible with MacBook Pro/Air 2023/2022, Thunderbolt 4/3 Devices,Apple MagSafe Watch 9/8/7/SE/Ultra, iPad Pro 2022/2021, Samsung Galaxy S23/S20/S10, and iPhone 17/16/15 Pro. Plug and play
- Please Note: To reach 10Gbps speed, keep the cable under 3.3 ft. For USB A Male to USB C adapters, try flipping the USB C connector. USB C Male to USB A adapters support bidirectional 10Gbps transfer within 3.3 ft
A common workaround is a this-recovering wrapper that binds callable properties to the target:
function wrapWithThisRecovery(target) {
return new Proxy(target, {
get(target, property, receiver) {
const value = Reflect.get(target, property, receiver);
if (typeof value === 'function') {
return value.bind(target);
}
return value;
}
});
}
const proxyMap = wrapWithThisRecovery(new Map([['key', 'value']]));
proxyMap.get('key');Binding every function is not universally transparent: methods that are intended to observe a derived receiver, private methods, or fluent APIs may need different treatment. If the wrapped built-in exposes accessors or relies on identity checks, an explicit facade can be safer than a generic proxy.
How do apply and construct traps work?
The apply trap intercepts calls to a function target. Its arguments are the target function, the this value, and an array-like argument list. Use Reflect.apply to preserve ordinary call semantics after logging or validating arguments.
function add(a, b) {
return a + b;
}
const observedAdd = new Proxy(add, {
apply(target, thisArg, argumentsList) {
console.log('arguments', argumentsList);
return Reflect.apply(target, thisArg, argumentsList);
}
});The construct trap intercepts new for a constructable target. Forward with Reflect.construct(target, argumentsList, newTarget); preserving newTarget matters for prototype selection and derived constructors. A non-constructable function cannot be made constructable merely by adding a trap.
When should I use Proxy, Reflect, or neither?
- Choose Proxy when callers must continue using normal property, call, or construction syntax while you enforce validation, observe operations, provide virtual values, or coordinate objects.
- Choose Reflect inside a Proxy when custom logic should wrap default behavior. It keeps Boolean success results, accessors, prototypes, and descriptor rules aligned with the language.
- Choose Reflect without Proxy when you need explicit internal-method calls such as a non-throwing property definition or a direct function invocation.
- Prefer an explicit class or facade when the object relies heavily on private fields, internal slots, identity-sensitive methods, or a narrow public API. A facade makes the supported surface clear instead of pretending every operation is transparent.
- Avoid interception when a direct function, setter, or schema validator can express the policy more clearly. Proxy adds an invisible control path that every consumer of the object must understand.
Do not choose based on an assumed speed advantage. The available documentation establishes behavior and constraints, not a universal performance benchmark. Measure your own workload if interception appears in a hot path, and preserve a non-proxy code path when profiling or debugging requires it.
How do I troubleshoot a broken proxy?
The handler recurses or overflows the stack
Inspect every Reflect call in the trap. If it receives the proxy instead of the target, replace that argument with the target while retaining the original receiver where accessor semantics require it.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallAn assignment unexpectedly throws
Check the Boolean returned by set and inspect the target descriptor. A false result is an intentional rejection, while a true result that conflicts with a non-writable, non-configurable property triggers an invariant error.
A getter sees the wrong object as this
Verify that Reflect.get receives the handler’s receiver. Passing the target deliberately can fix a specialized wrapper, but it also changes inheritance and accessor behavior.
Also popular on Amazon
- 5-in-1 Connectivity: Equipped with a 4K HDMI port, a 5 Gbps USB-C data port, two 5 Gbps USB-A ports, and a USB C 100W PD-IN port. Note: The USB C 100W PD-IN port supports only charging and does not support data transfer devices such as headphones or speakers.
- Powerful Pass-Through Charging: Supports up to 85W pass-through charging so you can power up your laptop while you use the hub. Note: Pass-through charging requires a charger (not included). Note: To achieve full power for iPad, we recommend using a 45W wall charger.
- Transfer Files in Seconds: Move files to and from your laptop at speeds of up to 5 Gbps via the USB-C and USB-A data ports. Note: The USB C 5Gbps Data port does not support video output.
- HD Display: Connect to the HDMI port to stream or mirror content to an external monitor in resolutions of up to 4K@30Hz. Note: The USB-C ports do not support video output.
- What You Get: Anker 332 USB-C Hub (5-in-1), welcome guide, our worry-free 18-month warranty, and friendly customer service.
Enumeration or sealing fails
Compare ownKeys, getOwnPropertyDescriptor, and extensibility traps with the target’s actual keys and descriptors. Forwarding through Reflect is safer than constructing a key list or descriptor object manually.
A built-in method reports an incompatible receiver
Assume the method requires an internal slot. Test a target-bound method or expose an explicit facade; do not assume that an empty handler makes a proxy identical to its target.
Recommended Free Tools
A class field or private method bypasses validation
Remember that class-field initialization uses [[DefineOwnProperty]], not just [[Set]], and private fields cannot be branded onto the proxy. Cover those paths separately in the handler design and tests.
What should a production test matrix include?
Proxy behavior is easiest to trust when tests exercise both ordinary and protected cases. Include:
- Reads and writes of own properties, inherited properties, symbols, and missing keys.
- Getters and setters that assert the identity of
this. - Writable, read-only, configurable, and non-configurable descriptors.
- Deletion, enumeration, descriptor definition, prototype changes, and attempts to extend a sealed target.
- Function calls and construction with explicit
this, derived constructors, and thrown errors. - Arrays and methods that perform indirect reads or writes.
- Private fields and internal-slot objects such as
Map, with an intentional policy for unsupported operations. - Strict-mode assignments that receive a false Boolean from
set.
For each trap, assert both the observable result and the target’s final state. This catches handlers that log the right event but accidentally skip a setter, mutate a descriptor, or claim success after rejecting an operation.
What are the essential rules to remember?
Proxy is the interception layer; Reflect is the forwarding vocabulary. Forward to the target, preserve the receiver when accessors need it, return the type each trap promises, and treat invariants as hard engine rules. Private fields and internal-slot built-ins are not transparently proxyable, so bind or facade them intentionally. With those boundaries explicit, proxies can add validation, auditing, virtual properties, formatting, and coordination without silently rewriting JavaScript’s object semantics.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Frequently Asked Questions
Can a Proxy intercept every operation performed by an object?
No. The trap set covers the language’s listed internal methods, but syntax and engine behavior outside those methods is not automatically observable. Private-field access is branded to the original instance, and built-ins that require internal slots can reject a proxy receiver.
Does an empty handler make a proxy identical to its target?
It forwards ordinary operations, but the proxy remains a separate object with different identity. Code that compares references, relies on private-field branding, or requires a built-in internal slot can therefore observe a difference.
Should I return true or false from a validation set trap?
Return the Boolean result that represents whether the write actually happened. Return false when the value is rejected; returning true without storing it lies to the caller and can violate target invariants.
How can I keep a proxy compatible with inherited getters?
Pass the original receiver to Reflect.get and Reflect.set while using the target as the first argument. Then test a derived object whose inherited accessor reads this, because replacing the receiver with the target changes that behavior.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
