数组&Manth

数组

创建数组

• var arr=[1,2]
  

• var arr=new Array()
  arr[0]='12';
  

• var arr=new Array(1,2,'a')
  

添加数组元素

从前添加是unshift，从后添加是push

var arr=[1,2,3,'1','a'];
console.log(arr.unshift('ghghg',55,'a'));
//返回新数组长度，改变原来数组,括号里可以添加多个
console.log(arr.push('ghghg',55,'a'));
//返回新数组长度，改变原来数组,括号里可以添加多个

删除数组元素

从前删除是shift，从后删除是pop

var arr=[1,2,3,'1','a'];
console.log(arr.shift());
//返回删除的内容，改变原来数组,括号里只可以放一个，或者不放，反正是删除第一项
console.log(arr.pop());
//返回删除的内容，改变原来数组,括号里只可以放一个，或者不放，反正是删除最后一项

splice（）删除、添加、替换

var arr=[1,2,3,'1','a'];
console.log(arr.splice());
//什么都没有干
//-------------------------------------
console.log(arr.splice(1));
//返回删除的元素，从当前位置开始，删到最后
console.log(arr.splice(arr.length+1));
//超过数组长度以后不起作用
console.log(arr.splice(-2));
//返回删除的元素，从后往前删除
//------------------------------------
console.log(arr.splice(1,2));
//返回删除的元素，1代表开始位置，2代表长度
//-------------------------------------
console.log(arr.splice(1,2，3));
//替换，把原来位置删了，新加了内容
//1代表开始的位置，2代表长度，3代表要替换的内容，3以后可以添加好多值
//可以只添加不删除，长度为0就可以
console.log(arr.splice(1,0，3));

length为0就是只添加，length大于0，就是替换原来的内容

join（）

数组转为字符串

var arr=[1,2,3,'1','a'];
//数组变字符串
console.log(arr.join())
console.log(arr.join('/'))//就是用/连接起来
//字符串转数组
console.log(arr.join().split());

concat（）

连接多个数组

var arr=[1,2,3,'1','a'];
var arr1=['qwq'];
var arr2=['ttt'];
console.log(arr.concat(arr1,arr2));

reverse（）

反转

var arr=[1,2,3,'1','a'];
console.log(arr.reverse());
//反转的是数组中的每一项

indexOf（）

查找某一项出现的位置，返回的下标（index）

var arr=[1,2,3,'1','a'];
console.log(arr.indexOf(2));//1
//括号里的元素在数组中首次出现的位置

sort（）

数组提供的排序方法，sort（[参数]）

默认最小值位于前面

var arr=[1,3,45,7];
console.log(arr.sort());//比的是编码
//可以加参数
arr.sort(function(a,b){return a-b})
//这样就可以从小到大排序
arr.sort(function(a,b){return b-a})
//这样就可以从大到小排序

纯数字才可以

字符串排序

var arr=['a','ca','b','e','eee'];
console.log(arr.sort());//比的是编码
//编码默认从a-z排序
arr.sort(function(a,b){return b.chartCodeAt(0)-a.chartCodeAt(0)})
//想让他从z-a排序

汉字情况如何排序

localeCompare

var arr=['河北','天津','沧州','北京','上海','香港'];
console.log(function(a,b){return a.localeCompare(b,'zh')})

时间排序

var arr={
	{"time":"2019-8-15","id":"1123"}
	{"time":"2019-8-15","id":"1123"}
	{"time":"2019-8-15","id":"1123"}
	{"time":"2019-8-15","id":"1123"}
	{"time":"2019-8-15","id":"1123"}
}
//时间比较，现在是在字符串里，先把他变为时间类型
var px=arr.sort(Function(a,b){
	//a.time-b.time	//这种不行
	//return new Date(a.time)- new Date(b.time);
	//先转换为时间类型再进行比较
	//转换为时间戳
	//return Date.parse(a.time)-Date.parse(b.time);
	if(a.time === b.time){
                return Number(a.id)-Number(b.id);
				//是字符类型没法比较，所以先转为数值
            }
            return new Date(a.time)-new Date(b.time);
});
console.log(arr);

数组排序的其他方法（不让用sort）

选择排序

两个循环，找最小的值往前面放，从第一项起，每一项都和后面的项依次比较，如果被比较项比当前项小，则两项交换位置

var arr5=[2,4,6,2,1,8,0];
        for(var i=0;i<arr5.length;i++){
            for(var j=i+1;j<arr5.length;j++){
                if(arr5[i]>arr5[j]){
                    var x=arr5[i];
                    arr5[i]=arr5[j];
                    arr5[j]=x;
                }
            }
        }
        console.log(arr5);
//更新版，先记住位置
var arr5=[2,4,6,2,1,8,0];
        for(var i=0;i<arr5.length;i++){
        	var index=i;
            for(var j=i+1;j<arr5.length;j++){
                if(arr5[index]>arr5[j]){
                    index=j;
                }
				var x=arr5[i];
            	arr5[i]=arr5[index];
            	arr5[index]=x;
            }
        }
        console.log(arr5);

冒泡排序

相邻的两个比,找最大的往后面放，两个循环

var arr5=[2,4,6,2,1,8,0];
        for(var i=0;i<arr5.length;i++){
            for(var j=0;j<arr5.length-i;j++){
                if(arr5[j]>arr5[j+1]){
                    var x=arr5[i];
                    arr5[i]=arr5[j];
                    arr5[j]=x;
                }
            }
        }
        console.log(arr5);

数组迭代，遍历数组，类似for循环

every，针对数组元素做出判断，如果结果都为true，则返回true(&&)

var arr7=[2,3,1,6]
        var a7=arr7.every(function(value,index,array){//回调函数
            return value >1;
        })
        console.log(a7);//false
//value每一项，索引值，原来数组

some，针对数组做出判断，如果结果有一个为true，则返回true(||)

var arr7=[2,3,1,6]
var a1=arr7.some(function(value,index){
            return value>5;
        })
        console.log(a1);//true

filter，过滤作用，针对数组做出判断，满足条件的会组成一个新数组

var arr7=[2,3,1,6]
var a2=arr7.filter(function(value,index,array){
            return value >2;
        })
        console.log(a2);

map，遍历数组，对数组每一项进行操作，返回一个新的数组，将返回的值合成一个新的数组（常用）

var arr7=[2,3,1,6]
var a3=arr7.map(function(value,index,array){
            return value +2;
        })
        console.log(a3);

forEach，没有返回值，就是一个循环，遍历数组（常用）

var a4=arr7.forEach(function(value,index){
            console.log(value);//2，3，1，6
        })

数学对象Math

不用创建

处理数字的基本方法

常用的
Math.ceil() //有小数点进一位，向上舍入
Math.floor() //不要小数点后面的内容，向下舍入
Math.round() //四舍五入
Math.random() //默认0-1，包含0不包含1
Math.random()*x //0-x之间的随机数
Math.random()*(y-x)+x //x-y之间的随机数
不常用的
Math.abs //求绝对值
Math.min() //求最小值
Math.max() //求最大值
Math.pow(2,2) //求2的2次幂，Manth.pow(one,two),求one的two次幂
Math.sqrt() //求某个数的平方根
Math.sin(写的是弧度);
Math.cos();
Math.PI=180deg=3.1415926=π