使用es6的方式去重
var arr = [{a:1},{a:1},{a:2},{a:3},{a:2}]
Array.prototype.unique = function (){
return [...new Set(this.map(a=>JSON.stringify(a)))].map(a=>JSON.parse(a))
}
arr.unique()
使用indexOf的方式去重 需同一地址下
Array.prototype.unique = function(){
const result = []
this.forEach( v =>{
if(result.indexOf < 0 ){
result.push(v)
}
})
return result
}
使用hash的方式去重
Array.prototype.unique = function() {
const hash = {}
const arr = []
let len = this.length
for (let i = 0; i < len; i++) {
if (!hash[this[i]]) {
hash[this[i]] = 'unqiue'
arr.push(this[i])
}
}
return arr
}
算法排序
Array.prototype.quickSort = function (){ //只可以排整数
return this.sort(function(a,b){
return a - b
})
}
冒泡排序
Array.prototype.popSort = function (){
let max = this.length - 1
for(let i = 0 ; i < max ; i++){
//循环控制比较多少轮
for(let j = 0 ; j < max - i ; j++){
//用于和上一层做比较
if(this[j] > this[j + 1]){
let temp = this[j]
this[j] = this[j + 1]
this[j + 1] = temp
}
}
}
return this
}
对象里的number排序
arr = [
{time: 19850813},
{time: 1565798524164},
{time: 15657985206},
{time: 156579851}
]
arr.sort((a,b)=>{
return a.time < b.time ? 1 : -1
})
集合取交集
Array.intersect = function () {
var result = new Array();
var obj = {};
for (var i = 0; i < arguments.length; i++) {
for (var j = 0; j < arguments[i].length; j++) {
var str = arguments[i][j];
if (!obj[str]) {
obj[str] = 1;
}
else {
obj[str]++;
if (obj[str] == arguments.length)
{
result.push(str);
}
}//end else
}//end for j
}//end for i
return result;
}
集合去掉重复
Array.prototype.uniquelize = function () {
var tmp = {},
ret = [];
for (var i = 0, j = this.length; i < j; i++) {
if (!tmp[this[i]]) {
tmp[this[i]] = 1;
ret.push(this[i]);
}
}
return ret;
}
并集
Array.union = function () {
var arr = new Array();
var obj = {};
for (var i = 0; i < arguments.length; i++) {
for (var j = 0; j < arguments[i].length; j++)
{
var str=arguments[i][j];
if (!obj[str])
{
obj[str] = 1;
arr.push(str);
}
}//end for j
}//end for i
return arr;
}
2个集合的差集 在arr不存在
Array.prototype.minus = function (arr) {
var result = new Array();
var obj = {};
for (var i = 0; i < arr.length; i++) {
obj[arr[i]] = 1;
}
for (var j = 0; j < this.length; j++) {
if (!obj[this[j]])
{
obj[this[j]] = 1;
result.push(this[j]);
}
}
return result;
};
console.log(Array.intersect(["1", "2", "3"], ["2", "3", "4", "5", "6"]));//[2,3]
console.log([1, 2, 3, 2, 3, 4, 5, 6].uniquelize());//[1,2,3,4,5,6]
console.log(Array.union(["1", "2", "3"], ["2", "3", "4", "5", "6"], ["5", "6", "7", "8", "9"]))
console.log(["2", "3", "4", "5", "6"].minus(["1", "2", "3"]));
降维数组
function dee(a){
var c = Array.prototype.concat.apply([],a)
var sum = JSON.stringify(c).match(/\[/g).length
if(sum === 1){
return c
}else{
dee(c)
}
}
every
对数组中每一项进行给定函数，如果每一项都满足条件则返回true，否则返回false；
var numbers = [1,2,3,4,5,4,3,2,1];
var result = numbers.every((item,index,array) => {
return item >2 ;
});
alert(result ); //false
some
对数组中每一项进行给定函数，如果任意一项满足条件则返回true，否则返回false；
var numbers = [1,2,3,4,5,4,3,2,1];
var everyResult = numbers.some(function(item,index,array){
return item>2;
});
alert(everyResult); //true
filter
对数组中每一项进行给定函数判断，返回满足函数条件的项组成的数组
var numbers = [1,2,3,4,5,4,3,2,1];
var everyResult = numbers.filter(function(item,index,array){
return item>2;
});
alert(everyResult); // [3,4,5,4,3]
map
对数组中每一项进行给定函数，返回执行后的结果组成的数组
var numbers = [1,2,3,4,5,4,3,2,1];
var everyResult = numbers.map(function(item,index,array){
return item*2;
});
alert(everyResult); // [2, 4, 6, 8, 10, 8, 6, 4, 2]
forEach
遍历数组，类似for循环
var numbers = [1,2,3,4,5,4,3,2,1];
numbers.forEach(function(item,index,array){
if(item!=2){ //如果不是2
numbers.splice(index,1,2); //替换成2
}
});
alert(numbers); // [2, 2, 2, 2, 2, 2, 2, 2, 2]
reduce && reduceRight
这两个方法迭代数组所有项，然后构建一个最终返回的值。
reduce从左到右，reduceRight从右到左。
var values = [1,2,3,4,5];
var sum = values.reduce(function(prev,cur,index,array){
return prev + cur;
});
alert(sum); //15
检测数组instanceof && array.isArray
var values = [1,2,3];
if(values instanceof Array){
//对数组进行某些操作
}
if(Array.isArray(values)){
//对数组进行某些操作
}
join
将数组转换成字符串，且用分隔符分隔
var colors = [1,2,3];
alert(colors.join("|")); // 1|2|3
toString
将数组转换成字符串
var color = [1,2,3];
console.log(color.toString());// 1,2,3
valueOf
将数组转换成字符串，返回数组值
var color = [1,2,3,4];
console.log(color.valueOf());//1,2,3,4
push && pop && shift && unshift
push() 从数组末尾添加
pop() 从数组末尾移除
shift() 从数组前端移除
unshift() 从数组前端添加
reverse
反转数组，返回数组
var color = [1,2,3,4,5];
console.log(color.reverse());//[5, 4, 3, 2, 1]
console.log(Array.isArray(color.reverse()));//true
sort
排序返回数组，默认是升序，
var color = [1,2,3,4,5];
var color2 = color.sort((a,b) => {
return b-a; //降序
//return a-b；升序
//retun 是 负数；
});
console.log(color2);
// [5, 4, 3, 2, 1]
concat
用于复制或者从尾部添加–>创建新数组
先创建一个当前数组的副本，然后将添加的数组添加到末尾，返回新的数组。如果没有传参数，直接复制返回新构建的数组。
var values = [1,2,3];
var v1 = values.concat();
var v2 = values.concat(4);
console.log(values); //[1,2,3];
console.log(v1); //[1,2,3]
console.log(v2); //[1,2,3,4]
splice
splice() 方法用于插入、删除或替换数组的元素。
array.splice(index,num,arr);
//返回被删除的元素
/**
*index：修改的位置即下标数字
*num：删除的长度，默认是至结尾
*arr：添加进去的数组
**/
//删除demo：
var values = [1,2,3,4,5,6];
var v = values.splice(0,2);
console.log(values); //[3,4,5,6]
console.log(v); //[1,2]
//插入demo：
var values = [1,2,3,4,5,6];
var v1 = values.splice(1,0,1,1,1);
console.log(values); //[1,1,1,1,2,3,4,5,6]
console.log(v1); //[]
//替换demo：
var values = [1,2,3,4,5,6];
var v1 = values.splice(1,2,1,1,1);
console.log(values); //[1,1,1,1,4,5,6]
console.log(v1); //[2,3]
slice
用于复制或截取数组–>创建新数组，截取当前数组的一部分创建一个新数组。可以接受一个或者两个参数，只有一个参数时返回指定位置到尾部的数组。两个参数时，返回指定位置到结束位置之前但不包括结束位置的数组。
var values = [1,2,3];
var v1 = values.slice();
var v2 = values.slice(1);
var v3 = values.slice(1,3);
console.log(values); //[1,2,3]
console.log(v1); //[1,2,3]
console.log(v2); //[2,3]
console.log(v3); //[2,3]
indexOf && lastIndexOf
返回元素在数组的位置
var values = [1,2,3,4,5];
indexOf() 从头找指定项的位置
var v1 = values.indexOf(3);
lastIndexOf() 从后往前查位置
var v2 = values.lastIndexOf(3);
两者如果没查到都返回-1
网友评论