Post Top Ad

Your Ad Spot

domingo, 28 de junio de 2020

Propuesta ES: Object.fromEntries()

La propuesta " Object.fromEntries" (por Darien Maillet Valentine, Jordan Harband y Kevin Gibbons) se encuentra en la etapa 4 y, por lo tanto, forma parte de ECMAScript 2019. Esta publicación de blog explica cómo funciona.

Object.fromEntries()vs. Object.entries()  

Dado un iterable sobre [clave, valor] pares, Object.fromEntries()crea un objeto:
assert.deepEqual(
  Object.fromEntries([['foo',1], ['bar',2]]),
  {
    foo: 1,
    bar: 2,
  }
);
Hace lo contrario de Object.entries():
const obj = {
  foo: 1,
  bar: 2,
};
assert.deepEqual(
  Object.entries(obj),
  [['foo',1], ['bar',2]]
);
Combinando Object.entries()con Object.fromEntries()ayuda con la implementación de una variedad de operaciones relacionadas con objetos. Sigue leyendo para ver ejemplos.

Ejemplos   

En esta sección, usaremos Object.entries()Object.fromEntries()implementaremos varias funciones de herramienta de la biblioteca Underscore .

_.pick(object, ...keys)  

pick()elimina todas las propiedades de objectcuyas claves no se encuentran keysLa eliminación no es destructiva : pick()crea una copia modificada y no cambia el original. Por ejemplo:
const address = {
  street: 'Evergreen Terrace',
  number: '742',
  city: 'Springfield',
  state: 'NT',
  zip: '49007',
};
assert.deepEqual(
  pick(address, 'street', 'number'),
  {
    street: 'Evergreen Terrace',
    number: '742',
  }
);
Podemos implementar pick()lo siguiente:
function pick(object, ...keys) {
  const filteredEntries = Object.entries(object)
    .filter(([key, _value]) => keys.includes(key));
  return Object.fromEntries(filteredEntries);
}

_.invert(object)  

invert() intercambia de forma no destructiva las claves y los valores de un objeto:
assert.deepEqual(
  invert({a: 1, b: 2, c: 3}),
  {1: 'a', 2: 'b', 3: 'c'}
);
Podemos implementarlo así:
function invert(object) {
  const mappedEntries = Object.entries(object)
    .map(([key, value]) => [value, key]);
  return Object.fromEntries(mappedEntries);
}

_.mapObject(object, iteratee, context?)  

mapObject()es como el método Array .map(), pero para objetos:
assert.deepEqual(
  mapObject({x: 7, y: 4}, value => value * 2),
  {x: 14, y: 8}
);
Esta es una implementación:
function mapObject(object, callback, thisValue) {
  const mappedEntries = Object.entries(object)
    .map(([key, value]) => {
      const mappedValue = callback.call(thisValue, value, key, object);
      return [key, mappedValue];
    });
  return Object.fromEntries(mappedEntries);
}

_.findKey(object, predicate, context?)  

findKey()devuelve la clave de la primera propiedad para la que predicatedevuelve true:
const address = {
  street: 'Evergreen Terrace',
  number: '742',
  city: 'Springfield',
  state: 'NT',
  zip: '49007',
};
assert.equal(
  findKey(address, (value, _key) => value === 'NT'),
  'state'
);
Podemos implementarlo de la siguiente manera:
function findKey(object, callback, thisValue) {
  for (const [key, value] of Object.entries(object)) {
    if (callback.call(thisValue, value, key, object)) {
      return key;
    }
  }
  return undefined;
}

Una implementación   

Object.fromEntries() podría implementarse de la siguiente manera (he omitido algunas verificaciones):
function fromEntries(iterable) {
  const result = {};
  for (const [key, value] of iterable) {
    let coercedKey;
    if (typeof key === 'string' || typeof key === 'symbol') {
      coercedKey = key;
    } else {
      coercedKey = String(key);
    }
    Object.defineProperty(result, coercedKey, {
      value,
      writable: true,
      enumerable: true,
      configurable: true,
    });
  }
  return result;
}
El polyfill oficial está disponible a través del paquete npmobject.fromentries .

Algunos detalles más sobre Object.fromEntries()  

  • Duplicar claves: si menciona la misma clave varias veces, la última mención "gana".
    > Object.fromEntries([['a', 1], ['a', 2]])
    { a: 2 }
    
  • Símbolos como claves: aunque Object.entries()ignora las propiedades cuyas claves son símbolos, Object.fromEntries()acepta símbolos como claves.
  • Coerción de claves: las claves de los pares [clave, valor] se convierten en claves de propiedad: los valores distintos de cadenas y símbolos se convierten en cadenas.
  • Iterables contra matrices:
    • Object.entries()devuelve una matriz (que es coherente con Object.keys()etc.). Sus pares [clave, valor] son ​​matrices de 2 elementos.
    • Object.fromEntries()es flexible: acepta iterables (que incluye matrices y es coherente con new Map()etc.). Sus pares [clave, valor] solo se requieren para ser objetos que tengan propiedades con las claves '0''1'(que incluye matrices de 2 elementos).
  • Solo se admiten propiedades de datos enumerables: si desea crear propiedades no enumerables y / o propiedades sin datos, debe usar Object.defineProperty()oObject.defineProperties() .

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

outbrain

Páginas