数组基础

Posted 2021-03-21 niuyaomin

// 对象分为三种

// 内建对象

// 宿主对象

// 自定义对象

// 数组(Array)

// 数组也是一个对象他和普通的对象功能类似也是用来存储一些值的

// 不同的是一般对象{}用的是属性名字符串来存储值的而我们的数组是[]通过数字索引号来储存值的

// 索引:

// 从零开始的整数就是整数[0]数组存储性能比普通对象要好,在开发中我们经常使用数组来存储一些数据

//

// 创建数组语法:

// 使用typeof检查数据类型arr时会返回object

// var arr = new Array(10);

// console.log(arr)

// var arr = [10];

// console.log(arr)

//// 向数组中添加元素语法:数组[索引] = 值

// var arr = new Array();

// arr[0]=10;

// arr[1]=11;

// console.log(arr[0]);

//// 如果读取 不存在的值会返回undefined

//// console.log(arr[2]);

//// 使用字面量创建数组[]

//// 数组之中可以是任意的数据类型

// var arr = [undefined,null,[1,2,3],{name:"孙悟空"},function(){alert("吃了没");},6];

// console.log(arr);

// console.log(arr[2][0]);

// console.log(arr[3].name);

// arr[4]();

//// 获取数组的长度语法:length对于非连续的数组长度会返回索引最大值+1

// var arr = [1,2,3,4,5,6];

// console.log(arr.length);

//// length可以给数组最后添加一个元素

// arr[arr.length] = 7;

// console.log(arr);

//// length可以改变数组的长度;

// arr.length = 5;

// console.log(arr);

// console.log(arr.length);

 

// // for...of循环

// // for (const iterator of object) {}用来遍历arr数组

// var arr = [1,2,3,4,5,"a"];

// for (var a of arr) {

// console.log(a);

// }

 

//// for循环去遍历数组元素

// var arr = [1,2,3,4,5,6];

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

// console.log(arr[i]);

// }

// function Per(name,age) {

// this.name = name;

// this.age = age;

// }

//// 修改原型中的tostring方法

// Per.prototype.toString = function(){

// return "pos[name = "+this.name+",age = "+this.age+"]";

// };

//// 创建多个per对象

// var p1 = new Per("孙悟空",18);

// var p2 = new Per("猪八戒",18);

// var p3 = new Per("蜘蛛精",17);

// var p4 = new Per("玉兔",25);

// var p5 = new Per("二郎神",15);

//// console.log(p5)

//// 将这些per对象放到数组之中

// var pero = [p1,p2,p3,p4,p5];

//// 创建一个函数可以将Pero中满十八岁的Pero提取出来

//// 然后封装到新的数组之中返回arr形参要提取信息的数组

// function getAdult(arr){

//// 创建一个性的数组

// var newArr = [];

//

//// 遍历arr,获取arr中的person对象

// for(var i=0; i<pero.length; i++){

// var p = pero[i];

// if(p.age >= 18){

// newArr.push(p);

// }

// }

//// 判断是否成年>=18

//// 如果大于18则将这个对象添加到newarr中

// return newArr;

// }

// var ret = getAdult(pero);

// console.log(ret);

//// 一般数组中我们都是使用for循环去遍历数组

//// js中还为我们提供了一个方法,用来遍历数组

//// forEach()

//// 这个方法只支持ie8以上的浏览器

// var arr = [1,2,3,4,5,6];

//// forEach()这个方法需要一个函数作为参数，像这种函数由我们创建但是不是由我们调用的我们称为回调函数

//// 数组中的函数有几个元素就会执行几次，每次执行时，浏览器将会遍历到的元素以实参的形式传递进来，我们可以定义形参用来读取这些内容

//// 浏览器会在回调函数中传递三个参数

//// 第一个参数,就是当前正在遍历的元素

//// 第二个参数,就是当前正在遍历的元素索引号

//// 第三个参数,就是正在遍历的数组

//// 其余的参数都是未定义undefined

// arr.forEach(function(value,index,object,undefined){

//// console.log("hello");

// console.log("第一个形参传递value值 = "+value);

// console.log("第二个形参传递index索引 = "+index);

// console.log("第三个形参传递object本数组对象 = "+object);

// console.log("其余参数未定义 = "+undefined);

// });

 

 

 

//// 数组方法

//// push()方法向数组的末尾添加一个或者多个元素,并返回新的长度可以要将添加的元素作为参数传递

// var arr = [1,2,3,4,5,6];

// var result = arr.push(7,8);

// console.log(arr);

// console.log(result);

//// unshift()方法向数组的开头添加一个或者多个元素,并返回新的长度可以要将添加的元素作为参数传递

// var arr = [1,2,3,4,5,6];

// var result = arr.unshift(-1,0);

// console.log(arr);

// console.log(result);

// 展开操作符号在数组末尾添加一个值

// var arr = [1,2,3,4,5,6];

// var arr2 = [...arr,7];

// console.log(arr2);

// 展开操作符号在数组前面添加一个值

// var arr = [1,2,3,4,5,6];

// var arr2 = [0,...arr];

// console.log(arr2);

// 在任何索引处插入元素

// var arr = [1,2,3,4,5,6];

// var arr2 = [

// ...arr.slice(0,2),"a",...arr.slice(2)

// ];

// console.log(arr2);

// 可以通过运算符和数据字面量以不可变的方式从数组中删除数组中的值

// var arr = [1,2,3,4,5,6];

// var arr2 = [

// ...arr.slice(0,1),

// ...arr.slice(arr.length-1)

// ];

// console.log(arr2);

 

//// pop()方法可以删除数组最后一个元素，删除谁就返回谁

// var arr = [1,2,3,4,5,6];

// var result = arr.pop();

// console.log(arr);

// console.log(result);

//// shift()方法可以删除数组第一个元素，删除谁就返回谁

// var arr = [1,2,3,4,5,6];

// var result = arr.shift();

// console.log(arr);

// console.log(result);

// // array.concat()方法

// // array.concat（）将一个或者多个数组链接到原始数组之中

// var arr = [1,2,3,4,5,6];

// var arr2 = ["a"];

// var arr3 = ["b"];

// var result = arr.concat(arr3,arr2,arr);

// console.log(arr);

// console.log(result);

// // 展开符号操作和数组字面量一起使用来链接数组[...arr,...arr2]

// var arr = [1,2,3,4,5,6];

// var arr2 = ["a"];

// var arr3 = ["b"];

// var arr4 = [...arr,...arr3,...arr2];

// console.log(arr4);

// // array.map(callback)方法通过在每个数组项上使用callback使用参数调用结果来创建一个新数组。

// // 提示map创建一个新的映射数组并不会改变原先的arr数组

// var arr = [1,2,3,4,5,6];

// var arr2 = arr.map(function (a) {

// return a+1;

// });

// console.log(arr2);

// // Array.form()方法通过在每个数组项上使用arr2调用结果来创建一个新的结果

// // 创建一个新的数组并且不会改变原始的数组更合适从类似数组的对象进行映射

// var arr = [1,2,3,4,5,6];

// var arr2 = Array.map(arr,function(a){return a+1;});

// console.log(arr2);

 

// // Array.reduce()方法通过调用callback函数将数组简化为一个值

// // 在遍历中使用参数调用的：累加器，当前项，索引和数组本身且应该返回累加器

// // 经典实例是对数字的求和

// var arr = [1,2,3,4,5,6];

// var arr2 = arr.reduce(function(a,b) {

// return a+b;

// },3);

// console.log(arr2)

// // Array.slice()方法可以截取数组中的片段并返回

// var arr = ["a","b","c","d","e","f"];

// var result = arr.slice(2)

// console.log(result);

 

// // Array.splice()方法可以截取数组中的片段并返回也会改变原始数组的值,前面两个参数是截取位置后面参数是在截取的位置中添加任意值不限制个数

// var arr = ["a","b","c","d","e","f"];

// var result = arr.splice(0,2,444)

// console.log(result);

// console.log(arr);

// // 拷贝数组的一种简单方法就是展开运算符号‘var arr = [...变量名];

// var arr = ["a","b","c","d","e","f"];

// var arr2 = [...arr];

// console.log(arr2);

// console.log(arr2 == arr);//false

// // Array.concat()方法可以连接多个数组也是拷贝数组的方法不会对原数组产生影响

// var arr = ["a","b","c","d","e","f"];

// var arr2 = Array.concat(arr,66);//等同于[].concat(arr),

// console.log(arr2)

 

// // array.includes()方法可以查找一个值是否在数组之中有返回true没有false

// var arr = [1,"b","c","d","e","f"];

// console.log(arr.includes(1)

// Array.find()方法返回数组中提供的函数测试的第一个元素值。否则就返回undefined

// var arr = ["a",2,1,"d","e","f"];

// var arr2 = arr.find(function(a){

// return a%2 == 0;

// })

// console.log(arr2)

// // Array.indexOf()方法可以查找数值中的值的索引位置并返回，没有查到返回-1

// var arr = ["a",2,1,"d","e","f"];

// var result = arr.indexOf("f");

// console.log(result);

// // Array.every()方法可以查询每一个值是否符合函数规定

// // 下面函数之中可以是检查值的类型是否是偶数

// var arr = [2,4,6];

// var arr2 = [1,2,3,4,5,6];

// function oshu(b) {

// return b%2==0;

// }

// console.log(arr.every(oshu));//true

// console.log(arr2.every(oshu));//fales

// // Array.some()方法如果数组中的值只要有一个通过函数检查就会返回true

// var arr = [1,2,5];

// var arr2 = [1,3,7];

// function oshu(b) {

// return b%2==0;

// }

// console.log(arr.some(oshu));//true

// console.log(arr2.some(oshu));//fales

// // Array.filter()方法是过滤方法，可以过滤出数组中符合函数的值

// var arr = [1,2,3,4,5,6];

// function oshu(b) {

// return b%2==0;

// }

// console.log(arr.filter(oshu))

// var a = 0;

// // Array.fill()方法可以用来填充数组

// var arr = [1,2,3,4,5,6];

// console.log(arr.fill(0));

// // 不仅如此还可以初始化数数组

// console.log(Array(5).fill(9));

// // Array.join()该方法可以将数组转换成为一个字符串该方法不会对元数组产生应影响

// // 在join中可以制定一个字符串作为参数成为数组中的链接符号

// var arr = [1,2,3,4,5,6];

// var result = arr.join();

// var str = arr.join("字符");

// console.log(typeof result);//string

// console.log(str);

// // array.reverse()方法用来颠倒数组中的元素位置,会影响原数组

// var arr = [1,2,3,4,5,6];

// arr.reverse();

// console.log(arr);

// // array.sort()可以对数组中的元素进行排序也会影响原来的数组，默认会按照unicode编码进行排序

// var arr = [2,1,3,6,5,4];

// // console.log(arr.sort());

// // 对与数字时也是有局限性的我们可以自己制定排序规则

// // 我们可以在sort()中添加一个回调函数，用来指定规则，回调函数中需要定义两个形参，浏览器会分别使用数组中的元素作为实参去调用回调函数,形参a一定在b前面

// // 浏览器会根据回调函数的返回值来决定元素返回的位置

// // 如果返回一个大于0的数字就会交换位值

// // 如果返回一个小于0的数字位置不变

// // 如果返回0，则认为两个元素相等，也不会交换位置

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

// // console.log("a="+a)

// // console.log("b="+b)

// if (a>b) {

// return 1;

// }if (a<b) {

// return -1;

// } else {

// return 0;

// }

// //上面if语句等同于 return a-b;

// });

// console.log(result);

 

// // 使用sort()方法将偶数排列在基数前面练习

// var arr = [2,1,3,6,5,4,7,9,11];

// var result = arr.sort(

// function(a,b) {

// if (a % 2 == 0 && b % 2 != 0) {

// return -1

// }if (a % 2 != 0 && b % 2 == 0) {

// return 1;

// } else {

// return 0;

// }

// }

// );

// console.log(result);

// // Array.flat()方法通过遍历数组的值到了一定深度来从新创建数组原数组的成员里面有一个数组，flat()方法将子数组的成员取出来，添加在原来的位置。

// // flat()默认只会“拉平”一层，如果想要“拉平”多层的嵌套数组，可以将flat()方法的参数写成一个整数，表示想要拉平的层数，默认为1。flat()的参数为2，表示要拉平两层的嵌套数组。

// var arr = [2,[1,3,6,5],4,7,[9,11]];

// var result = arr.flat(1);

// console.log(result);

 

// 数组中的去重练习

// 获取数组中的每一个元素

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

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

console.log(arr[i]);

for (var j = i+1; j < arr.length; j++) {

// console.log(">-------"+arr[j]);

if (arr[i] == arr[j]) {

arr.splice(arr[j],1)

j-1

}

}

}

console.log(arr);