常见的数组,字符串 常用方法(自用)

indexOf

• indexOf用来找到数组中某一项的索引
• 语法:indexOf(你要找到的数组中的项)

var arr = [1, 2, 3, 4, 5]

// 使用 indexOf 超找数组中的某一项
var index = arr.indexOf(3)

console.log(index) // 2

• 我们要找的就是数组中值为3的那一项
• 返回的就是值为3的那一项在数组中的索引
• 如果你要找的内容在数组中没有，那么就会返回 -1

var arr = [1, 2, 3, 4, 5]

// 使用 indexOf 超找数组中的某一项
var index = arr.indexOf(10)

console.log(index) // -1

• 你要找的值在数组中不存在，那么就会返回 -1

forEach

• 和 for 循环一个作用，就是用来遍历数组的
• 语法：arr.forEach(function (item, index, arr) {})

var arr = [1, 2, 3]

// 使用 forEach 遍历数组
arr.forEach(function (item, index, arr) {
  // item 就是数组中的每一项
  // index 就是数组的索引
  // arr 就是原始数组
  console.log('数组的第 ' + index + ' 项的值是 ' + item + '，原始数组是', arr)
})

• forEach() 的时候传递的那个函数，会根据数组的长度执行
• 数组的长度是多少，这个函数就会执行多少回
• forEach 接受的参数是一个函数;
• forEach参数函数的调用次数 : 和数组项数一致;

arr.forEach( function( ){
    //数组有多少项，那么这个函数就会被调用多少次; 
    //每次函数调用都对应数组的某一项; 
    console.log( 1 );
})

• 作为遍历方法核心的意义在于去出数组之中所有的数据;

arr.forEach( function( item , index , arr ){
    // 作为参数的函数可以接受一些形参; 
    // 形参是由封装的功能来进行传递的; 
       console.log( item , index , arr );
});

• 实现forEach 的封装 :

function forEach( arr , fn ){
    for(var i = 0 ; i < arr.length ; i ++){
        fn( arr[i] , i , arr );
    }
}
forEach( arr, function( item , index ){
    console.log( item , index );
})

map

• 和 forEach 类似，只不过可以对数组中的每一项进行操作，返回一个新的数组
• 新数组里面承载的数据就是遍历时函数返回的数据：
• map 参数也是一个函数;
• map 参数函数的形参和forEach 一样;

var arr = [1, 2, 3]

// 使用 map 遍历数组
var newArr = arr.map(function (item, index, arr) {
  // item 就是数组中的每一项
  // index 就是数组的索引
  // arr 就是原始数组
  return item + 10
})

console.log(newArr) // [11, 12, 13]

• 封装map

function map( arr , fn ){
      // - map是有返回值的; 
      var res = [];
      for(var i = 0 ; i < arr.length ; i ++){
            var a = fn( arr[i] , i , arr );
            res.push( a );
      }
      return res;
}
var res = map( salary_list , function( item , index ){
      return item * 15 / 10 
}); 

console.log( res );

filter

• 和 map 的使用方式类似，按照我们的条件来筛选数组
• 把原始数组中满足条件的筛选出来，组成一个新的数组返回
• 我们会对数组之中的每一项数据添加一个逻辑，如果函数的返回值为true，那么就把这条数据加入到新数组之中

var arr = [1, 2, 3]

// 使用 filter 过滤数组
var newArr = arr.filter(function (item, index, arr) {
  // item 就是数组中的每一项
  // index 就是数组的索引
  // arr 就是原始数组
  return item > 1
})

console.log(newArr) // [2, 3]

• 我们设置的条件就是 > 1

• 返回的新数组就会是原始数组中所有 > 1 的项

• filter封装:

function filter( arr , fn ){
    var res = [];
    for(var i = 0 ; i < arr.length ; i ++){
    //根据函数的返回值决定是否将这项数据放入到新数组之中; 
        if( fn( arr[i] , i , arr ) ){
           res.push( arr[i] );
        }
    }            
    return res;            
}

reduce

• 归纳,合并,求和;

var arr = [ 1,2,3,4,5,6,7 ];
var res = arr.reduce( function( prev , item , index , arr ){
    // prev : 上一次函数计算的结果; 
    // - 第一次执行时，就是reduce的第二个参数; 
    // console.log( prev );
    return prev + item;
} , 0 );

//redcue 的第二个参数是在第一次调用函数时给函数prev参数赋值的数据; 
console.log( res );
var arr = [ 1,2,3,4,5,6,7 ];
// reduce的第二个参数可以省略 : 
var res = arr.reduce( function( prev , item , index , arr ){
    // prev : 上一次函数计算的结果; 
    // - 第一次执行时，如果reduce没有传递第二个参数，那么prev就是数组的第一项数据; 
    // - 此时item就代表顺延向后的一个数据; 
    return prev + item;
}  );

• reduce 封装 :

function reduce( arr , fn , data ){
    // - 怎么判断传了两个参数还是三个参数; 
    // - arguments : 伪数组; 
    // console.log( arguments );
    // - 可以通过arguments.length 判断参数传入数量； 
    // - 判断data的数据类型 : typeof data === "undefined";

    var has_data_args = typeof data === "undefined"

    // - 1. 获取prev值 : 
    var prev = has_data_args ? arr[0] : data;
    // console.log( prev );

    for(var i = has_data_args ? 1 : 0 ; i < arr.length ; i ++){

        prev = fn( prev , arr[i] , i , arr );
    }

    return prev; 
}

var res = reduce( list , function( prev , item ){
    // console.log( prev );
    return prev + item.price * item.count; 
} , 0)

console.log( res );

字符串的常用方法

• 我们操作字符串，也有一堆的方法来帮助我们操作
• 字符串和数组有一个一样的地方，也是按照索引来排列的

charAt

• charAt(索引) 是找到字符串中指定索引位置的内容返回
• charAt() 和取出运算是一样的功能

var str = 'Jack'

// 使用 charAt 找到字符串中的某一个内容
var index = str.charAt(2)

console.log(index) // c

• 因为字符串也是按照索引进行排列的，也是同样从 0 开始
• 所以索引 2 的位置就是 c
• 如果没有对应的索引，那么就会返回 空字符串

var str = 'Jack'

// 使用 charAt 找到字符串中的某一个内容
var index = str.charAt(10)

console.log(index) // ''

charCodeAt

• charCodeAt(索引)就是返回对应索引位置的unicode编码
• 获取当前字符的十进制unicode编码

var str = 'Jack'

// 使用 charAt 找到字符串中的某一个内容
var index = str.charCodeAt(0)

console.log(index) // 74

• 因为J在unicode对照表中存储是74,索引就会返回74

indexOf

• indexOf就是按照字符找到对应的索引

var str = 'Jack'

// 使用 indexOf 找到对应的索引
var index = str.indexOf('J')

console.log(index) // 0

• 因为字符 J在字符串 Jack 中的索引位置是 0,所以返回0

substring

• substring是用来截取字符串使用的
• 语法： substring(从哪个索引开始，到哪个索引截止)，包含开始索引，不包含结束索引

var str = 'hello'
//         01234

// 使用 substring 截取字符串
var newStr = str.substring(1, 3)

console.log(newStr) // el

• 从索引1开始,到索引3截止,包含前面的索引不包含后面的索引
• 所以返回的是el

substr

• substr也是用来截取字符串的
• 语法:substr(从哪个索引开始,截取多少个)

var str = 'hello'
//         01234

// 使用 substr 截取字符串
var newStr = str.substr(1, 3)

console.log(newStr) // ell

• 这个方法和 substring不一样的是，第二个参数是截取多少个

toLowerCase 和 toUpperCase

• 这两个方法分别使用给字符串转成小写和大写字母的

var str = hello

// 使用 toUpperCase 转换成大写
var upper = str.toUpperCase()

console.log(upper) // HELLO

// 使用 toLowerCase 转换成小写
var lower = upper.toLowerCase()

console.log(lower) // hello