JavaScript

字符串位置比较

str.localeCompare(str2)

• 如果str排在str2前面，返回负数
• 如果str排在str2后面，返回正数
• 如果他们位置相同，返回0

字符串常用命令

1. includes判断str是否包含，包含返回true，不包含返回false ，includes(str,3),再位置3开始检索
2. startsWith(str) ：true，包含以字符串str开始
3. endswith(str）：true，包含以字符串str结尾
4. substring(start,end）：start与end直间(包含start，不包含end) ，start或end负值代表0
5. slice(start,end)：start与end之间（不含end），start或end允许负值
6. substr(start,length)：从start开始获取长为length的字符串  ，允许start为负数
7. str.indexOf(substr，pos）：0：字符串存在，1：字符串位置，-1：字符串不存在，pos指定检索位置， 查询字符串下一个（pos指第几个）存在的位置

注意：substr仅限于在浏览器中使用，相较于其他slice稍微灵活些，推荐常用slice

• toLowerCase()：大写变小写
• toUpperCase：小写变大写
• str.codePointAt(pos)：查找字符再UTF-16编码中的位置

如：alert("z".codePointAt(0));    //122

        alert("Z".codePointAt(0));    //90

• String.fromCodePoint(code)  通过数字code创建字符

如：alert(String.fromCodePoint(90))     //Z

• at：获取最后一个元素,arr.at(i)

1. 如果i>0，则与arr[i] 完全相同
2. 如果i为负数，则从数组的尾部向前数

如：let fruits = ["Apple", "Orange", "Plum"];

       alert(fruits.at(-1)） ===fruits[fruits.length-1]         //Plum    

pop/push，Shift/unshif

• push：在末端添加一个元素，支出一次添加多个元素
• shift：取出队列首端的一个元素，整个队列前移，并返回第一个取出的元素
• unshift：再数组首端添加元素，支出一次添加多个元素
• pop：在末端取出一个元素

如：一次添加多个元素：

                let fruits = ["Apple"];

                fruits.push("Orange", "Peach");

                fruits.unshift("Pineapple", "Lemon");

                 alert( fruits );             // ["Pineapple", "Lemon", "Apple", "Orange", "Peach"]

                

注：arr.pop()和arr.at(-1)都是返回最后一个元素，pop同时也删除了最后一个元素，改变原数组

splice

• arr.splice(start,deleteLength)：删除，返回已删除
• arr.splice(start,deleteLength,insert,insert) ：删除并插入字符串替换，返回已删除，如果deleteLength为0时，则不删除，从start索引开始插入数据，数组后字符串位置后

如：let arr=['I',"go","home"]

delete arr[1]    //reomove go
alert(arr.length)    //3

delete删除不会改变数组长度
  
arr.splice(1,1) //从索引是1，删除1个元素
alert(arr)    //["I","home"]

<!-----删除并插入----->
arr.splice(1,1,'hello','house')
alert(arr)     //['I','hello','house','home']

arr.splice(2,0,"complex","add")   //['I','go','complex','add','home']

Concat：arr.concat创建新数组，包含来自于其他数组和其他项的值

注：是复制数组并新添加元素，返回新组合数组，不会改变原有数组

let arr=[1,2]
arr.concat([3,4])  //[1,2,3,4]

arr.concat('a') //[1,2,'a']



let arr = [1, 2];

let arrayLike = {
  0: "something",
  length: 1
};

alert( arr.concat(arrayLike) ); // 1,2,[object Object]

注：如果数组对象有Symbol.isConcaSpareadable，那么它会被concat作为一个数组来处理，
    否则作为对象处理，如上图例子

let arr = [1, 2];

let arrayLike = {
  0: "something",
  1: "else",
  [Symbol.isConcatSpreadable]: true,
  length: 2
};

alert( arr.concat(arrayLike) ); // 1,2,something,else

indexOf，lastIndexOf，includes

方法与字符串操作具有相同的语法，并且作用基本上也与字符串的方法相同，只不过这里是对数组元素而不是字符进行操作：

• arr.indexOf(item, from) 从索引 from 开始搜索 item，如果找到则返回索引，否则返回 -1。
• arr.lastIndexOf(item, from) —— 和上面相同，只是从右向左搜索。
• arr.includes(item, from) —— 从索引 from 开始搜索 item，如果找到则返回 true（译注：如果没找到，则返回 false）。

let arr = [1, 0, false];

alert( arr.indexOf(0) ); // 1
alert( arr.indexOf(false) ); // 2
alert( arr.indexOf(null) ); // -1

alert( arr.includes(1) ); // true

find/findIndex

let result = arr.find(function(item, index, array) {
  // 如果返回 true，则返回 item 并停止迭代
  // 对于假值（false）的情况，则返回 undefined
});

依次对数组中的每个元素调用该函数：

• item 是元素。
• index 是它的索引。
• array 是数组本身。

如果它返回 true，则搜索停止，并返回 item。如果没有搜索到，则返回 undefined。

例如，我们有一个存储用户的数组，每个用户都有 id 和 name 字段。让我们找到 id == 1 的那个用户：

let users = [
  {id: 1, name: "John"},
  {id: 2, name: "Pete"},
  {id: 3, name: "Mary"}
];

let user = users.find(item => item.id == 1);

alert(user.name); // John

注意在这个例子中，我们传给了 find 一个单参数函数 item => item.id == 1。这很典型，并且 find 方法的其他参数很少使用。

arr.findIndex 方法（与 arr.find 方法）基本上是一样的，但它返回找到元素的索引，而不是元素本身。并且在未找到任何内容时返回 -1。

filter

find 方法搜索的是使函数返回 true 的第一个（单个）元素。

如果需要匹配的有很多，我们可以使用 arr.filter(fn)。

语法与 find 大致相同，但是 filter 返回的是所有匹配元素组成的数组：

let results = arr.filter(function(item, index, array) { 

// 如果 true item 被 push 到 results，迭代继续 
// 如果什么都没找到，则返回空数组

 });



如：
let users = [
  {id: 1, name: "John"},
  {id: 2, name: "Pete"},
  {id: 3, name: "Mary"}
];

// 返回前两个用户的数组
let someUsers = users.filter(item => item.id < 3);

alert(someUsers.length); // 2

map

它对数组的每个元素都调用函数，并返回结果数组，返回的是每个item的集合。

let result = arr.map(function(item, index, array) {
  // 返回新值而不是当前元素
})

例如，在这里我们将每个元素转换为它的字符串长度：

let lengths = ["Bilbo", "Gandalf", "Nazgul"].map(item => item.length);
alert(lengths); // 5,7,6

sort(fn)

arr.sort 方法对数组进行 原位（in-place） 排序，更改元素的顺序。(译注：原位是指在此数组内，而非生成一个新数组。)

它还返回排序后的数组，但是返回值通常会被忽略，因为修改了 arr 本身。

arr.sort(fn) 方法实现了通用的排序算法。我们不需要关心它的内部工作原理（大多数情况下都是
经过快速排序 或 Timsort 算法优化的）。它将遍历数组，使用提供的函数比较其元素并对其重新
排序，我们所需要的就是提供执行比较的函数 fn。

顺便说一句，如果我们想知道要比较哪些元素 —— 那么什么都不会阻止 alert 它们：

[1, -2, 15, 2, 0, 8].sort(function(a, b) {
  alert( a + " <> " + b );
  return a - b;
});

比较函数可以返回任何数字---------------------数字排序
let arr = [ 1, 2, 15 ];

arr.sort(function(a, b) { return a - b; });------升序
arr.sort(function(a, b) { return b-a; });---------降序

alert(arr);  // 1, 2, 15

或者使用剪头函数
let arr=[ 1, 2, 15 ];
arr.sort((a,b)=>a-b)


使用 localeCompare for strings    比较字符串-----------
let countries = ['Österreich', 'Andorra', 'Vietnam'];

alert( countries.sort( (a, b) => a > b ? 1 : -1) );
 // Andorra, Vietnam, Österreich（错的）

alert( countries.sort( (a, b) => a.localeCompare(b) ) );
 // Andorra,Österreich,Vietnam（对的！）

reverse

arr.reverse 方法用于颠倒 arr 中元素的顺序。

let arr=[10,6,8,5,2,9]

arr.reverse()
alert( arr ); //[9, 2, 5, 8, 6, 10]

let arr=[10,9,8,7]
arr.reverse()
alert(arr) //[7,8,9,10]

字符串转换数字

• isFinite(value)：参数转换数字，被验证是否是数字

如：alert(isFinite('15'))      //true

        alert(isFinite(‘str’))         //false

• +/Number：转换数字

如：+str：str转换数字

Array.from：可接收可迭代类和数组，从而获取一个真正的数组

let arrayLike = { // 有索引和 length 属性 => 类数组对象
  0: "Hello",
  1: "World",
  length: 2
};

// Error (no Symbol.iterator)
for (let item of arrayLike) {}

let arr = Array.from(arrayLike); // (*)
alert(arr.pop()); // World（pop 方法有效）

如果用对象转换数组时，必须要有数组和length，没有length，返回[]

循环

• for循环  ： — 运行得最快，可兼容旧版本浏览器

如：let arr = ["Apple", "Orange", "Pear"];

        for (let i = 0; i < arr.length; i++)

         {   alert( arr[i] );  }

• for....of： 现代语法，只能访问 items

如：

         let fruits = ["Apple", "Orange", "Plum"];

         // 遍历数组元素

          for (let fruit of fruits)

          { alert( fruit ); }

• for.....in：永远不要用这个

如：

     let arr = ["Apple", "Orange", "Pear"];

      for (let key in arr)

      { alert( arr[key] );     // Apple, Orange, Pear }

注：for....in  不适用数组，耗内存

Map

• new Map-----------创建map
• map.set(key，value)--------根据键存储值
• map.get(key)------根据键来返回值，如果map中不存在对应的key,则返回undefined
• map.has(key)----如果key存在则返回true,否则返回false
• map.delete(key)------删除指定键的值
• map.clear()-------------清空map
• map.size()------------返回当前元素个数

let map = new Map();

map.set('1', 'str1');   // 字符串键
map.set(1, 'num1');     // 数字键
map.set(true, 'bool1'); // 布尔值键

// 还记得普通的 Object 吗? 它会将键转化为字符串
// Map 则会保留键的类型，所以下面这两个结果不同：
alert( map.get(1)   ); // 'num1'
alert( map.get('1') ); // 'str1'

alert( map.size ); // 3



map还可以使用对象作为键名，在 Object 中，我们则无法使用对象作为键。在 Object 中使用字符串作为键是可以的，但我们无法使用另一个 Object 作为 Object 中的键。-----------------
let john = { name: "John" };

// 存储每个用户的来访次数
let visitsCountMap = new Map();

// john 是 Map 中的键
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Map迭代

• map.keys()---------------------遍历并返回一个包含所有键的可迭代对象
• map.values()--------------------遍历并返回一个包含所有值的可迭代对象
• map.entries()---------------------遍历并返回一个包含所有实体[key,value]可迭代对象，for...of默认情况下就是这个

let recipeMap = new Map([
  ['cucumber', 500],
  ['tomatoes', 350],
  ['onion',    50]
]);

// 遍历所有的键（vegetables）
for (let vegetable of recipeMap.keys()) {
  alert(vegetable); // cucumber, tomatoes, onion
}

// 遍历所有的值（amounts）
for (let amount of recipeMap.values()) {
  alert(amount); // 500, 350, 50
}

// 遍历所有的实体 [key, value]
for (let entry of recipeMap) { // 与 recipeMap.entries() 相同
  alert(entry); // cucumber,500 (and so on)
}

set迭代

let set=new Set(["oranges","apples","bananas"])

for(let value of set)
{
   alert(value)
}

set.foreach((value,valueAgain,set)=>{
alert(value)
})

• new Set([iterable]) —— 创建 set，可选择带有 iterable（例如数组）来进行初始化。
• set.add(value) —— 添加一个值（如果 value 存在则不做任何修改），返回 set 本身。
• set.delete(value) —— 删除值，如果 value 在这个方法调用的时候存在则返回 true ，否则返回 false。
• set.has(value) —— 如果 value 在 set 中，返回 true，否则返回 false。
• set.clear() —— 清空 set。
• set.size —— 元素的个数。

对象遍历

• Object.keys(user) = ["name", "age"]
• Object.values(user) = ["John", 30]
• Object.entries(user) = [ ["name","John"], ["age",30] ]

let user={
name:'John',
age:30
}

//遍历所有值
for(let value of Object.values(user)){
  console.info(value)    //John,30
}

//遍历key
for(let value of Ojbect.keys(user)){
  console.info(value)    //name,age
}
//遍历key和值
for(let value of Ojbect.entries(user)){
  console.info(value)   //["name","john"],["age","30"]
}