javascript--数组
一、数组的优缺点：
数组的优点：
1、按照索引查询元素速度快;
2、能存储大量数据;
3、按照索引遍历数组方便;
4、数组定义简单,而且访问很方便;
5、可以随机访问其中的元素。
数组的缺点：
2.数组大小必须定义时给出，而且大多数情况下，数组空间的大小一旦确定后就不能更改
3.数组的空间必须是连续的，这就造成数组在内存中分配空间时必须找到一块连续的内存空间。所以数组不可能定义得太大，因为内存中不可能有那么多大的连续的内存空间，而解决这个问题的方法就是使用链表。
二、数组的声明方式：
2.1、通过new运算符创建数组
var arr1 = new Array('a',6,7,true); console.log(arr1);
注意：var arr1 = new Array(6); console.log(arr1); //输出的是一个长度为6的空数组。
2.2、省略new运算符创建数组
Var arr2 = Array(''a",6,7,true); console.log(arr2);
注意：var arr2 = Array(6); console.log(arr2); //输出的是一个长度为6的空数组。
2.3、直接赋值
var arr3 = ['aa',6,5,true];
三、数组中的每个元素都是数组元素，length：代表数组的长度。
四、可以通过下标来访问元素，也可以通过下标来设置元素。
例如：var arr3 = ['A',5,8,ture];
console.log(arr3[0]);//可以拿到数组元素
arr3[0] = 90;
console.log(arr3); // arr3= [90,5,8,ture];
注意：
二维数组:数组的元素可以是数组
boolean 类型一定要熟练使用。
| 数组方法总结 | ||
| 方法名称 | 方法满足条件 | 方法案例 |
| 栈与队列的形式汪数组里面添加减少元素。 | ||
| 栈：特点:先进后出，从一头进从一头出。 | ||
| 1.push() |
1.功能：给原数组的末尾添加元素，直接修改原数组。 2.参数：添加进数组的元素 3.格式：数组.push(参数)； 4.返回值： 返回插完元素以后数组的长度。（简单的来说就是新数组的长度） |
var arr = [1,2,3,4,5]; arr.posh(6); conslo.log(arr); arr = [1,2,3,4,5,6,]; |
| 2.pop() |
1.功能：从数组的尾部取元素，一次只能取一个，直接改变原数组。 2.参数： 无参数， 3.格式：数组.pop() 4.返回值： 取下的元素（简单的来说就是被删除的元素） |
var arr = [1,2,3,4,5]; arr.pop(); conslo.log(arr); arr= [1,2,3,4]; |
| 队列：特点：先进后出，一头进另一头出来 | ||
| 3.shift() |
1.功能：从原数组的首位取元素。一次只能取一个元素， 直接改变元素组。 2.参数： 无参数 3.格式：数组.shift() 4.返回值： 取下来的元素（简单的来说就是被删除的元素） |
var arr = 【1，2，3，4，5，6】 arr.shift(); conslo.log(arr); arr = [2,3,4,5,6] |
| 4.unshift() |
1.功能：从原数组的首位添加一个元素， 直接改变原数组。 2.参数：你要插入的元素 3.格式：数组.unshift() 4.返回值：插完元素以后数组的长度。 |
|
| 截取+拼接 | ||
| 5.slice() |
1.功能：截取当前数组中指定的区域，并不会改变元素组 2.格式：数组.slice(start,end); 3.截取范围：[start,end) 不包括结束位置下标的元素。左闭右 4.参数：1.参数可以是一定范围；2.参数是负1；3.参数是1；4参数是0 5.返回结果： 返回的是一个数组。 |
var arr = [1,2,3,4,5,6] arr.slice(2,3) //结果是 var newarr = [3] 当参数为 1时 arr.slice(1) // 结果是： 从小标1开始截取，知道最后也截取掉。 //当参数为（-1）时 arr.slice(-1) 表示从下标从数组后面的开始截取 //当参数为 （0）时 就是相当把这个数组复制了一遍。 |
|
深复制/浅复制 深赋值/浅赋值 符号地址对应表 栈 队列 |
||
| 符号 地址 | AAAA 10 aaa {a:100} |
含义：首先 JavaScript中的数据类型分为 值类型 和引用数据类型 值类型包括（nmber, string underfan bool null (NaN 属于nuber)） 值类型存放的时 栈里面 引用类型存放的时 队列堆里面。 值类型：在‘栈’中保存的是值
引用类型：在‘栈’中保存的是地
址，值在‘堆中保存’
任何的=赋值，仅仅是‘栈’中的内
容赋值
深赋值、深复制：不只在‘栈’中添
加一个新的，在‘堆’中野添加一个
新的，各改各的，互不影响
浅赋值、浅复制：仅仅在‘栈’中添
加一个新的，改值会影响原数组
|
| a AAAA | BBBB 10 | |
| b BBBB | CCCC aaaa | |
| c CCCC | ||
| 6.splice() |
1.功能：根据参数的不同，然后对数组进行增删改查 2.参数：一共有三个参数 。 第一个参数： 开始截取的下标； 第二参数 截取的长度 ； 第三个参数是：元素 如果是插入元素的话，则arr.splice(1,0 ,'元素') 如果是删除的话，则arr.splice(1,1); 如果是替换的话（修改）则 arr.splice(1,1,'元素') 3.格式： 数组.splice(start,length,元素)； 4.返回值：根据你的参数来进行返回的数据 |
特殊情况： 插入数据： 如果你要插入的一个数组的话， 把它插入到一个新的数组里面， 新插入的数组在这个最新的数组里面 展现的方式是 [1,'zhangsan',[1,2]] //不会自动去除中括号 |
| 7.concat |
1.功能：合并数组，并不会修改原数组，基于当前元素创建一个新的元素 2.格式：数组.concat() 3.返回值 ：返回的是连接的最新数组 |
var arr = [3,6,5]; var arr1 = [7,8,9]; arr3 = arr.concat(arr1); arr3 = [3,6,5,7,8,9];
|
| 9.join() |
1.原理：首先是让每一个数组元素，调用。toString 然后在同默认的特殊符号 拼接到一起 2.功能： 把数组元素连接成字符串 ，使用特殊的分隔符进行连接 3.格式：数组.join() 4.返回值： 拼接好的字符串 5.参数： 拼接符 ，如果没有拼接符默认就是 逗号来进行拼接 |
|
| 查找是否存在 | ||
| 10.indexOf() |
1.功能：查找元素在数组中第一次出现的下标位置 2.格式： 数组.indexOf(item，start) //如果 start 不传的话 就默认是从 下标0开始查 3.参数：你要查找的内容。 4. 返回值：如果查找到，返回的就是这个元素的下标 如果查不到的话，则返回-1. |
|
| 11.lastIndexOf() |
1.功能：查找元素在数组后面开始进行查找第一个出现的位置 2.格式： 数组.lastIndexOf(item,start) 3.参数：你要查找的内容 4.返回值:如果找到的话，返回的正序的下标。 如果找不到的话，则进行返回-1. |
|
|
方法(遍历) |
||
| 12.findIndex |
原理 ： 这个相当于 遍历 返回结果：找到过滤的函数，必须返回一个bool类型的结果 |
使用与引用类型的数组，按条件查找到下标、 var arr = [{name:'占山',age:20}, 返回的是 name = '占山' 的下标。 |
| 13.find() |
按条件查找一个满足条件的元素，必须返回一个 bool类型的结果 返回值： 如果找到了则 返回你找到的元素，如果没有找到则返回undefind |
arr . find（
function（item，index）{
return item.name
=== 值；}
）
|
| 14.filter() |
按条件找到所有满足条件的元素，必须返回一个 bool类型的结果 返回值：找到找不到都会返回来一个数组， 如果找到了则 返回你找到的元素构成的数组，如果没有找到则返回一个空数组，可以根据lenght 长度来判断是否找到元素
|
arr . filter（
function（item，index）{
return item.name
=== 值；}
）
按条件查找所有满足条件的元素
必须返回一盒bool类型的结果
找到或找不到都会返回
一个数组，区别：有无
值
找到则返回找到的元素
构成的数组
比如：[
{name: "345"} ]
找不到返回一个空数组
|
| 15.forEach() |
注重迭代/遍历，注重过程
|
|
| 16:map(函数，内容是具体的映射规则) |
根据当前数组按一定的规则映射出一
个新数组
原数组不变
必须返回一个结果，不然return默认
返回undefined
映射出的新数组 新数组数量不变，内容
会根据映射规则改变
比如：item*2
得到的是原数组中值*2
后的新数组
|
var arr = [1,2,3,4,5,6]; |
| 17some(函数，必须返回一个bool类型的结果) |
判断数组中有没有任意一个元素符合
条件，能让函数参数返回真
找到一个满足条件的元素就会终止循
环返回真
如果遍历完都没有找到则返回假
|
// some 遍历 |
| 18every(函数，必须返回一个确定的结果) |
判断数组中是否所有元素都符合条
件，让函数参数返回真
找到一个不满足条件的就会终止循环
返回假
如果遍历完所有元素都符合条件则返
回真
|
var arr3 = [{name:'占山',age:20}, |
| 19reduc(函数，必须返回一个确定的结果) |
使用参数函数按照一定的逻辑对整个
数组从左到右进行‘收缩’
有第二个参数：第二个参数是参数函
数初始没有返回值时用的
|
参数函数最后一次调用
return返回的结果
|
| 20reduceRight（函数，必须返回一个确定的结果） |
使用参数函数按照一定的逻辑对整个
数组从右到左进行‘收缩’
|
参数函数最后一次调用
return返回的结果
|
| 21.stort() | /*4. 使用for循环实现一个逆向排序，先进性正常排序，然后进行倒叙 var arr4 = [99,5,165,22,8,6]; for(var i = 0; i <= arr4.length-1; i++){ for(var j = i + 1; j<arr4.length; j++) if(arr4[i] > arr4[j]){ var tep = arr4[i]; arr4[i] = arr4[j]; arr4[j] = tep; } } console.log(arr4); console.log(arr4.reverse()); |
|
| 22.reverse() | 1.逆向顺序，改变原来的数组 | var arr3 = [ 1, 5, 10, 15,16, 20,105 ]; // var arr4 = arr3.sort(); // console.log(arr3); // console.log(arr4); //可以正常数字排序 // var arr5 = arr3.sort( function ( n1, n2 ){ // return n1 -n2; // } ); // console.log(arr5); |
深复制 / 浅复制
1.Object.create() 与 Object.assign()
两者的相同点： 都创建了一个对象
（1）Object.create()
只是一级属性复制，只是比浅拷贝多深拷贝了一层而已
它只对顶层属性做了复制，完全没有继续做递归之类的把所有下一层的属性做深拷贝
（2.）多级拷贝
对于多级拷贝，可以使用json.parse(json.stringify(要拷贝的对象))
原理是：将一个对象转成 json字符串之后，又从 json字符串转成对象
参数： proto : 必须。表示新建对象的原型对象，即该参数会被赋值到目标对象(即新对象，或说是最后 返回的对象)的原型上。, 该参数可以是null， 对象， 函数的prototype属性 （创建空的对象时需传null , 否 则会抛出TypeError异常）。 propertiesObject : 可选 添加到新创建对象的可枚举属性（即其自身的属性，而不是原型链上的枚举属性）对象 的属性描述符以及相应的属性名称。 这些属性对应Object.defineProperties()的第二个参数。 返回值： 在指定原型对象上添加新属性后的对象。 // Object.create() 方式创建 // Object.create() es6创建对象的另一种方式，可以理解为继承一个对象, 添加的属性 是在原型下 var a = { rep: 'apple' } var b = Object.create(a) console.log(b) // {} b 自身是没有的 console.log(b.__proto__) // {rep: "apple"} console.log(b.rep) // {rep: "apple"} Object.create()方法创建的对象时，属性是在原型下面的，也可以直接访问 b.rep // {rep: "apple"} , 此时这个值不是b自身的，是它通过原型链proto来访问到b的值。
.
// new Object() 方式创建 new Object() 通过构造函数来创建对象, 添加的属性是在 自身实例下 var a = { rep : 'apple' } var b = new Object(a) console.log(b) // {rep: "apple"} console.log(b.__proto__) // {} console.log(b.rep) // {rep: "apple"}
14、Object.assign( obj ) 和 Object.assign( {}, obj ) 的区别 Object.assign()：是把Object.assign()的多个参数,逐一合并到第一个参数中,并把第 一个参数本身返回 var obj = { a:100 }; var obj2 = Object.assign( obj ); // var obj2 = obj; var obj2 = Object.assign( {}, obj ); // var obj2 = { ...obj }; Object.assign( obj ); 相当于直接返回了obj,obj和obj2指向的是相同的地 址,改变obj2 的a,obj的也会变 Object.assign( {},obj ); 是创建了一个新的对象,把obj的值合并进去并赋值给 obj2 互不影响 var obj2 = Object.create( obj ); var obj2 = Object.assign( obj ); delete obj2.a; 删除的是obj2自身上的a 如果是assign,consol.log(obj2.a) obj2中没有a这个键 如果是create,delete删除的是obj2自身上的,但是obj2上并没有a,a是原型上的,delete 什么也没做 面试题: var company = { address: "beijing" } var yideng = Object.create(company); delete yideng.adress; console.log(yideng.adress);
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
常用的几种for 循环
1.普通的
for(var i = 0; i < 数组的长度；i++){
}
for(var i = 10; i<=10; i--){}
2.第二常用
var a = [1,3,”ture“,true]
for(var x in a){
console.log(x) //输出的是 在 a中数组的位置
console.log(a[x]) //输出的是值
}
3. forEach
var arr = ['a','b','c'];
arr.forEach(function(value,index,array){
//函数中分别对应：数组元素 元素的索引 数组本身
})
浙公网安备 33010602011771号