JavaScript ES6中如何为Object类添加原型方法及实现实例调用

Got it, let's tackle your two JavaScript questions one by one—super common scenarios when working with objects!

Adding methods to the global Object class is doable, but you have to be careful with prototype pollution. Here's how to go about it:

1. Directly modify Object.prototype (not recommended for production) #

You can attach methods directly to Object.prototype, which makes them available to every single object in your code. But be warned: this can cause conflicts with other libraries or built-in methods, and will show up in for...in loops unless you mark them as non-enumerable.

// Add a method to log the object
Object.prototype.log = function() {
  console.log('Current object:', this);
};

// Use it on any object
const myObj = { foo: 'bar' };
myObj.log(); // Logs: Current object: { foo: 'bar' }

2. Use Symbols to avoid enumeration issues #

If you must add a prototype method, using a Symbol as the method name prevents it from showing up in for...in loops or Object.keys() calls:

const logSymbol = Symbol('log');
Object.prototype[logSymbol] = function() {
  console.log('Current object:', this);
};

// Call it using the symbol
myObj[logSymbol](); // Works, no enumeration problems

3. Prefer static methods (for non-instance use) #

If you don't need the method to be callable on object instances, add it as a static method to Object instead:

Object.log = function(obj) {
  console.log('Object:', obj);
};

// Use it like this
Object.log(myObj); // Logs: Object: { foo: 'bar' }

Your user object is a plain JavaScript object right now, so its prototype is Object.prototype. Instead of polluting the global object prototype, we should create a custom prototype just for user objects. Here are two clean ways to do this:

1. Use a constructor function (best for multiple user instances) #

If you plan to create multiple user objects, define a constructor and attach the method to its prototype. All instances will inherit the method:

// Define a User constructor
function User(name, gender) {
  this.name = name;
  this.gender = gender;
}

// Add the isMale method to the prototype
User.prototype.isMale = function() {
  return this.gender === 'male';
};

// Create your user instance
const user = new User("Carlos", "male");
console.log(user.isMale()); // Returns true

2. Modify the prototype of an existing object (one-off use) #

If you already have the user object and don't want to recreate it, you can set a custom prototype for it using Object.setPrototypeOf:

const user = { name: "Carlos", gender: "male" };

// Create a custom prototype with the isMale method
const userPrototype = {
  isMale() {
    return this.gender === 'male';
  }
};

// Assign the custom prototype to the user object
Object.setPrototypeOf(user, userPrototype);

// Now you can call the method directly
console.log(user.isMale()); // Returns true

Alternatively, use Object.create to build a new object with the custom prototype and your existing properties:

const user = Object.create(userPrototype, {
  name: { value: "Carlos", enumerable: true },
  gender: { value: "male", enumerable: true }
});

Important note: Never add isMale to Object.prototype here—every object (like {} or [1,2,3]) would get the isMale method, which is totally unnecessary and messy.

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