字符串
判斷是否存在某字符
判斷是否存在字符有很多方法,這里對常用的進行介紹:
-
includes
:判斷某字符是否存在,返回對應bool值,舉例:
"abc".includes("a")
// true
"abc".includes("d")
// false
-
indexOf
:和includes
不同的是存在的返回索引,不存在的返回-1,舉例:
"abc".indexOf("a")
// 0
"abc".indexOf("d")
// -1
-
lastIndexOf
:和indexOf
不同的是,如果存在多個,則返回最后一個的索引(前者返回第一個的),舉例:
"abca".indexOf("a")
// 返回第一個索引,0
"abca".lastIndexOf("a")
// 返回最后一個索引,3
"abca".lastIndexOf("d")
// 不存在也是-1
查詢字符
索引字符的方法也挺多,可以根據需求選擇,這里介紹常用的幾個:
-
charAt
:根據下標索引查詢,返回對應的字符,舉例:
"abc".charAt(2)
// 返回第二個字符,"c"
"abc".charAt()
// 默認返回第一個字符,"a"
"abc".charAt(3432)
// 不存在返回空字符串,""
-
search
:根據字符返回對應的索引,支持正則,多個數據則值返回第一個的索引,舉例:
"abc123abc".search(/abc/)
// 0
-
match
:和search
類似,但在多個數據時能全返回,還有返回的內容有點不同,舉例:
"abc123abc".match(/abc/)
// 索引返回一個對象,第一個值是對應的字符,后面是索引等,["abc", index: 0, input: "abc123abc", groups: undefined]
"abc123abc".match(/abc/)[0]
// 獲取索引的字符,"abc"
"abc123abc".match(/abc/g)
// 索引多個,["abc", "abc"]
替換字符
可以使用replace
方法替換,舉例:
"abc123abc".replace("123", "456")
// "abc456abc"
"abc123abc".replace("abc", "456")
// 不用正則加g默認只替換第一個,"456123abc"
"abc123abc".replace(/\d/g, "0")
// 支持正則替換,這里替換所有數字,"abc000abc"
判斷開頭/結尾
可以使用startsWith
/endsWith
方法判斷,舉例:
"abc".startsWith('a')
// true
"abc".endsWith('b')
// false
大小寫轉換
可以使用toUpperCase
/toLowerCase
方法轉換,舉例:
"abc".toUpperCase()
// "ABC"
"ABC".toLowerCase()
// "abc"
數值轉換
可以使用parseInt
/parseFloat
將數值內容的字符串轉成原本的數值,舉例:
parseFloat("123")
// 123
截取字符串
可以使用substring
/substr
截取,舉例:
"12345".substr(1, 2)
// 截取第二個到第三個字符,"23"
"12345".substring(1, 3)
// 從第二個字符截取到第四個字符(不包括第四個),"23"
"12345".substr(1)
// 截取第二個及以后的字符,"2345"
去除兩邊空字符
可以使用trim
去除,舉例:
" dasd ".trim()
// "dasd"
字符串/數組互轉
字符串轉數組可以通過split
拆分實現,數組轉字符串可以通過join
拼接實現,舉例:
"12345".split('')
// ["1", "2", "3", "4", "5"]
[1,2,3,4,5].join("")
// "12345"
重復復制
可以使用repeat
方法復制,舉例:
"abc".repeat(3)
// "abcabcabc"
拼接字符串
常見的就是用+
號拼接,這里介紹模板字符串的拼接,通過${變量名}
進行拼接,舉例:
x = "aaa"
`${x}bbb`
// 拼接x和bbb字符,"aaabbb"
注意模板字符串的外面是使用反引號`
而不是單引號
數組
增
常用的方法:
-
push
:往數組的最后增加內容,支持傳一個或多個,舉例:
a = [1,2,3]
a.push(4)
// 加入1個4,變成:[1, 2, 3, 4]
a.push(5,6,7)
// 加入3個數,變成:[1, 2, 3, 4, 5, 6, 7]
-
unshift
:往數組第一個位置插入內容,舉例:
a = [1,2,3]
a.unshift(0)
// [0, 1, 2, 3]
-
splice
:該方法是一個增刪改查都支持的萬能方法,參數說明:第一個參數為起始位置,第二個為從起始位置開始截取的數量,第三個往后都為可選,為從起始位置開始插入的值,舉例:
// 對數組a = [111, 222, 333, 444, 555]分別進行下面操作(每次執行前保證數組為[111, 222, 333, 444, 555]):
a.splice(2, 2)
// 從第三個元素開始截取2個彈出,結果為[333, 444],數組變成:[111, 222, 555]
a.splice(2, 2, "aaa")
// 從第三個元素開始截取2個彈出后,在第三個元素位置插入一個"aaa",結果為[333, 444],數組變成:[111, 222, "aaa", 555]
a.splice(2, 0, "aaa", "bbb")
// 從第三個元素開始截取0個數據彈出,并在該位置插入"aaa"和"bbb",結果為[],數組變成:[111, 222, "aaa", "bbb", 333, 444, 555]
可以看到該方法將會對數組進行截取和插入操作,并返回截取的數組內容
改
可以直接根據索引來修改數組內容:
a = [1,2,3]
a[1] = 5
// a變成:[1, 5, 3]
也可以用前面介紹的splice
方法
查
數組查詢的方法有很多,可以根據需求的不同選擇特定的方法,下面介紹幾個常用的索引方法使用場景:
-
indexof
:根據值來索引下標,存在則返回對應索引,不存在返回-1,舉例:
a = [1,2,3]
a.indexOf(2)
// 返回索引1
a.indexOf(0)
// 不存在,返回-1
-
includes
:索引某個值是否存在于數組,返回一個bool值,舉例:
a = [1,2,3]
a.includes(2)
// true
a.includes(0)
// false
-
find
:返回第一個符合條件的值,舉例:
a = [1,2,3]
a.find(item => item > 2)
// 返回第一個大于2的值,3
-
findIndex
:返回第一個符合條件的值的索引,舉例:
a = [1,2,3]
a.findIndex(item => item > 2)
// 返回第一個大于2的值的索引,2
-
slice
:根據索引返回要查詢的值,可以索引多個,并且可以倒序索引,可以理解為去掉增刪改操作的splice
方法,舉例:
a = [1,2,3]
a.slice(1,3)
// 返回第二個到第三個(返回第一個索引到第二個索引減一的數據),[2, 3]
a
// 可以看到a并沒有改變,[1, 2, 3]
a.slice(-1)
// 索引最后一個,[3]
-
splice
:前面介紹過了,這里不贅述
刪
-
pop
:刪除并返回最后一個值,舉例:
a = [1,2,3]
a.pop()
// 彈出最后一個,3
a
// 可以看到最后一個沒了,[1, 2]
-
shift
:刪除并返回第一個值,舉例:
a = [1,2,3]
a.shift()
// 1
a
// [2, 3]
- 修改
length
屬性:舉例:
a = [1,2,3]
a.length = 2
// 只留前兩個,2
a
// [1, 2]
-
delete
關鍵字:被其刪除的內容都將從內存中被清掉,舉例:
a = [1,2,3]
delete a[0]
// 刪掉第0個,true
a
// 第0個變成空的了,[empty, 2, 3]
delete a
// true
a
// 可以看到a這個數組已經沒了
// VM548:1 Uncaught ReferenceError: a is not defined
// at <anonymous>:1:1
拼接
concat
方法可以將數組拼接在一起,舉例:
a = [1,2,3]
b = [4,5,6]
a.concat(b)
// [1, 2, 3, 4, 5, 6]
合并成字符
join
方法可以將數組按照規定拼成一個字符,舉例:
a = [1,2,3]
a.join("-")
// 用符號'-'將數組內容拼在一起,"1-2-3"
排序
sort()
方法可以完成數組排序功能,舉例:
a = [1,2,3,5,4]
a.sort()
// [1, 2, 3, 4, 5]
要注意的是排序方法默認是按字符順序排序的,如果希望按數字大小排序則需要定義排序規則,舉例:
a = [1,2,3,5,10,4]
a.sort()
// 注意默認不是按數字排序,10被排在了前面,[1, 10, 2, 3, 4, 5]
a.sort((a, b) => a-b)
// 按從小到大排序(a是下一個數,b是當前數,所以a-b就是按下一個數大于當前數方式來排序),[1, 2, 3, 4, 5, 10]
逆序
reverse()
方法可以實現數組逆序(注意這里的逆序是把數組反過來,而不是從大到小的意思),舉例:
a = [1,2,3,5,4]
// [1, 2, 3, 5, 4]
a.reverse()
// 可以看到倒過來了,[4, 5, 3, 2, 1]
遍歷
可以使用for (item in xxx)
遍歷,舉例:
a = [1,2,3]
for (let x in a){console.log(x)}
也可以使用forEach
方法,使用該方法還有第二個參數,為遍歷的索引,舉例:
a = [1,2,3,4,5]
a.forEach((item, index) => {console.log(item, index)})
// 循環輸出:1 0、2 1、...
篩選
filter
方法,舉例:
a = [1,2,3,4,5]
a.filter(item => item%2==0)
// 返回所有偶數,結果為[2, 4]
統一操作
map
方法,舉例:
a = [1,2,3,4,5]
a.map(function(item){return item>=3})
// 統一操作判斷每個數據是否大于等于3,[false, false, true, true, true]
設置統一值
可以使用fill
方法,舉例:
a = [1,2,3,4,5]
a.fill(100)
// 統一設置為100, [100, 100, 100, 100, 100]
一般在需要生成固定長度且值統一的場景下用,舉例:
new Array(10).fill(1)
// 生成10個值都為1的數組, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
連續運算
如階乘、累加等操作,可以使用reduce
方法,舉例:
a = [1,2,3,4,5]
a.reduce(function(tmp, item, index) {
return tmp + item;
// 返回結果為當前數和下一個數的求和
})
// 這里實現了累加,最后的結果為15
總體判斷
可以使用some
/every
方法對數組進行條件判斷,舉例:
a = [1,2,3]
a.some(item=>item>1)
// 數組存在大于1的則返回true,結果:true
a.every(item=>item>1)
// 數組里全部大于1則返回true,結果:false
迭代對象轉數組
使用數組對象Array
下的from
方法可以將一個可迭代對象轉成數組進行操作,舉例:
s = "sdasdasf"
Array.from(s)
// ["s", "d", "a", "s", "d", "a", "s", "f"]
// 字符串被轉成了數組
更多數組方法參考
https://blog.csdn.net/ChauncyWu/article/details/82960898
對象
增
直接插入鍵值即可,舉例:
a = {}
a['x'] = 1
a
// {x: 1}
a.y = 2
// 通過這種方式也可以,但是前者的鍵名可控,這種不可控
a
{x: 1, y: 2}
改
直接根據鍵修改值即可,舉例:
a = {x:1}
a['x'] = 2
// 2
a
// {x: 2}
a.x = 3
// 兩種方式都行
a
// {x: 3}
查
直接根據鍵索引即可,舉例:
a = {x: 1, y: 2}
a['x']
// 1
a.y
// 2
刪
使用delete
關鍵字刪除即可,舉例:
a = {x: 1, y: 2}
delete a.x
// true
a
// {y: 2}
判斷是否存在否個鍵
可以通過in
關鍵字判斷,舉例:
a = {x: 1}
'x' in a
// true
'y' in a
// false
遍歷
可以通過for (key in obj)
遍歷,舉例:
a = {x: 1, y:2}
for (let key in a) { console.log(key, a[key]) }
獲取所有鍵/值
可以使用Object.keys()
/Object.values()
方法,舉例:
a = {x: 1, y:2}
Object.keys(a)
// 獲取所有鍵,["x", "y"]
Object.values(a)
// 獲取所有值,[1, 2]
Object.entries(a)
// 將所有鍵值以數組形式返回,["x", 1], ["y", 2]
Object.entries(a).forEach((item) => {console.log(item)})
// ["x", 1]
// ["y", 2]
解析/轉JSON格式
可以使用JSON.parse
/JSON.stringify
方法,舉例:
a = {x: 1, y:2}
JSON.stringify(a)
// 轉json,"{"x":1,"y":2}"
深拷貝對象
最常用的就是通過轉json拷貝后再轉回對象,舉例:
a = {x: 1, y:2}
b = JSON.parse(JSON.stringify(a))
// 深拷貝對象,{x: 1, y: 2}
a.x = 3
a
// {x: 3, y: 2}
b
// 可以看出b沒有一起發生改變,{x: 1, y: 2}
深拷貝/淺拷貝參考:https://www.cnblogs.com/penghuwan/p/7359026.html
數組/對象解構/ES6新增方法
這里已經介紹了一部分,剩余的可以參考我的另一篇文章:ES6+ 特性整理