数组封装方法

封装数组的方法

---

pop

1. 封装一个函数，名字叫做 pop
2. pop函数的参数是唯一的数组
3. 调用pop函数，删除数组中最后一个数据
4. 如果这个数组是空，那么调用这个函数，返回值是 undefined
5. 如果不是空数组返回值为被删除的数据

var arr = [1, 2, 3];
function pop(arr){
    if (!arr.length) return;
    var last = arr[arr.length - 1]
    arr.length--
    return last
}
console.log(pop(arr));  // 3
console.log(arr); // [1, 2]

shift

1. 封装一个函数，名字叫做 shift
2. shift函数的参数是唯一的数组
3. 调用shift函数，删除数组中第一个数据
4. 如果这个数组是空，那么调用这个函数，返回值是 undefined
5. 如果不是空数组返回值为被删除的数据

function shift(arr){
      var len = arr.length
      if (!len) return
      var first = arr[0]
      for (var i=0; i<len; i++) {
        arr[i] = arr[i+1]
      }
      arr.length--
      return first
}
    var arr = ['a', 'b', 'c'];
    console.log(shift(arr));  // 'a'
    console.log(arr);  // ['b', 'c']

indexOf

1 封装一个函数叫 indexOf
2.indexOf 函数的第一个参数为要查找的数组，第二个参数为要查找的数据
3.调用这个函数，如果要查找的数据未找到，那么函数的返回值为-1，如果找到那么返回这个数据的位置

function indexOf(arr, item){
      for (var i=0; i<arr.length; i++) {
            if (arr[i] === item) {
              return i
            }
      }
      return -1
}
    var arr = [1, 2, 'a', 6];
    console.log(indexOf(arr, 'a'));  // 2
    console.log(indexOf(arr, 10));  // -1

splice

1.封装一个函数叫做 spliceOne
2.该函数的第一个参数是数组，第二个参数是索引
3.调用这个函数，可以删除这个索引对应的数据
4.如果是空数组，那么返回undefined，否则返回这个被删除的数据

function spliceOne(arr, index){
      var len = arr.length
      if (!len) return
      var target = arr[index]
      for (var i=index,j=i+1; j<len; i++,j++) {
        arr[i] = arr[j]
      }
      arr.length--
      return target
}
    var arr = [1, 2, 3, 6];
    console.log(spliceOne(arr, 2));  // 3
    console.log(arr);  // [1, 2, 6]

join

1. 封装一个函数叫做 join
2. join函数的第一个参数是一个数组，第二个参数是分割符
3. 调用join，那么数组中的每一项就会被指定的分割符链接起来，如果不指定分隔符，默认就是 , 如果分隔符传入的不是一个字符串，那么就返回false
4. 返回值为字符串，原数组不变。

function join(arr, spliter){
      if (typeof spliter === 'undefined') {
        return arr.toString()
      } 
      if (typeof spliter !== 'string') return false
       for (var i=0,str='',len=arr.length; i<len; i++) {
        str += i < len - 1 ? arr[i] + spliter : arr[i]
      }
      
      return str
}
    
    var arr = [1, 2, 3]; 
    console.log(join(arr));  // '1,2,3'
    console.log(join(arr, '')); // '123'
    console.log(join(arr, '--'));  //'1--2--3';
    console.log(join(arr, 123));  // false
    console.log(arr); // [1, 2, 3];

reverse

1. 封装一个函数叫做 reverse
2. 该函数的参数是一个数组
3. 调用这个函数，那么数组将会反转
4. 返回反转后的数组

function reverse(arr){
      var len = arr.length;
      if (len < 2) return arr;  // 长度小于2，那么数组不需要反转
      for(var i=0; i<len; i++) {
        var start = i, end = len - i - 1;
        if (start < end) {
            [arr[start], arr[end]] = [arr[end], arr[start]]
        }
      }
      return arr
}
    var arr = [1, 2, 3];
    console.log(reverse(arr));  // [3, 2, 1]
    console.log(arr);  // [3, 2, 1]

filter

1. 封装一个函数叫做filter
2. 该函数的第一个参数是要过滤的数组，第二个参数是一个函数成为过滤函数
3. 调用这个方法，会对数组进行遍历
4. 每次遍历，都会把数组的当前这项和索引值当作参数传给过滤函数
5. 这个过滤函数的规则一旦符合就返回这个值
6. filter函数最终返回所有符合条件的数据的集合，一个新数组。

function push(arr, ...rest){
      for (var i=0; i<rest.length; i++) {
        arr[arr.length] = rest[i]
      }
      return arr.length;
}
	
 function filter(arr, cb){
  var result = []
  for (var i=0; i<arr.length; i++) {
    // 当前这次循环的值
    var item = arr[i];
    var ret = cb(arr[i], i)
    if (ret) {
      push(result, item)
    }
  }
  return result
}
    
var arr = [11, 4, 7, 12, 17, 9];
var result = filter(arr, function (item, i){
  console.log(i);
  return item > 10;
});

console.log(result);  // [11, 12, 17];

slice

1. 封装一个函数名字叫做 slice
2. 这个函数的参数有3个，第一个是必选的要操作的数组，后面2个可选，第二个是要截取的开始位置，第三个是结束的位置

3.调用这个函数，分为以下几种情况

- 如果只传了这个数组，那么返回这个数组的浅拷贝
- 如果只传了开始位置，那么会一直截取到数组的最后
- 如果开始位置大于数组的长度，那么会返回空数组
- 如果结束位置大于数组的长度，那么结束位置就等于数组的长度
- 如果开始位置大于结束位置，那么返回空数组
- 如果开始位置或者结束位置是一个负数，那么相当于这个负数加上length， 如果相加之后的结果依然是个负数，那么返回空数组
- 例如：var arr = [1, 2, 3, 4] 那么调用 slice(arr, 1, 3)，会截取这个数组 arr 中 从1开始到3结束，不包括结束位置的所有数据，返回值也就是 [2, 3]

function push(arr, ...rest){
        for (var i=0; i<rest.length; i++) {
            arr[arr.length] = rest[i]
        }
        return arr.length;
     }
    
    
    function slice (arr, start, end) {
        var result = [], len = arr.length
        if (typeof start === 'undefined') {
            start = 0
            end = len
        }
      
        if (typeof end === 'undefined' || end > len) end = len
        if (start < 0) start += len
        if (end < 0) end += len
        if (!len || start < 0 || end < 0 || start > end || start > len) return result
        for (var i=start; i<end; i++) {
            push(result, arr[i])
        }
        return result
    }
    
    var arr = [1, 2, 3, 4]
    console.log(slice(arr, -3, -1)); // [2, 3]
    console.log(slice(arr, 1, 3));   // [2, 3]