数组跟字符串的操作方法-CSDN博客

本文链接：https://blog.csdn.net/ahhhhhhlzc/article/details/127500338

一：数组的操作方法

1.添加

unshift方法：

-给数组开头添加一个或多个元素，返回一个新数组

语法：数组.unshift(元素，元素...)-返回新数组的长度

示例：

var arr=['a','b','c'];

var l=arr.unshift('d')

console.log(arr);

console.log(l);

var l=arr.unshift('d','e')

console.log(arr);

console.log(l);

给数组末尾添加一个或多个元素

语法：数组.push(元素，元素...)-返回新的数组长度

示例：

var arr=['a','b','c'];

arr.push('d')

var l=arr.push('d','e')

console.log(arr);

console.log(l);

splice方法：

给数组任意一个位置添加1个或多个元素

添加一个元素：

语法：数组.splice(开始下标，删除个数，新元素，新元素...)

示例：

var arr=['a','b','c'];

var brr = arr.splice(1, 0, 'e')

添加多个元素：

var brr = arr.splice(1, 0, 'e', 'f')

2.删除

shift方法：-将数组开头的元素删掉

语法：

数组.shift()-返回被删掉的元素

示例：

var arr = ['a', 'b', 'c'];

var ele=arr.shift()

console.log(arr);

console.log(ele);

pop方法：

将数组最后一个元素删除

语法：数组.pop()-返回被删掉的元素

示例：

var arr=['a','b','c'];

var ele=arr.pop()

console.log(arr);

console.log(ele);

splice方法：

删除一个元素

语法：数组.splice(开始下标，删除个数)-返回所有被删掉元素组成的新数组

示例：

var arr=['a','b','c'];

var brr = arr.splice(1, 1)

console.log(brr)

console.log(arr)

删除多个元素：

语法：

数组.splice(开始下标，删除个数，在删除位置放入一个或多个元素)-返回所有被删掉元素组成的新数组

var brr = arr.splice(1, 2);

console.log(arr);

console.log(brr);

3.修改

splice方法：

修改一个元素：

语法：数组.splice(开始下标，删除个数，新元素，新元素...)返回所有被删掉元素组成的新数组

var arr=['a','b','c'];

var brr=arr.splice(1,1,'e');

修改多个：

var brr=arr.splice(1,2,'e','f');

console.log(arr);

console.log(brr);

数组的其他方法：

排序数组：

sort方法-对数组中的元素进行排序

语法：数组.sort()-注意不是按照数字大小排序的，按照字符串大小进行排序，返回这个数组本身

如果想让数组中元素按数字大小进行排序，并返回这个数组本身，那么：

var arr = [11,5,9,7,3,4,6]

arr.sort(function(a,b){

return a-b

return b-a

})

var brr=arr.sort(function(a,b){

return a-b

return b-a

});

console.log(arr);

console.log(brr);

console.log(arr===brr)

翻转数组：

语法：数组.reverse()-返回当前数组

示例：

var arr=['a','b','c']

var brr = arr.reverse()

console.log(arr);

console.log(brr);

console.log(arr===brr);

拼接成一个字符串的方法：

join方法：-将数组中所有元素通过指定的连接符，拼接成一个字符串

语法：

数组.join(连接符)-返回连接后的字符串

如果省略连接符，默认使用逗号连接

var arr = ['a', 'b', 'c'];

var str = arr.join('') 将所有元素直接拼接在一起

var str = arr.join()

合成一个更大数组的方法：

concat:

语法：数组.concat(1个或多个元素或数组)-返回组合后的更大的数组

示例：

var arr = ['a', 'b'];

var brr = arr.concat('c')

var brr = arr.concat('c', 'd')

var brr = arr.concat(['c', 'd'])

var brr = arr.concat(['c', 'd'], ['e', 'f'])

console.log(brr)

截取数组：

slice:

语法：数组.slice(开始下标，结束下标)-返回被截取出来的一段组成的数组，结果不包含结束下标对应的字符

示例：

var arr = ['a', 'b', 'c', 'd', 'e', 'f']

var brr = arr.slice(2, 5);

var brr = arr.slice(2) 如果省略结束下标，就截取到数组的末尾

var brr = arr.slice() 在省略结束下标的基础上，还可以省略开始下标，从开头截取到末尾

console.log(brr)

console.log(arr)

console.log(arr === brr)

查找该元素在数组中是否存在：

indexOf方法-查找某个元素在数组中第一次出现的下标

语法：

数组.indexOf(元素)-找到元素就返回对应的下标，找不到元素就返回-1 */

var arr=[1,5,6,7,3,2,5,9,1,3,6,8,7]

找1在arr中第一次出现的下标

var index=arr.indexOf(10)

语法：数组.indexOf(元素，开始查找的下标)-找到元素就返回对应的下标，找不到元素返回-1

var index=arr.indexOf(1,2)

console.log(index)

lastIndexOf-查找某个元素在数组中最后一次出现的下标-语法和返回值跟indexOf是一样的

var arr=[1,5,6,7,3,2,5,9,1,3,6,8,7]

var index=arr.lastIndexOf(1)

var index=arr.lastIndexOf(1,5)

console.log(index)

把数组中每个元素都处理成新元素，将所有新元素组成一个新的数组：

语法：

var brr=数组.map(function(value,index){

value表示遍历出来的每个元素

index是每个value对应的下标-可选项

return新元素

})

示例：

有数组[1, 3, 4] - 将每个元素都扩大10倍，形成新的数组

var arr = [1, 3, 4]

var brr = arr.map(function (v) {

var newValue = v * 10

return newValue

})

console.log(brr);

var arr = [{

age: 12

{

age: 15

{

age: 20

}

]

var brr = arr.map(function (v) {

v.age = v.age + 1

console.log(v);

return v

})

console.log(brr);

过滤数组的方法：

filter方法-将数组中满足条件的所有元素组成新的数组返回

语法：

var brr=数组.filter(function(value,index){

value表示遍历出来的每个元素

index是每个value对应的下标//可选项

return 条件

})

var arr = [50,65,88,76,35,24]

var brr = arr.filter(function(v) {

return v < 60

})

console.log(brr);

示例：

var arr = [

{

category: '水果',

{

category: '衣服',

{

category: '肉',

{

category: '水果',

}

]

var brr = arr.filter(function(v) {

return v.category === '水果'

})

console.log(brr);

遍历数组的方法：

forEach方法 - 专业用来遍历数组的

语法：

数组.forEach(function(value, index) {

value表示每个值

index表示每个下标

})

var arr = ['a', 'b', 'c']

arr.forEach(function(v, i) {

if(i === 1) {

break forEach方法中不能使用break和continue关键字

}

console.log(v, i);

})

数组去重：

for循环去重：

for(var a=arr.length-1; a<arr.length; a++) {

if(arr[arr.length-2] === arr[a]) {

arr.splice(a, 1)

a--

}

for(var b=0; b<arr.length-1; b++) {

for(var a=b+1; a<arr.length; a++) {

if(arr[b] === arr[a]) {

arr.splice(a, 1)

a--

}

console.log(arr);

indexOf去重：

将arr中每个元素都判断是否在brr中，如果不在，就放进brr，如果在，就下一个元素判断

for(var a=0; a<arr.length; a++) {

// 判断arr[a]是否在brr中

var index = brr.indexOf(arr[a])

// index>=0正常的下标 - 在brr中

// index == -1 表示不在brr中

if(index < 0) {

brr.push(arr[a])

}

console.log(brr);

对象属性去重：

思路：{}对象中的键 - 唯一的

将数组中每个元素都做为对象的键，最终只会保留一个

var arr = [1, 1, 1, 2, 2, 3, 2, 4, 'a', 'a', 'b']

定义空对象

var obj = {}

遍历数组

for(var a=0; a<arr.length; a++) {

将每个 arr[a] 都作为对象的键

obj.键 = 值 // 使用变量代表键 - 必须使用[]语法

obj[键] = 值

obj[ arr[a] ] = typeof arr[a]

}

console.log(obj);

将对象中的每个键都放在一个数组中

定义空数组

var brr = []

遍历对象

for(var key in obj) {

key是对象的每个键

将每个键都放在数组中

brr.push(+key)

如果原本的值是number类型就转成数字放入brr

brr.push( obj[key] === 'number' ? +key : key )

}

console.log(brr);

set方法去重：

ES6中新增了数据类型set，set的一个最大的特点就是数据不重复。Set函数可以接受一个数组（或类数组对象）作为参数来初始化，利用该特性也能做到给数组去重

function unique(arr) {

if (!Array.isArray(arr)) {

console.log('type error!')

return

}

return [...new Set(arr)]

}

使用 lodash 的 uniq()

_.uniq([2, 1, 2]); => [2, 1]

判断数组中是否至少有一个元素是满足条件的-返回布尔值

语法

布尔值 = 数组.some(function(value, index) {

return 条件

})

示例：

var arr = [10, 20, 30, 50, 40, 80, 99, 100]

var bool = arr.some(function(v) {

return v > 90

})

console.log(bool);

判断数组中是否所有元素都满足指定条件-返回布尔值

语法：

布尔值 = 数组.every(function(value, index) {

return 条件

})

查找数组中第一个满足指定条件的元素：

语法：

元素 = 数组.find(function(value, index) {

return 条件

})

找到了就会返回元素，找不到就返回undefined

查找数组中满足指定条件的第一个元素对应的下标

语法：

下标 = 数组.find(function(value, index) {

return 条件

})

找到了就会返回下标，找不到就返回-1

reduce - 归并数组 - 数组求和

语法：

数组.reduce(function(a, b) {

// reduce遍历数组，会少遍历一次

// a第一次遍历，代表第一个元素，第二次开始，就代表上次遍历return的结果

// b第一次遍历，代表第二个元素，第二次遍历，代表第三个元素，第三次遍历，代表第4个元素...

})

字符串的方法：

charCodeAt - 根据字符串的下标获取到对应的字符的阿斯克码

// 语法：字符串.charCodeAt(下标) - 返回阿斯克码(10进制的数字)

indexOf - 找一个字符或小字符串在大字符串中第一次出现的下标

// 语法：字符串.indexOf(字符/小字符串) - 返回下标或-1

lastIndexOf - 找一个字符或小字符串在大字符串中最后一次出现的下标

// 语法：字符串.lastIndexOf(字符/小字符串) - 返回下标或-1

slice - 截取字符串

// 语法：字符串.slice(开始下标, 结束下标) - 返回截取出来的小字符串

// 结果不包含结束下标对应的字符

split - 将字符串分割成一个数组

// 语法：字符串.split('分割符') - 返回数组

replace - 将字符串中的指定部分替换成新内容

// 语法：字符串.replace('被替换的部分', 新内容) - 返回替换后的完整字符串

trim - 去除字符串两端的空格

// 语法：字符串.trim()

// trimLeft - 去除左边空格

// trimRight - 去除右边空格

toUpperCase - 将字符串中每个字符都转成大写

toLowerCase - 将字符串中所有字符都转成小写

startsWith - 判断字符串是否以某个字符或小字符串开头的

// 语法：字符串.startsWith(字符/小字符串) - 返回布尔值

endsWith - 判断字符串是否以某个字符或小字符串结尾的

语法：字符串.endsWith(字符/小字符串) - 返回布尔值

includes - 判断字符串中是否包含某个字符或小字符串

// 语法：字符串.includes(字符/小字符串) - 返回布尔值

substr - 截取字符串

// 语法：字符串.substr(开始下标, 截取的长度)

substring - 截取字符串

// 语法：字符串.substring(开始下标, 结束下标) - 返回的结果不包含结束下标对应的字符

3个截取字符串方法的区别

// var str = 'i love you'

// slice：可以使用负数来表示下标

// console.log( str.slice(-8, -4) );

// console.log( str.slice(6, 2) ); // 如果开始下标在结束下标右边，就截取到空字符串

// substring：不能使用负数表示下标

// console.log( str.substring(-8, -4) ); // 空字符串

// console.log( str.substring(6, 2) ); // 当开始下标在结束下标的右边，先将两个参数交换位置，然后再截取

// substr：他的开始下标，可以使用负数表示

// console.log( str.substr(-2) );

字符串的比较：

字符串比较的原则：

// 字符串的比较规则：逐字符比较

// 先拿第一个字符出来比较，能决定大小，不继续比了，第一个字符决定了整个字符串的大小

// 第一个字符相等，再拿第二个字符比较 ....

// 计算机显示的每个字符，其实在计算机内部都有对应的二进制指令，所以，每个字符之间有大小关系的

阿斯克码表中规律：

数字0~9对应的阿斯克码：48~57

大写字母A~Z的阿斯克码：65~90

小写字符a~z的阿斯克码：97~122