underscore arrays

一、_.first():返回array（數組）的第一個元素。傳遞 n參數將返回數組中從第一個元素開始的n個元素

_.first = _.head = _.take = function(array, n, guard) {
　　//n == null-->array[0];
　　//n != null;guard == ture;-->array[0]
　　//n != null;guard == false;-->返回前n個元素
    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
  };

二、_.initial():返回數組中除了最後一個元素外的其餘所有元素。 在arguments對象上特別有用。傳遞 n參數將從結果中排除從最後一個開始的n個元素

_.initial = function(array, n, guard) {
　　//n == null--1;
　　//n != null;guard == true--1
　　//n != null;guard != true--n
    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
  };

//倒序指定的n個元素
slice.call(array, Math.max(array.length-n, 0));

三、_.last():返回array（數組）的最後一個元素。傳遞 n參數將返回數組中從最後一個元素開始的n個元素，跟first相反

_.last = function(array, n, guard) {
    if ((n != null) && !guard) {
      return slice.call(array, Math.max(array.length - n, 0));
    } else {
      return array[array.length - 1];
    }
  };

四、_.rest():返回數組中除了第一個元素外的其餘所有元素。傳遞 index 參數將返回除了第一個元素到第index元素之外剩餘的全部元素，會輸出index個元素，跟_.initail相反。underscore不一樣版本，會函數的定義都不一樣。

_.rest = _.tail = function(array, index, guard) {
   //guard=true,index無效；slice()輸出包含start 
　　return slice.call(array, (index == null) || guard ? 1 : index);
  };

五、_.compact:返回能被轉爲true的元素　filter返回知足驗證的元素

_.compact = function(array) {
    return _.filter(array, function(value){ return !!value; });
  };

六、_.flatten:多維數組轉爲一維數組　reduce對元素進行迭代，迭代器返回memo，shallow參數用於控制合併深度, 當shallow爲true時, 只合並第一層, 默認進行深層合併

_.flatten = function(array, shallow) {
    return _.reduce(array, function(memo, value) {
      //shallow=true,concat value:連接兩個或多個數組
      if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value));
      //value爲值，數組自增賦值
      memo[memo.length] = value;
      return memo;
    }, []);
  };

七、_.without():返回一個刪除全部values值的 array副本。與_.difference相似；前者的第二參數爲元素，後者的第二參數爲數組

_.without = function(array) {
　　 // slice.call(arguments, 1)返回從第二個開始的全部參數
    return _.difference(array, slice.call(arguments, 1));
  };

八、_.uniq():返回 array去重後的副本, 使用 === 作相等測試.
若是您肯定 array 已經排序, 那麼給 isSorted 參數傳遞 true值, 此函數將運行的更快的算法.

_.uniq = _.unique = function(array, isSorted, iterator) {
    //如何判斷第二個參數是isSorted仍是iterator，先判斷iterator是否存在。
    //若是iterator存在，則會根據它建立一個新的數組，以它作對比
    var initial = iterator ? _.map(array, iterator) : array;
    var results = [];
    //length=2,則必定有序
    if (array.length < 3) isSorted = true;
    //把數組元素歸爲統一的值
    _.reduce(initial, function (memo, value, index) {
      //isSorted=true:當前元素與最後一個元素比較：若是不相等的話，有可能跟以前的元素相等呀（已是有序了，因此相等的都是相鄰的）
      //isSorted=false:使用include來檢查
      if (isSorted ? _.last(memo) !== value || !memo.length : !_.include(memo, value)) {
        //memo存得時iterator的值
        memo.push(value);
        //results存的是array的值
        results.push(array[index]);
      }
      return memo;
    }, []);
    return results;
  };

九、_.union():與uniq方法做用一致, 不一樣之處在於union容許在參數中傳入多個數組

_.union = function() {
    //true：只合並一層
    return _.uniq(_.flatten(arguments, true));
  };

十、_.intersection()：獲取多個數組的交集元素；

_.intersection = _.intersect = function(array) {
    var rest = slice.call(arguments, 1);
    //filter：知足條件的返回
    //先對array去重,uniq只會處理第一個array
    //rest是剩餘的，須要比較的
    return _.filter(_.uniq(array), function(item) {
      return _.every(rest, function(other) {
        return _.indexOf(other, item) >= 0;
      });
    });
  };

十一、_.difference():返回當前數組中與指定數據不相等的差別數據,第二個參數爲array，

_.difference = function(array) {
　　//只合並一層
    var rest = _.flatten(slice.call(arguments, 1), true);
    return _.filter(array, function(value){ return !_.include(rest, value); });
  };

十二、_.zip():將每一個數組的相同位置的數據做爲一個新的二維數組返回, 返回的數組長度以傳入參數中最大的數組長度爲準, 其它數組的空白位置使用undefined填充，zip方法應該包含多個參數, 且每一個參數應該均爲數組

_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]] 

_.zip = function() {
    var args = slice.call(arguments);
    //pluck:獲取對象數組的屬性值
    var length = _.max(_.pluck(args, 'length'));
    var results = new Array(length);
    //arguments都是數組
    for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
    return results;
  }; 

1三、_.indexof():搜索一個元素在數組中首次出現的位置, 若是元素不存在則返回 -1,搜索時使用 === 對元素進行匹配 

_.indexOf = function(array, item, isSorted) {
	if (array == null) return -1;
	var i, l;
	if (isSorted) {
	  i = _.sortedIndex(array, item);
　　　　　　//寫的真好，之後不用if了
	  return array[i] === item ? i : -1;
	}
	if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
	for (i = 0, l = array.length; i < l; i++) if (i in array && array[i] === item) return i;
	return -1;
};

1四、_.lastIndexOf():返回一個元素在數組中最後一次出現的位置, 若是元素不存在則返回 -1,搜索時使用 === 對元素進行匹配,與indexof相反

_.lastIndexOf = function(array, item) {
    if (array == null) return -1;
    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
    var i = array.length;
    while (i--) if (i in array && array[i] === item) return i;
    return -1;
  };

1五、_.range():建立數組，內容爲連續數字

_.range = function(start, stop, step) {
    if (arguments.length <= 1) {
      //若是start=undefined，則stop爲0；若是start不爲undefined，則stop=start
      stop = start || 0;
      start = 0;
    }
    step = arguments[2] || 1;

    var len = Math.max(Math.ceil((stop - start) / step), 0);
    var idx = 0;
    var range = new Array(len);

    while(idx < len) {
      range[idx++] = start;
      start += step;
    }

    return range;
  };