字符串位置比较
str.localeCompare(str2)
- 如果str排在str2前面,返回负数
- 如果str排在str2后面,返回正数
- 如果他们位置相同,返回0
字符串常用命令
- includes判断str是否包含,包含返回true,不包含返回false ,includes(str,3),再位置3开始检索
- startsWith(str) :true,包含以字符串str开始
- endswith(str):true,包含以字符串str结尾
- substring(start,end):start与end直间(包含start,不包含end) ,start或end负值代表0
- slice(start,end):start与end之间(不含end),start或end允许负值
- substr(start,length):从start开始获取长为length的字符串 ,允许start为负数
- 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)
- 如果i>0,则与arr[i] 完全相同
- 如果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"] }