In JavaScript, what does `Object.getOwnPropertyDescriptor(obj, key)` return for a data property versus an accessor property, and which attributes can the two kinds never share?

## Properties are records, not just values In the specification an object property is not simply a name bound to a value: it is a record of **attributes**. Reflecting that record into ordinary JavaScript is what `Object.getOwnPropertyDescriptor(obj, key)` does. The shape of what comes back tells you which of the two possible kinds the property is. ## The data-property descriptor ```js const o = { count: 1 }; Object.getOwnPropertyDescriptor(o, 'count'); // { value: 1, writable: true, enumerable: true, configurable: true } ``` - **value** — the stored value, returned as-is on every read. - **writable** — whether assignment may replace `value`. When `false`, assignment is discarded in sloppy mode and throws a `TypeError` in strict mode. - **enumerable** — whether the key is visible to key-listing operations. - **configurable** — whether the property may be deleted, and whether its other attributes may be changed later. ## The accessor-property descriptor ```js const rect = { w: 3, h: 4, get area() { return this.w * this.h; } }; Object.getOwnPropertyDescriptor(rect, 'area'); // { get: [Function: get area], set: undefined, enumerable: true, configurable: true } ``` - **get** — a function called on read, or `undefined`. - **set** — a function called on write with one argument, or `undefined`. - **enumerable**, **configurable** — identical in meaning to the data case. Notice what is *absent*: there is no `value` and no `writable`. An accessor stores nothing, so there is nothing for `value` to hold, and "can this be written" is answered by whether `set` is a function. A getter-only property is the accessor world's read-only. ## The kinds are mutually exclusive Mixing the two field groups is an error, not a merge: ```js Object.defineProperty({}, 'x', { value: 1, get() { return 2; } }); // TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute ``` The same rule bans `writable` alongside `get`/`set`. A property can, however, *change* kind over its lifetime — redefining a configurable data property with `{ get }` converts it to an accessor and drops `value`/`writable`; the reverse conversion works the same way. If the property is non-configurable, both conversions throw. ## Own only, never inherited ```js class A { get id() { return 1; } } const a = new A(); Object.getOwnPropertyDescriptor(a, 'id'); // undefined Object.getOwnPropertyDescriptor(Object.getPrototypeOf(a), 'id'); // { get, set: undefined, ... } ``` The `undefined` result surprises people who expect it to mirror a plain read. Because class accessors and methods live on the prototype, you must look at `A.prototype` — or walk the chain with `Object.getPrototypeOf` in a loop — to find their descriptors. Note also that the prototype descriptor reports `enumerable: false`: class-body members are deliberately non-enumerable, while object-literal members are enumerable. ## The plural form ```js Object.getOwnPropertyDescriptors(rect); // { w: {...}, h: {...}, area: { get: f, set: undefined, ... } } ``` `Object.getOwnPropertyDescriptors(obj)` (ES2017) returns one object mapping every own key — strings *and* symbols — to its descriptor. It pairs with `Object.defineProperties(target, descriptorMap)` and with `Object.create(proto, descriptorMap)`, both of which consume exactly that shape, which is what makes descriptor-preserving object construction possible. ## Reading a returned descriptor is safe The returned object is a fresh, ordinary object each call — a snapshot, not a live view. Mutating it changes nothing about the real property; you must feed it back through `Object.defineProperty` for an edit to take effect: ```js const d = Object.getOwnPropertyDescriptor(o, 'count'); d.writable = false; // no effect yet Object.defineProperty(o, 'count', d); // now the property is read-only ``` That round-trip is the idiomatic way to change one attribute while preserving the rest, and it is why descriptors are a *record you can pass around* rather than a hidden engine detail. ## Why interviewers ask this The descriptor is the vocabulary underneath a whole family of behaviours: why a property never appears in a key listing, why an assignment silently does nothing, why a library-defined property refuses to be deleted, and why copying an object with spread turns a getter into a frozen snapshot. A candidate who can name the two shapes and say which attributes they share can explain all of those from first principles instead of memorising each symptom.