数组 与 字符串 常用方法

数组常用方法

1、push

将一个或多个元素添加到数组的末尾。

let myArray = [1, 2, 3];
myArray.push(4); // [1, 2, 3, 4]

2、pop

从数组的末尾删除并返回一个元素。

let myArray = [1, 2, 3];
let lastElement = myArray.pop(); // lastElement = 3, myArray = [1, 2]

3、unshift

将一个或多个元素添加到数组的开头

let myArray = [2, 3];
myArray.unshift(1); // [1, 2, 3]

4、shift

从数组的开头删除并返回一个元素。

let myArray = [1, 2, 3];
let firstElement = myArray.shift(); // firstElement = 1, myArray = [2, 3]

5、concat

将两个或多个数组合并成一个新数组。

let array1 = [1, 2];
let array2 = [3, 4];
let newArray = array1.concat(array2); // [1, 2, 3, 4]

6、slice

从数组中提取部分元素并返回一个新数组。

let myArray = [1, 2, 3, 4, 5];
let subArray = myArray.slice(1, 3); // subArray = [2, 3]

7、splice

从数组中添加或删除元素。

let myArray = [1, 2, 3, 4, 5];
myArray.splice(2, 1); // 删除索引为2的元素，myArray = [1, 2, 4, 5]

8、map

对数组中的每个元素执行一个函数并返回一个新数组。

let myArray = [1, 2, 3];
let doubledArray = myArray.map(item => item * 2); // [2, 4, 6]

9、filter

根据条件筛选数组中的元素并返回一个新数组。

let myArray = [1, 2, 3, 4, 5];
let evenNumbers = myArray.filter(item => item % 2 === 0); // [2, 4]

10、reduce

将数组中的元素逐个累积到一个值。

let myArray = [1, 2, 3, 4, 5];
let sum = myArray.reduce((acc, currentValue) => acc + currentValue, 0); // 15

11、forEach

对数组中的每个元素执行一个函数，没有返回值。

let myArray = [1, 2, 3];
myArray.forEach(item => console.log(item)); // 依次输出 1, 2, 3

12、every

检查数组中的所有元素是否满足指定条件。如果所有元素满足条件，返回true，否则返回false。

let myArray = [2, 4, 6, 8];
let isEven = myArray.every(item => item % 2 === 0); // true，因为所有元素都是偶数

13、some

检查数组中是否至少有一个元素满足指定条件。如果至少有一个元素满足条件，返回true，否则返回false。

let myArray = [1, 3, 5, 6];
let hasEven = myArray.some(item => item % 2 === 0); // true，因为有一个元素是偶数

14、find

返回数组中满足指定条件的第一个元素，如果没有找到则返回undefined。

let myArray = [10, 20, 30, 40, 50];
let found = myArray.find(item => item > 25); // found = 30

15、findIndex

返回数组中满足指定条件的第一个元素的索引，如果没有找到则返回-1。

let myArray = [10, 20, 30, 40, 50];
let foundIndex = myArray.findIndex(item => item > 25); // foundIndex = 2

16、reverse

颠倒数组中元素的顺序。

let myArray = [1, 2, 3, 4, 5];
myArray.reverse(); // [5, 4, 3, 2, 1]

17、sort

对数组元素进行排序。

let myArray = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
myArray.sort(); // [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

18、join

将数组中的所有元素连接成一个字符串。

let myArray = ["Hello", "World"];
let joinedString = myArray.join(" "); // "Hello World"

19、indexOf和 lastIndexOf

分别返回元素在数组中第一次出现和最后一次出现的索引，如果没有找到则返回-1。

let myArray = [1, 2, 3, 4, 5, 3];
let firstIndex = myArray.indexOf(3); // firstIndex = 2
let lastIndex = myArray.lastIndexOf(3); // lastIndex = 5

20、includes

判断数组是否包含指定元素，返回 true 或 false。

const numbers = [1, 2, 3, 4, 5];
console.log(numbers.includes(3));  // true
console.log(numbers.includes(6));  // false

字符串常用方法

1、substring

提取字符串的子字符串。

let myString = "Hello, World!";
let subString = myString.substring(0, 5); // subString = "Hello"

2、slice

提取字符串的子字符串，支持负数索引

let myString = "Hello, World!";
let subString = myString.slice(7, 12); // subString = "World"

3、indexOf 和 lastIndexOf

分别返回子字符串在字符串中第一次出现和最后一次出现的索引，如果没有找到则返回-1。

let myString = "Hello, World!";
let firstIndex = myString.indexOf("o"); // firstIndex = 4
let lastIndex = myString.lastIndexOf("o"); // lastIndex = 7

4、toLowerCase 和 toUpperCase

将字符串转换为小写或大写

let myString = "Hello, World!";
let lowerCaseString = myString.toLowerCase(); // lowerCaseString = "hello, world!"
let upperCaseString = myString.toUpperCase(); // upperCaseString = "HELLO, WORLD!"

5、trim

移除字符串两端的空格。

let myString = "   Hello, World!   ";
let trimmedString = myString.trim(); // trimmedString = "Hello, World!"

6、split

将字符串分割成数组。

let myString = "apple,banana,cherry";
let myArray = myString.split(","); // myArray = ["apple", "banana", "cherry"]

7、includes

检查字符串是否包含指定的子字符串，返回布尔值。

let myString = "Hello, World!";
let containsHello = myString.includes("Hello"); // true

Underscore.js

（6）invoke

invoke方法对集合的每个成员执行指定的操作。

_.invoke([[5, 1, 7], [3, 2, 1]], 'sort')
// [[1, 5, 7], [1, 2, 3]]

（7）sortBy

sortBy方法根据处理函数的返回值，返回一个排序后的集合，以升序排列。

_.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });
// [5, 4, 6, 3, 1, 2]

（8）indexBy

indexBy方法返回一个对象，根据指定键名，对集合生成一个索引。

var person = [{name: 'John', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
_.indexBy(person, 'age');
// { "50": {name: 'larry', age: 50},
     "60": {name: 'curly', age: 60} }

集合特征

Underscore.js提供了一系列方法，判断数组元素的特征。这些方法都返回一个布尔值，表示是否满足条件。

（4）sample

sample方法用于从集合中随机取样。

_.sample([1, 2, 3, 4, 5, 6])
// 4

集合过滤

Underscore.js提供了一系列方法，用于过滤数组，找到符合要求的成员。

（1）filter

filter方法依次对集合的每个成员进行某种操作，只返回操作结果为true的成员。

_.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
// [2, 4, 6]

（2）reject

reject方法只返回操作结果为false的成员。

_.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
// [1, 3, 5]

（3）find

find方法依次对集合的每个成员进行某种操作，返回第一个操作结果为true的成员。如果所有成员的操作结果都为false，则返回undefined。

_.find([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
// 2

（4）contains

contains方法表示如果某个值在数组内，则返回true，否则返回false。

_.contains([1, 2, 3], 3);
// true

（7）max，min

max方法返回集合中的最大值。如果提供一个处理函数，则该函数的返回值用作排名标准。

var person = [{name: 'John', age: 40}, 
              {name: 'larry', age: 50}, 
              {name: 'curly', age: 60}];
_.max(person, function(per){ return per.age; });
// {name: 'curly', age: 60};

min方法返回集合中的最小值。如果提供一个处理函数，则该函数的返回值用作排名标准。

var numbers = [10, 5, 100, 2, 1000];
_.min(numbers)
// 2

对象相关方法

（1）toArray

toArray方法将对象转为数组，只包含对象成员的值。典型应用是将对类似数组的对象转为真正的数组。

 _.toArray({a:0,b:1,c:2});
// [0, 1, 2]

（2）pluck

pluck方法将多个对象的某一个属性的值，提取成一个数组。

var person = [{name: 'John', age: 40}, 
              {name: 'larry', age: 50}, 
              {name: 'curly', age: 60}];

_.pluck(person, 'name');
// ["moe", "larry", "curly"]