数组的定义
数组是一个有序的值列表。 数组中每个值叫做元素,每个元素在数组中都有一个唯一的位置。位置用数字表示叫做 (索引)或者 (下标)
下标是从 0开始数的
数组是指一组数据的有序集合
数组的类型
声明后直接赋值
let arr = ['1' , 'b' , 3];
构造函数方式赋值
let arr = new Array( '1' , '2' , b)
访问一个数组里面不存在的东西得到的会是一个undefined
数组的长度 .length
使用arr.length 查看数组的长度
使用arr.length = 0 可清空数组 空数组
删除数组元素
const arr = ['a ' ,'v ' ,'c']
delete arr [1]; //删除数组中下标为1的元素 delete 会占位
log(arr); //['a',empty,'c']
delete // remove
简单值与复杂值的比较
按值比较和按址比较的区别
简单值存储于栈区 (stack)
简单值的比较 比较的是值 也就是说值相等 则两个变量就相等
复杂值存储于堆区 (heap)
复杂值的比较 比较地址,如果地址相等才相等
遍历数组
for 遍历数组
const arr =[ 1,2,3];
for(let i=0; i< arr.length; i++){
log(arr[i]);
}
下标是从0开始数 所以会比长度少一个
for of 遍历元素
const arr = [1,2,3];
for(let item of arr ){
log(item);
}
for in 遍历下标
let arr1 = [1,2,3]
for (const index in arr1) {
console.log(index)
}
forEach()
arr1.forEach(function (item,index) {
});
数组的方法
栈方法push()和pop()
push 在末尾添加
let arr = [1,2,3];
arr.push(4,5) // 添加的过程
log(arr) // push是往数组的最后位置上加 得到结果 arr = [1,2,3,4,5]
pop 删除并返回末尾项
let arr = [1,2,3];
arr.push() // 删除的过程
log(arr) // pop是删掉最后一项 arr = [1,2]
队列方法shift()和unshift()
shift()删除第一项
let arr = [1,2,3];
arr.shift() // 删除的过程
log(arr) // shift是删掉第一项 arr = [2,3]
unshift()从第一项开始添加
let arr = [1,2,3];
arr.unshift(1,2) // 添加的过程
log(arr) // unshift是从第一项开始添加 arr = [1,2,1,2,3]
截取 slice()
基于当前数组中的一个或多个项目创建一个新数组
表达式
arr . slice(startindex, endindex) // 第一个值表示 开始下标 第二个值表示结束下标
一个参数时
let arr = [1,2,3,true,4]
let result = arr.slice(2) //一个参数时,从参数位置开始截取到最后一项
log(result); // [3,true , 4]
两个参数时
let arr = [1,2,3,true,4]
let result = arr.slice(2,4) //两个参数时,从参数位置开始截取到第二个参数下标-1
log(result); // [3,true ]
剪接 splice()
arr.splice(starindex,deleteindex,additem1,additem2)
1、增(插入元素)
let arr = [1,2,3,true,4]
arr.splice(1,0,'a','b') //从下标1开始删除0个 插入a b
console.log(arr); //[ 2, 'a', 'b', 3, true, 4 ]
2、删 (删除元素)
let arr = [1,2,3,true,4]
arr.splice(0,1);// 从下标0开始删除1个元素
console.log(arr);// 2,3,true,4
3、改(替换元素)
let arr= [1,2,3]
arr.splice(1,1,a) // 从下标1开始删除1个元素 再插入一个元素等于替换
log(arr)
排序方法 reverse() 和 sort()
reverse() 反转数组内容
let arr =[2,1,3]
arr.reverse();
console.log(arr) 3,1,2
// 将数组倒着来
sort()
let arr = [2,1,3]
arr.sort((a,b) => a-b); //升序 从小到大
arr.sort((a,b) => b-a); //降序 从大到小
连接方法concat()
拼接多个数组
let arr1 =[1,2,3]
let arr2 = [ 3,2,1]
let arr3 = [1,3,2]
let arr4 = arr1.concat(arr1,arr2,arr3);//方法展示
console.log(arr4) // arr4=[
1, 2, 3, 1, 2,
3, 3, 2, 1, 1,
3, 2
]
原数组上加
let arr1 =[1,2,3]
let arr2 = [ 3,2,1]
let arr3 = arr1.concat('a','b','c');//方法展示
log(arr3) // [1,2,3,'a','b','c']
数组的拷贝
let arr1 =[1,2,3]
let arr2 = arr1.concat()// arr2 形成一个新数组
log(arr1 == arr2) // false 复杂类型 在堆里 地址 不同
位置方法indexOf() 和lastIndexOf()
从数组头部或末尾开始查找指定元素,返回元素在数组的下标, 查找不到则返回 -1 进行全等比较
let arr = ['a','b','c','d','e','c']
log(arr.indexOf('c')) // 返回下标 2 从头部开始找
log(arr.lastIndexOf('c')) // 返回下标5 从末尾开始找
数组转字符串 join()
join()接受一个参数:字符串的分隔符,将数组中每个元素取出来拼接成一个字符串,返回结果
let arr= [1,2,3,4,5]
log(arr.join('、')) // 1、2、3、4、5
let str = arr.join('-')
log (str) // 1-2-3-4-5
let str1 =arr.join('')
log(str1) // 12345
字符串转数组 split()
split()接收一个参数:指定的分隔符,转出的数组中不会包含分隔符
let str = 'hello world'
log(srt.split('')); [ 'hello','world']
log(str.splot('o')) ['hell','w','rld']
//空格也算到长度里了
查找方法 includes()
includes()接收一个参数: 元素,返回布尔值 进行全等匹配
let arr =[1,2,3]
log(arr.includes('1')); //false
log(arr.includes(1)); //true
map() 遍历 数组并操作数组元素 返回新的数组
let arr =[1,2,3,4,5];
let newArr= arr.map(function(item,index){
return item*2;
});
log(newArr);//输出新数组 newArr[2,4,6,8,10]
//若此处部写*2
//就是遍历数组并传给新数组
筛选filter() 筛选后为true值 回忽略掉undefined的值
let arr =[10,12,13,15,16];
let newArr = arr.fliter(function(item,index){
return item % 2 === 0;
});
log(newArr);//输出为[10,12,16]
some( ) 和 every() 遍历之后返回值时boolean值 表判断
let arr =[10,12,13,15,16];
let results = arr.some(function(item,index){
return item % 2 === 0;
});
log(reaults);//输出为true 用于判断是否存在满足条件的数
let results = arr.every(function(item,index){
return item % 2 === 0;
});
log(reaults);//输出为false 用于判断是否每个元素都满足
set()
Set 是ES6中引入的一种数据结构 它允许存储任何类型的唯一值 无论是原始值或者是对象引用。 Set中的元素时唯一的 //可以用来去重 let s = new Set() // 创建了一个 空集 new 构建函数
set的对象方法
add()
添加数据并且返回新的Set结构
let S = new Set()
S.add( 1 ) // Set{1}
S.add (2) // Set{1,2}
S.add (1) // Set{1,2}
也可以用下面的方式
let arr = [3,2, 3, 4, 5, 3,4,6,3,3,3,3, 71, 11, 31, 12,2,3,5,4]
let S = new Set(arr);
console.log(S);
调用add()方法以后返回的又是一个Set对象 , 所以可以连续调用add()方法进行值的添加, 称为链式调用
let S =new Set()
S.add(1).add(2).add(3).add( 1); // Set{1,2,3}
通过size查看长度
let S = new Set([1,2,3]);
log(s);
log(s.size); // 3
add 加进去的会是一个
let s1 =new Set()
s1.add ([1,2,3])
log(s1) //
log(s1.size) // 1
delete() 删除数据 返回布尔值
let s = new Set([1,2,3])
log(s.delete(1)); //[2,3]
log(s.delete('1'))[1,2,3]
has() 查看是否存在, 返回布尔值,做全等比较
let s = new Set([1,2,3])
log(s.has(1)); // true
log(s.has('1')) //false
clear() 清空
let s = new Set([1,2,3]) s.clear()
Set的实际运用
let arr = [1,2,3,42,2,4,2,42,3,32,3]
//
let s =new Set(arr) 因为Set的特性 去重 装进集合里
let newArr = [...S] ... 扩展运算符 将集合展开 放进数组里 newArr变成一个数组
//也可以两步合一步
let newArr = [...new set(arr)];
log(newArr);
扩展运算符、
let bar = { a: 1, b: 2 }; let baz = { ...bar }; // { a: 1, b: 2 }
解构
var arr = ['tom', 'jeery', 'jacky', 'doinb', 'clearlove8'];
let [a, b, c, d, e] = arr;
console.log(a, b, c, d, e);
输出结果:tom jeery jacky doinb clearlove8
实现交换
let a= 5 , b =10
[a,b] = [b ,a]
// 10 5
排序
降序
let arr = [2, 3, 4, 5, 6, 71, 11, 31, 12]
for (let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i]<arr[j]) {
let temp;
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
console.log(arr); // [
71, 31, 12, 11, 6,
5, 4, 3, 2
]
升序
let arr = [2, 3, 4, 5, 6, 71, 11, 31, 12]
for (let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i]>arr[j]) {
let temp;
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
console.log(arr);
冒泡排序
let arr = [2, 3, 4, 5, 6, 71, 11, 31, 12]
for (let count = 0; count < arr.length; count++) {// 控制的是比较次数
for (let i = 0; i < arr.length; i++) { // 每一次循环里面交换的次数
if (arr[i] < arr[i+1]) {//让他每一个和下一个比较
let temp;
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
console.log(arr);