Object.defineProperties()

Il metodo Object.defineProperties() definisce nuove proprietà o modifica le proprietà esistenti, direttamente sull'oggetto di ritorno.

Object.defineProperties(obj, props)

obj

L'oggetto su cui definire le nuove proprietà o modificare le esistenti proprietà.

props

Un oggetto che contiene le proprietà enumerabili. Per ogni proprietà troviamo dei descrittori della proprietà stessa, che ne impostano il comportamento. Suddividiamo i descrittori in due tipologie: il data descriptors e i descrittorei che ne regolano gli accessi (guarda Object.defineProperty() per maggiori dettagli). I descrittori hanno le seguenti c:

configurable

true se e solo se la proprietà individuata dal descrittore può essere cambiata e se la proprietà può essere cancellata dal presente oggetto.
Defaults a false.

enumerable

true se e solo se la proprietà è visualizzabile durante una enumerazione delle proprietà del presente oggetto (es. for-in)
Defaults a false.

value

Il valore associato con la proprietà che si sta definendo. Può essere un qualsiasi valore valido di Javascript (number, object, function, ecc...)
Defaults a undefined.

writable

true se e solo se il valore associato per la proprietà può essere cambiato con un operatore di assegnazione.
Defaults to false.

get

Una funzione che serve da getter (prelevare il dato) per la proprietà, o undefined se non è presente un getter. Il valore di ritorno della funzione verrà usato come valore della proprietà
Defaults a undefined.

set

Una funzione che serve da setter (impostare il dato) per la proprietà undefined se non è presente il setter. La funzione riceverà un solo argomento che verrà assegnato come valore della proprietà.
Defaults a undefined.

L'oggetto che è stato passato alla funzione.

Object.defineProperties, in sostanza, definisce tutte le proprietà di un oggetto, corrispondenti alle proprietà "own" proprie di un oggetto obj.

var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
  // etc. etc.
});

Assumendo di eseguire un ambiente precedente con tutti i nomi e le proprietà che fanno riferimento ai valori iniziali, Object.defineProperties è quasi completamente equivalente (nota il commento in isCallable) al seguente reimplementazione in Javascript:

function defineProperties(obj, properties) {
  function convertToDescriptor(desc) {
    function hasProperty(obj, prop) {
      return Object.prototype.hasOwnProperty.call(obj, prop);
    }

    function isCallable(v) {
      // NB: modify as necessary if other values than functions are callable.
      return typeof v === 'function';
    }

    if (typeof desc !== 'object' || desc === null)
      throw new TypeError('bad desc');

    var d = {};

    if (hasProperty(desc, 'enumerable'))
      d.enumerable = !!desc.enumerable;
    if (hasProperty(desc, 'configurable'))
      d.configurable = !!desc.configurable;
    if (hasProperty(desc, 'value'))
      d.value = desc.value;
    if (hasProperty(desc, 'writable'))
      d.writable = !!desc.writable;
    if (hasProperty(desc, 'get')) {
      var g = desc.get;

      if (!isCallable(g) && typeof g !== 'undefined')
        throw new TypeError('bad get');
      d.get = g;
    }
    if (hasProperty(desc, 'set')) {
      var s = desc.set;
      if (!isCallable(s) && typeof s !== 'undefined')
        throw new TypeError('bad set');
      d.set = s;
    }

    if (('get' in d || 'set' in d) && ('value' in d || 'writable' in d))
      throw new TypeError('identity-confused descriptor');

    return d;
  }

  if (typeof obj !== 'object' || obj === null)
    throw new TypeError('bad obj');

  properties = Object(properties);

  var keys = Object.keys(properties);
  var descs = [];

  for (var i = 0; i < keys.length; i++)
    descs.push([keys[i], convertToDescriptor(properties[keys[i]])]);

  for (var i = 0; i < descs.length; i++)
    Object.defineProperty(obj, descs[i][0], descs[i][1]);

  return obj;
}

• Object.defineProperty()
• Object.keys()
• Enumerability and ownership of properties