使用对象解构时省略属性变量

Question

这是一个例子：

const initObject = {
  a: 0,
  b: 0,
  c: 0
}

const { a, ...rest } = initObject

我们从对象中省略了属性 a，但随后 const a 被分配了一个值，但从未使用过 - 来自 eslint 的错误 (no-unused-vars)。是否可以完全省略const a？

Answer 1

一种可能的方法是使用// eslint-disable-next-line no-unused-vars

例如

// eslint-disable-next-line no-unused-vars
const { a, ...rest } = initObject

或者使用ignoreRestSiblings

ignoreRestSiblings 选项是一个布尔值（默认值：false）。使用 Rest 属性可以从对象中“省略”属性，但默认情况下，兄弟属性被标记为“未使用”。启用此选项后，其余属性的兄弟姐妹将被忽略。

例如

/*eslint no-unused-vars: ["error", { "ignoreRestSiblings": true }]*/
// 'a' is ignored because it has a rest property sibling.
const { a, ...rest } = initObject;

更多关于no-unused-vars的信息

---

但如果您的目标是删除属性a，还有另一种方法。
您可以使用delete 运算符。

来自MDN documentation

JavaScript delete 运算符从对象中删除属性

例如

const initObject = {
  a: 0,
  b: 0,
  c: 0
}

const rest = { ...initObject }; // create a shallow copy
delete rest.a;

console.log(rest);

Answer 2

来自 eslint 的错误（no-unused-vars）。

no-unused-vars rules 有两个配置选项可以帮助您的用例：

• ignoreRestSiblings option 是一个布尔值，默认为false。启用后，其余属性的兄弟姐妹将被忽略。这正是您所需要的！

• varsIgnorePattern option 为不检查使用情况的变量名称指定了一个正则表达式模式。这允许我们为common underscore identifier 设置一个例外，以使用{ "varsIgnorePattern": "^_" } 显式标记未使用的变量。

  const { a:_, ...rest } = initObject;
  //       ^^
  

  不幸的是，您仍然需要避免_ 变量的多个声明，因此要省略多个属性，您需要执行{ a:_a, b:_b, ...rest } = … 之类的操作。

是否可以完全省略const a？

完全避免引入任何标识符的坏技巧是使用

const { a:{}, ...rest } = initObject;
//       ^^^

这进一步将.a 属性值解构为一个对象，但为此您需要确保该属性存在并且不包含null 或undefined 值。

Answer 3

这似乎与@R3tep's answer 略有偏差，但它避免了将声明中的所有变量标记为已使用的陷阱：

const initObject = {
  a: 0,
  b: 0,
  c: 0
}

const {
  a, // eslint-disable-line no-unused-vars
  ...rest
} = initObject

现在如果rest未被使用，仍然会导致eslint错误。

---

关于问题

那么删除属性的正确方法是什么？

我将回答您应该提出的问题。 处理具有您不需要的属性的对象的正确方法是以一种隐式忽略它们的方式重写您的逻辑。

1. 如果您只需要属性b 和c，请仅解构这些属性：

   const { b, c } = initObject
   

   如果你不需要a，甚至不要承认它的存在。

2. 如果您的输入有很多您需要处理的特定属性，并且您不能假设initObject 已经具有它需要的确切布局，然后避免使用反射方法或语法的诱惑，如Object.entries()、for...in、object spread and rest syntax 等。

   继续单独处理您需要的特定属性，并将您的逻辑分解为可分离的函数，如果需要，每个函数都处理可管理的属性子集。

   另一方面，如果您可以预先设置您的输入以具有您已经需要的确切布局（例如，您可以假设initObject 只有b 和c） ，然后随意使用反射——这正是它的用途。

3. 如果以上两点都不适合你，但你仍然发现你真的希望initObject 有很多任意属性，还有一些你想忽略，那么您应该使用此答案开头的建议（或其他适合您的答案之一）。

   但是，如上所述，这是代码异味，表明您的逻辑需要对对象的布局更加宽松¹，或者您的输入前提条件需要更改².

Answer 4

您可以创建一个 IIFE 并将对象传递给它。

const initObject = {
  a: 0,
  b: 0,
  c: 0
}
const res = (({a,...rest}) => (a,rest))(initObject);
console.log(res)

Answer 5

技术上满足 linter 规则的一个选项是预先声明 rest，将 a 属性解构为 rest，然后然后使用 rest 语法将对象的其余部分放入rest 变量名中：

const initObject = {
  a: 0,
  b: 0,
  c: 0
};
let rest;
({ a: rest, ...rest } = initObject);

console.log(rest);

不幸的是，如果你想避免var，你不能像这样只用一行来做到这一点

let { a: rest, ...rest } = initObject

因为当{ 的左侧声明一个变量时，右侧的每个新变量名都分别初始化 - 也就是说，对于解释器来说，它看起来有点像

let rest = initObject.a;
let rest = <everything else in initObject>

但不允许为相同的变量名称重复 let 标识符。您可以在一行中使用var，允许重复标识符：

const initObject = {
  a: 0,
  b: 0,
  c: 0
};
var { a: rest, ...rest } = initObject;

console.log(rest);

但这有点奇怪。正如其他答案所建议的那样，我更喜欢配置/忽略 linter，或者使用解构以外的东西。

Answer 6

您可以使用Object.assign() 创建对象的浅表副本，然后简单地删除该属性。

const initObject = {
  a: 0,
  b: 0,
  c: 0
}

let rest = Object.assign({}, initObject);
delete rest.a;

console.log(rest);
console.log(initObject);

Answer 7

试试

const rest = ((o)=> (delete o.a,o))({...initObject});

'use strict'

const initObject = {
  a: 0,
  b: 0,
  c: 0
}

const rest = ((o)=> (delete o.a,o))({...initObject});

console.log({initObject,rest});

Answer 8

为了省略（清理） ID 和密码属性，这最终在一个对象中对我有用。

这是来自产品和用户模型之间的关系的响应。

   return {...product,
        author: [
            `username: ` + product['author'].username,
            `email: ` + product['author'].email,
        ]};

否则对于数组，我使用：

    return products.map(product => [{ 
        'title' : product['title'],
        'description' : product['description'],
        'price' : product['price'],
        'updated' : product['updatedAt'],
        'author': {
            'username' : product['author'].username,
            'email' : product['author'].email,
        },                   
    }]);

我正在使用 PostgreSQL、Nest、Objection 和 Knex。