数据结构 -数组方面

数组的定义

数组是一个有序的值列表。 数组中每个值叫做元素，每个元素在数组中都有一个唯一的位置。位置用数字表示叫做 （索引）或者 （下标）

下标是从 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);