库存更新问题

---恢复内容开始---

用对象确实比用数组解决起该问题来方便得多，我一开始也是想的用对象来做，但是不知道怎么把对象转换成数组，而且对于对象的排序简直一筹莫展。实际情况是，名值对的形式非常适合用对象来解决，因为对象就是用名值对来定义的。而排序又是数组的专利，所以这个问题一定是要同时用到两者，那就免不了要在两者中间转换。

首先看如何转换。数组转换成对象，用的是数组的forEach方法，然后一条语句object[name]=value就解决了。

function createObject(array) {
    var obj = {};    // We start off by creating an empty object.
    array.forEach(function(current) {    // We loop over the input array.
        obj[current[1]] = current[0];    // We add properties to the object for each item. E.g.: { 'Computer Screen' : 5 }
    });
    return obj;        // We return the object itself.
}

对象转换成数组也相当简单，用的是for...in语句，然后将每一项push到数组里去。

function createArray(object) {
    var array = [];     // We create an empty array.
    for (var key in object) {               // We loop over each key in the input object.
        array.push([object[key], key]);     // We push each object key name and value to the array.
    }
    return array;   // Finally, we return the array.
}

存货问题的解决逻辑就是两句话：

遍历要添加的目录（为什么不是旧目录呢，因为要添加的目录里的每一项都会被处理而旧目录并非）

1.如果item在当前目录中存在，就把他们的值相加；

2.如果item在当前目录中不存在，就在目录中添加。

用forEach()方法遍历待添加目录的每一项，提取该项的名称用对象的hasOwnProperty()方法检查是否在原目录中存在，再分别处理。

排序与我而言是难点，我想到的是用charCodeAt()之类的方法，但其实就是我所熟知的数组sort()方法。

function compareFunction(a, b) {
  if (a < b) {
    return -1; // a goes before b
  } else if (a > b) {
    return 1; // b goes before a
  } else {
    return 0; // a and b are equal
  }
}

对名称的首字母排序而非其他，代码如下：

    return createArray(currentInventory).sort(function(a, b) {
        if (a[1] < b[1]) return -1;     // If the first item's name is lesser than the second's, we return -1
        if (a[1] > b[1]) return 1;      // In the opposite case, we return 1
        return 0;                       // This case should not happen in this example, but if they were to be equal, we return 0.
    });

最终代码如下：

function inventory(arr1, arr2) {

    if (!Array.isArray(arr1)) {
        return [];
    };

    var currentInventory = createObject(arr1);

    arr2.forEach(function(current) {
        if (currentInventory.hasOwnProperty(current[1])) {
            currentInventory[current[1]] += current[0];
        } else {
            currentInventory[current[1]] = current[0];
        }
    });

    // First, we create the array, we then apply sort.
    return createArray(currentInventory).sort(function(a, b) {
        if (a[1] < b[1]) return -1;     // If the first item's name is lesser than the second's, we return -1
        if (a[1] > b[1]) return 1;      // In the opposite case, we return 1
        return 0;                       // This case should not happen in this example, but if they were to be equal, we return 0.
    });
    
    function createObject(array) {
        var obj = {};
        array.forEach(function(current) {
            obj[current[1]] = current[0];
        });
        return obj;
    }

    function createArray(object) {
        var array = [];
        for (var key in object) {
            array.push([object[key], key]);
        }
        return array;
    }
}

最后附上我个人的烂解法，值得赞扬的地方是基本逻辑是正确的，但没有想到对象和数组各自的优势，也不知道如何转换，排序部分更是没做。

function updateInventory(arr1, arr2) {
    // All inventory must be accounted for or you're fired!
    for(var i = 0; i<arr2.length;i++){
      var inventoryName = arr2[i][1];
      var inventoryNumber = getNumber(inventoryName,arr2);
      if(isExist(inventoryName,arr1)){
        var location = getLocation(inventoryName,arr1);
        arr1[location][0] += inventoryNumber;
      }else{
        arr1.push([inventoryNumber,inventoryName]);
      }
    }
    function getNumber(name,arr){
      for(var i = 0; i<arr.length;i++){
        if(arr[i][1] === name){
          return arr[i][0];
        }
      }
    }
    function isExist(name,arr){
      for(var i = 0; i<arr.length;i++){
        if(arr[i][1] === name){
          return true;
        }
      }
    }
    function getLocation(name,arr){
      for(var i = 0; i<arr.length;i++){
        if(arr[i][1] === name){
          return i;
        }
      }
    }
    return arr1;
}

---恢复内容结束---