new Object()与对象字面量表示法的区别及相关实例化概念疑问

Great questions—let's break each of these down clearly, step by step.

1. var abc = {} 是否属于对象？ #

Absolutely yes! This syntax is called object literal notation, and it's one of the most common ways to create plain JavaScript objects. When you write {}, you're directly instantiating a new object that inherits from Object.prototype—just like any other standard JS object. You can add properties, methods, and interact with it exactly as you would with an object created via new Object().

2. var abc = {} 与 var abc = new Object() 的区别 #

While both create objects that inherit from Object.prototype, there are a few key differences:

• Syntax & Convenience: Object literals are far more concise. You can define properties and methods directly when creating the object:

  // 字面量直接初始化属性
  let user = { name: "John", age: 30 };
  // new Object() 需要后续添加属性
  let user2 = new Object();
  user2.name = "John";
  user2.age = 30;
  

• Resistance to Constructor Tampering: If someone (accidentally or intentionally) redefines the Object constructor function, new Object() will use the modified version—but object literals will always create a native Object instance. Here's an example:

  // 篡改Object构造函数
  Object = function() {
    this.customProp = "I'm modified!";
  };
  
  let modifiedObj = new Object();
  console.log(modifiedObj.customProp); // 输出 "I'm modified!"
  
  let normalObj = {};
  console.log(normalObj.customProp); // 输出 undefined，仍是原生Object实例
  

• Performance: Most modern JS engines optimize object literals better. Since the engine can parse the object's structure directly at compile time, it's often slightly faster than calling the Object constructor (though the difference is negligible for most use cases).

3. Scanner scan = new Scanner();（Java）与 var abc = new Object()（JS）是否属于同一概念？ #

At a high level, yes—both are ways to instantiate an object using a constructor. But there are important differences under the hood because Java and JavaScript use different object models:

• Java is a class-based language: Scanner is a class, and new Scanner() creates an instance of that class, following strict class inheritance rules.
• JavaScript is a prototype-based language: Object is a constructor function, and new Object() creates an object that inherits from Object.prototype. JS doesn't have traditional classes (though ES6 introduced class syntax as syntactic sugar over prototypes).

So the core idea—creating an instance via a constructor—is the same, but the underlying mechanisms (class vs. prototype) are distinct.

4. 深入对比 new Object() 和对象字面量表示法的差异 #

To summarize the key points we touched on, plus a few extra details:

• Initialization Flexibility: Object literals let you define nested objects, functions, and computed properties in one go:

  let complexObj = {
    name: "Alice",
    address: { street: "123 Main St" },
    greet: () => console.log("Hi!"),
    [dynamicKey]: "value" // 支持计算属性名
  };
  

  With new Object(), you'd have to set each of these properties individually after creation.
• Readability: Object literals make the object's structure immediately clear to anyone reading the code, whereas new Object() requires extra lines to build out the object.
• Edge Case Behavior: In very old JS environments (pre-ES5), there were tiny differences in how the two approaches handled certain edge cases (like null values in prototypes), but these are irrelevant in modern JS.

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