Question

在这种情况下任何横向解决方案，当我需要知道我在哪个类而不使用bind时。

function Customer() {}
Customer.prototype.say = function() {
    console.log("I'm " + this.constructor.TYPE);
};
Customer.TYPE = 'customer';

function Product() {}
Product.prototype.say = function() {
    console.log("I'm " + this.constructor.TYPE);
};
Product.TYPE = 'product';

var customer = new Customer();
var product = new Product();

//cleaner interface
Promise.resolve()
    .then(customer.say) //I'm undefined
    .then(product.say) //I'm undefined


//works but looking for a solution using cleaner interface like above
//any lateral thinking
Promise.resolve()
    .then(customer.say.bind(customer)) //I'm customer
    .then(product.say.bind(product))  //I'm product

我正在寻找基于非约束的解决方案，任何基于横向思维的想法？

它是我正在开发的SDK，因此希望为客户提供更清晰的界面和用途。

Answer 1

你基本上有三个选择：

bind，您已经说过您不想要。

这样的包装函数：

.then(function(r) { return customer.say(r); })

......在ES2015中看起来像这样：

.then(r => customer.say(r))

更改对象，使它们不再使用从原型继承的函数，而是关闭实例的特定于实例的函数：

在ES5及更早版本中：
```
var Customer = function() {
    var me = this;
    me.say = function() {
        console.log("I'm " + me.constructor.TYPE);
    };
};
```
在ES2015 +
中
```
var Customer = function() {
    this.say = () = {
        console.log("I'm " + this.constructor.TYPE);
    };
};
```
你最终会以这种方式创建更多的函数对象，但函数中的代码将被JavaScript引擎重用。

sa proposal to the TC39 committee that defines JavaScript为运营商做了你想做的事情（基本上bind，但语法更清晰），但它只在第0阶段，因此不太可能在ES2017中。

Answer 2

一些想法：

1）不要使用原型/类。他们会一遍又一遍地制造这类问题。而是使用模块模式。由于“方法”每次都在闭包内部创建，因此它们是有效绑定的：

function Customer() {
    function say() {}

    return {
        type: 'product',
        say
    }
}

2）提供一个构造来构建基于原型的对象层次结构，其中所有方法都是预先绑定的。请注意，这消除了原型的唯一优势：内存消耗略少。

3）冒险并使用babel提供的::符号：然后（:: customer.say）并不是那么好，而且这个命题目前有点陈旧，所以它甚至可能无法正式进入语言。

除了bind之外，还有其他任何解决方案来解决这个问题

2 个答案: