Sorting and update 2D Dimension Question: 
Compare and update the inventory stored in a 2D array against a second 2D array of a fresh delivery. Update the current existing inventory item quantities (in arr1). If an item cannot be found, add the new item and quantity into the inventory array. The returned inventory array should be in alphabetical order by item.

And my code is: 

function updateInventory(arr1, arr2) {

  var newArr = arr1.concat(arr2);


  for(var i = 0; i&lt;newArr.length; i++){
    for(var j = i+1; j&lt;newArr.length; j++){
      if(newArr[i][1] === newArr[j][1]){
          newArr[i][0] += newArr[j][0];
          var index = newArr.indexOf(newArr[j]);
          newArr.splice(index,1);
      }
    }
  }

  return newArr.sort(function(a,b){
    return (a[1] &lt; b[1] ? -1 : (a[1] &gt; b[1] ? 1 : 0));
  });

}

var curInv = [
  [21, "Bowling Ball"],
  [2, "Dirty Sock"],
  [1, "Hair Pin"],
  [5, "Microphone"]
];

var newInv = [
  [2, "Hair Pin"],
  [3, "Half-Eaten Apple"],
  [67, "Bowling Ball"],
  [7, "Toothpaste"]
];

updateInventory(curInv, newInv);


Output =  [
  [ 88, 'Bowling Ball' ],
  [ 2, 'Dirty Sock' ],
  [ 3, 'Hair Pin' ],
  [ 3, 'Half-Eaten Apple' ],
  [ 5, 'Microphone' ],
  [ 7, 'Toothpaste' ]
];


Can this function be improved?
You could do better on your time complexity. Your current method runs in O(n^2), where n is the length of the concatenated newArr. However, if you sorted arr1 and arr2 first and then merged them, you could reduce the time complexity to O(n*log(n)), where n is the length of the longer of the two arrays:

function compareInventoryItems(a, b) {
  return (a[1] &lt; b[1] ? -1 : (a[1] &gt; b[1] ? 1 : 0));
}

function updateInventory(arr1, arr2) {
  arr1.sort(compareInventoryItems); // O(n*log(n))
  arr2.sort(compareInventoryItems); // O(m*log(m))

  var newArr = [],
    i1 = 0,
    i2 = 0;

  while (i1 &lt; arr1.length &amp;&amp; i2 &lt; arr2.length) { // O(n+m)

    switch (compareInventoryItems(arr1[i1], arr2[i2])) {
      case -1:
        newArr.push(arr1[i1++]);
        break;
      case 1:
        newArr.push(arr2[i2++]);
        break;
      case 0:
        arr1[i1][0] += arr2[i2][0];
        newArr.push(arr1[i1]);
        i1++;
        i2++;
        break;
    }
  }
  while (i1 &lt; arr1.length) {
    newArr.push(arr1[i1++]);
  }
  while (i2 &lt; arr2.length) {
    newArr.push(arr2[i2++]);
  }

  return newArr;
}

// Overall complexity = O(n*log(n)) + O(m*log(m)) + O(n+m) = O(n*log(n))


One problem is that the passed in arrays are mutated. You have this problem in your current solution too when you add the amounts of a matched item. Another issue is that the new array share pointers to the original inventory items. This could result in someone inadvertently mutating the updated inventory when working with the original arrays passed into updateInventory. If any of that's a concern to your project, then you could create copies of the items to avoid them all:

function updateInventory(arr1, arr2) {
  arr1.map((x) =&gt; x.slice(0)).sort(compareInventoryItems); // O(n*log(n))
  arr2.map((x) =&gt; x.slice(0)).sort(compareInventoryItems); // O(m*log(m))
  // ...