Core Purpose and Design

The Reflect object is a built-in namespace that provides methods for interceptable JavaScript operations. Unlike traditional Object methods, Reflect offers a more consistent interface for object manipulation and serves as a bridge between high-level APIs and internal language mechanisms.

Property Access Operations

Reading Properties with get()

The Reflect.get() method retrieves property values from objects with expilcit receiver context control:

const userData = {
  identifier: 'primary-user',
  years: 25,
  get profile() {
    console.log(`Accessing: ${this.identifier}`);
    return 'active';
  }
};

console.log(Reflect.get(userData, 'profile', {identifier: 'secondary-context'}));
// Output: secondary-context, then 'active'

Writing Properties with set()

Property assignment through Reflect.set() provides better control over setter execution context:

const config = {
  timeout: 5000,
  set mode(value) {
    console.log(`Context:`, this);
  }
};

const setResult = Reflect.set(config, 'mode', 'production');
console.log(setResult); // true

const contextualSet = Reflect.set(config, 'mode', 'debug', {source: 'api'});
console.log(contextualSet); // true

Function Invocation Methods

apply() for Function Calls

Reflect.apply() provides a cleaner alternative to Function.prototype.apply():

const numbers = [10, 5, 8, 3];

// Modern approach
const minimum = Reflect.apply(Math.min, null, numbers);
console.log(minimum); // 3

// Traditional equivalent
const legacyMin = Function.prototype.apply.call(Math.min, null, numbers);
console.log(legacyMin); // 3

// String manipulation example
const text = 'application';
const segment = Reflect.apply(String.prototype.substring, text, [0, 5]);
console.log(segment); // 'appli'

construct() for Instance Creation

Object instantiation without the new keyword using Reflect.construct():

function DatabaseConnection(host) {
  this.host = host;
}

DatabaseConnection.prototype.connect = function() {
  return `Connected to ${this.host}`;
}

function ServiceClient(endpoint) {
  this.endpoint = endpoint;
}

ServiceClient.prototype.request = function() {
  return `Requesting ${this.endpoint}`;
}

// Standard construction
const dbInstance = Reflect.construct(DatabaseConnection, ['localhost']);
console.log(dbInstance.connect()); // Connected to localhost

// Prototype override construction
const serviceInstance = Reflect.construct(DatabaseConnection, ['api.example.com'], ServiceClient);
console.log(serviceInstance instanceof ServiceClient); // true
console.log(serviceInstance.request()); // Requesting api.example.com

Property Descriptor Management

defineProperty() for Property Definition

Unlike Object.defineProperty(), Reflect.defineProperty() returns boolean success indicators:

const targetObject = {};

// Traditional approach with error handling
try {
  Object.defineProperty(targetObject, 'standard', { value: 100 });
} catch (error) {
  console.error('Definition failed');
}

// Reflect approach with boolean feedback
const success = Reflect.defineProperty(targetObject, 'modern', {
  configurable: true,
  enumerable: true,
  value: 200
});

console.log(success); // true

deleteProperty() for Property Removal

Controlled property deletion with explicit success feedback:

delete const settings = {
  theme: 'dark',
  language: 'en',
  temporary: 'data'
};

const removalSuccess = Reflect.deleteProperty(settings, 'temporary');
console.log(removalSuccess); // true
console.log(settings); // {theme: 'dark', language: 'en'}

// Non-existent property deletion still succeeds
const absentRemoval = Reflect.deleteProperty(settings, 'missing');
console.log(absentRemoval); // true

Property Inspection Utilities

has() for Property Existence

Property existence checking as an alternative to the in operator:

const component = {
  type: 'button',
  state: 'enabled'
};

console.log(Reflect.has(component, 'type')); // true
console.log(Reflect.has(component, 'render')); // false

// Works with prototype chain properties
function Widget(identifier) {
  this.id = identifier;
}
Widget.prototype.render = function() {};

const instance = new Widget('main');
console.log(Reflect.has(instance, 'id')); // true
console.log(Reflect.has(instance, 'render')); // true

ownKeys() for Property Enumeration

Comprehensive property key retrieval including non-enumerable properties:

const registry = {
  name: 'service-registry',
  version: '1.0'
};

console.log(Reflect.ownKeys(registry)); // ['name', 'version']

Object Extensibility Controls

preventExtensions() for Locking Objects

Preventing future property additions to objects:

const lockedConfig = {};
console.log(Reflect.isExtensible(lockedConfig)); // true

Reflect.preventExtensions(lockedConfig);
console.log(Reflect.isExtensible(lockedConfig)); // false

isExtensible() for Extension Checking

Verifying whether objects can accept new properties:

const flexibleObject = {};
console.log(Reflect.isExtensible(flexibleObject)); // true

Object.preventExtensions(flexibleObject);
console.log(Reflect.isExtensible(flexibleObject)); // false

Descriptor and Prototype Operations

getOwnPropertyDescriptor() for Property Metadata

Retrieving detailed property descriptor information:

const structuredData = {};

Reflect.defineProperty(structuredData, 'computed', {
  configurable: false,
  enumerable: true,
  writable: false,
  value: 'calculated'
});

const descriptor = Reflect.getOwnPropertyDescriptor(structuredData, 'computed');
console.log(descriptor);
/*
{
  configurable: false,
  enumerable: true,
  writable: false,
  value: 'calculated'
}
*/

getPrototypeOf() for Prototype Retrieval

Accessing an object's prototype chain:

function BaseModule() {}
BaseModule.prototype.initialize = function() {};

const moduleInstance = new BaseModule();
console.log(Reflect.getPrototypeOf(moduleInstance) === BaseModule.prototype); // true

setPrototypeOf() for Prototype Assignment

Programmatic prototype chain modification:

const dataContainer = {};
const prototypeAssignment = Reflect.setPrototypeOf(dataContainer, Array.prototype);
console.log(prototypeAssignment); // true

const frozenAssignment = Reflect.setPrototypeOf(Object.freeze({}), null);
console.log(frozenAssignment); // false