ES6中解构赋值与对象属性访问的差异及优劣对比

Part 1: var bmw = cars.bmw vs var {bmw} = cars #

First off, in your simple example both lines do the exact same thing—they assign the value of cars.bmw to a variable named bmw. But there are key differences when you look beyond single-property extraction:

Key Differences #

• Syntax for multiple properties: If you needed to grab both bmw and benz from cars, destructuring shines. Instead of writing:

  var bmw = cars.bmw;
  var benz = cars.benz;
  

  You can do this in one line:

  var {bmw, benz} = cars;
  

  Way cleaner, right?

• Variable renaming: Destructuring lets you rename variables on the fly. For example, if you want the variable to be myBmw instead of bmw:

  var {bmw: myBmw} = cars; // myBmw = "M3"
  

  With regular access, you'd write var myBmw = cars.bmw which works, but the destructuring syntax makes the intent more explicit.

• Default values: Destructuring supports default values directly, which is handy if the property might be missing or undefined:

  var {bmw = "3 Series"} = { benz: "c250" }; // bmw = "3 Series"
  

  With regular access, you'd have to do something like var bmw = cars.bmw || "3 Series", which can have edge cases (like if cars.bmw is 0 or false, it'll fall back to the default even though the property exists).

• Nested objects: Destructuring simplifies extracting properties from nested objects. For example:

  var garage = { cars: { bmw: "M3", benz: "c250" } };
  var { cars: { bmw } } = garage; // bmw = "M3"
  

  Without destructuring, you'd write var bmw = garage.cars.bmw—not bad for one level, but gets messy with deeper nesting.

Which is Better? #

It depends on your use case:

• If you're only extracting a single property, both are valid. Destructuring is more modern and aligns with ES6+ best practices, while regular access is more familiar to older JS codebases.
• For multiple properties, nested objects, or when you need defaults/renaming, destructuring is absolutely the better choice—it's more concise and readable.

Part 2: Node.js Require Syntax Equivalence #

Let's tackle this one directly: var {ObjectId} = require('mongodb') is equivalent to var ObjectId = require('mongodb').ObjectId—but only if the mongodb module exports an object with a property named ObjectId.

Wait, you wrote ObjectID (capital D) in the second line—note that property names are case-sensitive in JavaScript! If the mongodb module exports ObjectId (lowercase d, which is the actual case in the official MongoDB Node.js driver), then var ObjectId = require('mongodb').ObjectID would give you undefined (since that property doesn't exist). But assuming that's a typo, the destructuring syntax is just a shorthand for extracting that property from the module's export object.

In short: When you use destructuring with require, you're just pulling the named property directly from the object returned by require(), which is exactly what the dot notation does. They're functionally identical when the property names match.

内容的提问来源于stack exchange，提问作者RaxPat