javascript - 在 Javascript 中传递对象的实例

Question

这是我正在尝试做的。我正在尝试将一个订单实例传递给账单，它会被编入索引。问题是它不起作用。

我是不是把 JS 拉得太细了？

有关如何执行此操作的任何示例或一些阅读 Material ？

编辑:也许我应该补充一点，这应该是 POS(销售点)系统的用户界面。它应该接受产品的订单(每一个都有可变数量)，并在客户端处理账单中的小计、总计和项目数量。

EDIT2:母语不是英语。也许我选择的名称不是最适合问题的。

function Bill (prefix,maxForms,minForms) {         
     this.prefix = prefix;
     this.maxForms = maxForms;
     this.minForms = minForms;
     this.items = [];
     this.total = 0;

     this.addOrder = function(order) {
         if (this.items.length == 0)
         {
             this.items.push(order);
         }
         for (i=0;i<this.items.length;i++){
             if (this.items[i].name === order.name) {
                 this.items[i].quantity = order.quantity;
                 this.items[i].price = order.price;
             }
             else {
                 this.items.push(order);
             }
             this.total = this.total + order.getSubTotal();
         }
     }
 }



 function Order (name,price,quantity) {

     this.name = name;
     this.price = price;
     this.quantity = quantity;

     this.getSubtotal = function () {
         return this.price*this.quantity;
     }
     this.changeQuantity = function (newQuantity) {
         this.quantity = newQuantity;
     }
     this.incrementQuantity = function () {
         this.quantity = this.quantity + 1;
     }
 }

Answer 1

这里有一个问题:

for (i = 0;/*...*/)

我建议你多花点时间在 JS 上。
它看起来确实很像 C/Java/C#/PHP 等...

然而，问题在于 JS 没有任何 block 作用域*的概念。

* 直到 ES6，即

它只处理函数范围。

也就是说，变量在定义它的整个函数中具有相同的引用(通过 var )。

如果一个变量没有通过var定义，该函数向上到其父级以查找变量的值，然后从那里向上，从那里向上，直到它命中 window.<varname>。 .

您实际上可能正在修改 window.i在你类(class)的实例中。

function Bill ( ) {
    var bill = this,
        i = 0;

    for (i=0; /* ... */) { /*...*/ }
}

也就是说，您可能会花时间了解 JS。
你写的大部分内容看起来都非常好，用英语也是如此。

我可能会进一步分解它:

function Bill () {
    var bill = this;
    extend(bill, {
        total : 0,
        items : [],
        addOrder : function (order) {
            var match = bill.findOrder(order.name);
            if (!match) { bill.items.push(order);  }
            else { bill.updateOrder(match, order); }
            bill.updateTotal();
        },
        findOrder : function (name) {
            var matches = bill.items.filter(function (order) {
                return order.name === name;
            });
            return matches[0];
        },
        updateOrder : function (current, updated) {
            /* I don't know if you want to replace the old order, or add to it...  */
            /* so I'm "replacing" it, instead of increasing quantity, like you did */
            current.quantity = updated.quantity;
            current.price    = updated.price;
        },
        updateTotal : function () {
            bill.total = bill.items
                .map(function (order) { return order.getSubtotal(); })
                .reduce(function (tally, price) { return tally + price; }, 0);
        }
    });
}

var bill = new Bill();
bill.addOrder(new Order(/*...*/));

我在这里做了一些不同的事情。
首先，extend 不是一个“内置”函数；在各种库中有很多实现，但基本上，它只是让我免于编写 bill.x = x; bill.y = y; bill.z = z;... ，并改用一个对象。

接下来，我使用 var bill = this;
和 bill.method = function () { bill.total = /*...*/; };
而不是 this.method = function () { }; ，因为一旦你向下两层，在函数中，this不再意味着您认为的对象。

this.method = function () {
    this.async(function (response) {
        // unless you change it yourself, `this` probably means `window`
        this.value = response; // oops
    });
};

// instead, try
var thing = this;
thing.method = function () {
    thing.async(function (response) {
        thing.value = response;
    });
};

当然，你总是可以混合搭配，只要你知道你能走多远(一级)...
...但这意味着您真的非常需要关心使用 this很多。

var thing = this;
this.method = function () {
    this.async(function (val) {
        thing.value = val;
    });
};

比仅通过变量引用实例更令人困惑，而不是将两者结合起来。

有很多方法可以做到这一点；有些看起来非常像类，有些可能是 100% 功能性，而在 ES6 中，您可能只是完全使用类。

但是有一些想法，以及这样做背后的一些原因(特别是如果您不知道 JS 与其他 C 外观语言的区别在哪里)。

我认为您根本没有将 JS 拉伸(stretch)得太细。