标签: destructuring

我知道 LISP 宏参数中的解构是一件好事；我想知道这是否是必要的。举个例子，

(defmacro m1 (a) (car a))

和

(defmacro m2 ((a1 a2)) a1)

似乎（大致）等效 - 除了检查参数的正确形式。

我的猜测是，解构使代码更容易编写/理解，但任何使用它的代码都可能被翻译成不那么容易编写/理解的代码。我是对的还是这是一个愚蠢的初学者错误？

有没有办法只解构函数参数中的某些对象属性，而其余的属性仍可在对象中访问？

考虑以下反应示例。（我以React为例，但这个问题一般适用于JS）

const Form = (formProps) => {
  return (
    ...
    <FormSectionComponent
       initialValues={...} 
       values={...}
       {...formProps}
    />
    ...
  )
}

const FormSectionComponent = ({ initialValues, values}) => {
...
}

传入的内容props在函数参数中被解构，但是，还有其他道具进来，我可能想在某些条件下访问这些道具，但我不想或无法解构 - 例如，我不知道它们是什么并且想记录他们。

有没有办法不解构参数部分中的其他道具并将它们作为props对象访问？

我能想到的唯一解决方法是：

const FormSectionComponent = (props) => {
  const { initialValues, values} = props;
}

但我想知道是否还有其他解决方案。

我有数组

如您所见，它有 4 个元素（created_at、first_name、id、last_name）。

我的问题是，如何将其解构为具有 2 个元素（id、name）的数组

（名字应该是 first_name + last_name）

我想知道是否可以在方法中声明一次变量，然后多次重用它们来捕获解构的返回值。

例如：

  function verifyStatusAsSignedIn(url, cred){

     // code truncated

     return { 'error' : false, 'status': true }
  }

我可以同时进行声明和解构 JSON。

 const { error , status } = verifyStatusAsSignedIn(url, cred);

但是我有更多方法可以调用，它们也将返回带有错误和状态的 JSON，就像方法 'verifyStatusAsSignedIn()' 所做的那样。

理想情况下，我想这样做：

  let error, status;

  { error, status } = verifyStatusAsSignedIn(url, cred);

  //  handle or respond to error and status.

  { error, status } = nextStep(val1, val2);

  // handle or respond to error and status

但这给了我一个 lint 警告“预期的声明或声明。

是否可以重用现有变量来解构 json 对象？

我有这个函数签名

const foo = (arg, { opt1, opt2, opt3 }) => {
   ...
};

但我希望第二个参数是可选的，例如调用函数

foo("Hello");

但是，我得到

类型错误：无法解构opt1“未定义”或“空”的属性。

所以，我很想通过更改函数来解决这个问题，例如：

const foo = (arg, options = {}) => {
   const { opt1, opt2, opt3 } = options;

   ...
};

但是想知道是否有更内联的替代方案？

根据所选的语言，我需要破坏对象并获得所需的值。
我该怎么做才能不破坏整个对象？

const translate = {
   "navMenu1": {
      "en": "Menu 1",
      "ru": "???? 1"
   },
   "navMenu2": {
      "en": "Menu 2",
      "ru": "???? 2"
   },
   "navMenu3": {
      "en": "Menu 3",
      "ru": "???? 3"
   }
}

const Header = props => {
  const { lang } = props;

  const {
    navMenu1,
    navMenu2,
    navMenu3
  } = translate;

  return (
    <header className={cnGreetingHeader}>
      <div>-Logo-</div>
      <nav className={cnNav}>
        <div className={cnItem}>{navMenu1[lang]}</div>
        <div className={cnItem}>{navMenu2[lang]}</div>
        <div className={cnItem}>{navMenu3[lang]}</div>
      </nav>
    </header>
  );
};

我想要

<div className={cnItem}>{navMenu1[lang]}</div> 

用

<div className={cnItem}>{navMenu1}</div>

重要提示：如果可能，我想要一个使用解构赋值的答案。

大家好，我有下面的对象结构，我正在尝试使用解构技术获取所有内部对象的名称，但无法做到这一点，下面是对象结构

   {
       massingType {
            id
            name
        }
        ashraeClimateZone {
             id
            name
        }
        sourceOfData {
             id
             name    
        }
        .....
    } 

我正在做如下的解构

 constructionSetData.constructionSets.forEach(item => {
    if (
      item.ashraeClimateZone?.id === ashraeClimateZoneId &&
      item.massingType?.id === massingTypeId &&
      item.sourceOfData?.id === energyCodeId
    ) {
      matchedConstructionDataSet.push(item.name);
      const { sourceOfData: name, massingType: name, ashraeClimateZone: name } = item; // getting error here Identifier 'name' has already been declared 
    }
  });
  return matchedConstructionDataSet.length
    ? `${matchedConstructionDataSet.join(', ')}` // here i need to use above names coming from three inner objects …

我尝试使用该[] = []方法在 JavaScript 中交换两个对象值，但下面的代码失败并显示错误"message": "Uncaught TypeError: Cannot set property '9' of undefined",

let dataObj={"reg_price":2, "reg_price_alt":5, "ex":9}
console.log("before: ", dataObj)
[dataObj.reg_price, dataObj.ex] = [4, 5];
console.log("after: ", dataObj)

我缺少一些语法吗？我不明白为什么这个简单的代码不起作用。

对象解构不是我最喜欢的东西，我经常尽量避免使用它。但是，在这种特殊情况下，我很好奇而无法忽视正在发生的事情。

现在我们可以这样做；

var o = {},
    x = 1,
    y = 2;
o = {x,y};
console.log(o); // <- {x: 1, y: 2}

一切都很好;

不过，我的情况有点复杂；

var p = function(o){
          o.promise = new Promise((resolve,reject) => o = {resolve,reject});
          console.log(o)  // -< {resolve: ƒ, reject: ƒ}
          return o;
        }({});
console.log(p);           // -< {resolve: ƒ, reject: ƒ}

..的promise财产在p哪里？所以我用经典的方式来做；

var q = function(o){
          o.promise = new Promise((resolve,reject) => ( o.resolve = resolve
                                                      , o.reject  = reject
                                                      ));
          console.log(o)  // <- {promise: …

我在 JavaScript 中遇到过以下问题：

const [x1, ...[result]] = [3, 4, 5]
console.log([result])

我知道 x1 是 3，但为什么记录结果是 [4] 而不是 [4,5]？