数组去重
1.ES6的Set去重(最推荐)
new Set是ES6新推出的一种类型。他和数组的区别在于，Set类型中的数据不可以有重复的值。当然，数组的一些方法Set也无法调用。
弊端：但是Set去重有一个弊端，他无法去重引用类型的数据。比如对象数组。
const arr = [1,1,2,2,3,3,4,4,5,5];
const setData = Array.from(new Set(arr));
console.log(setData);
双重for
//双重循环去重
function Unique(arr = []) {
for (let i=0,len = arr.length; i < len; i++) {
for (let j = i + 1; j < len; j++) {
if (arr[i] === arr[j]) {
arr.splice(j, 1);
j--;
len--;
}
}
}
return arr;
};
Unique(arr)
相邻元素去重(for + sort)
这种方法首先调用了数组的排序方法sort()，然后根据排序后的结果进行遍历及相邻元素比对，如果相等则跳过改元素，直到遍历结束
function unique(arr) {
arr = arr.sort()
let res = []
for (let i = 0; i < arr.length; i++) {
if (arr[i] !== arr[i-1]) {
res.push(arr[i])
}
}
return res
}
indexOf去重
function Unique(arr = []) {
let repeatArr = [];
for (let i = 0,len = arr.length ; i < len; i++)
if (repeatArr.indexOf(arr[i]) === -1) repeatArr.push(arr[i])
return repeatArr;
}
Unique(arr)
const arr = [1,1,2,2,3,3,4,4,5,5];
function Unique(arr = []) {
let repeatArr = [];
for (let i = 0,len = arr.length ; i < len; i++)
if (!repeatArr.includes(arr[i])) repeatArr.push(arr[i])
return repeatArr;
}
Unique(arr)
function Unique(arr = []) { arr.filter((item,index) => arr.indexOf(item,0) === index)}
handleRemoveRepeat(arr)
reduce去重
const arr = [1,1,2,2,3,3,4,4,5,5];
function Unique(arr = []) {
return arr.reduce((t, v) => t.includes(v) ? t : [...t, v], []);
}
Unique(arr)
set与解构赋值去重
ES6中set的一个最大的特点就是数据不重复。Set函数可以接受一个数组（或类数组对象）作为参数来初始化，利用该特性也能做到给数组去重
function unique(arr) {
if (!Array.isArray(arr)) {
console.log('type error!')
return
}
return [...new Set(arr)]
}
数组排序
var oldArr = [19, 55, 6, 52, 4 , 6, 15, 28, 23, 2, 1, 9]
oldArr.sort((a, b) => {
return a-b // 升序
//reture b-a 降序
})
console.log(oldArr);
]
冒泡排序
var oldArr = [19, 55, 6, 52, 4 , 6, 15, 28, 23, 2, 1, 9]
function bubbleSort(arr) {
for(let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length - i; j++) {
// 如果前一个比后一个大,则交换位置
if (arr[j] > arr[j+1]) {
let temp = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = temp
}
}
}
return arr
}
console.log(bubbleSort(oldArr));
// [1, 2, 4, 6, 6, 9, 15, 19, 23, 28, 52, 55]
插入排序
var oldArr = [19, 55, 6, 52, 4 , 6, 15, 28, 23, 2, 1, 9]
function inserArr(arr) {
let newArr = []
for(let i = 0; i < arr.length; i++) {
if (i === 0) {
newArr.push(arr[i])
continue
}
for(j = newArr.length -1; j >= 0; j--) {
if (arr[i] >= newArr[j]) {
newArr.splice(j + 1, 0, arr[i])
break
} else if (j === 0) {
newArr.splice(0, 0, arr[i])
}
}
}
return newArr
}
console.log(inserArr(oldArr));
// [1, 2, 4, 6, 6, 9, 15, 19, 23, 28, 52, 55]
简单数组拍平
const flatten = (list) => list.reduce((a, b) => a.concat(b), []);
const flatten = (list) => [].concat(...list);
深层数组拍平
// depth为自定义拍平的层数，默认为 1
function flatten(list, depth = 1) {
if (depth === 0) return list;
return list.reduce(
(a, b) => a.concat(Array.isArray(b) ? flatten(b, depth - 1) : b),
[]
);
}
flat 方法可以直接用于数组拍平，不传入参数时默认拍平一层
const arr = ["1", ["2", "3"], ["4", ["5", ["6"]], "7"]];
// 不传参数时，默认“拉平”一层
arr.flat(); // ["1", "2", "3", "4", ["5", ["6"]], "7"]
const arr = [1, [2, 3], [4, [5, [6]], 7]];
// 传入一个整数参数，整数即“拉平”的层数
arr.flat(2);
// [1, 2, 3, 4, 5, [6], 7]
// 传入 <=0 的整数将返回原数组，不“拉平”
arr.flat(0);
arr.flat(-10);
// [1, [2, 3], [4, [5, [6]], 7]];
// Infinity 关键字作为参数时，无论多少层嵌套，都会转为一维数组
arr.flat(Infinity);
// [", 2, 3, 4, 5, 6, 7]
toString
toString 方法是一个比较简单的方法，他是把数组每个元素转化成字符串之后直接拍平，然后通过 map 遍历每个元素，让其变成 Number 类型
const arr = [1, [2, 3], [4, [5, [6]], 7]];
arr.toString();
arr.toString().split(',');
arr.toString().split(',').map(item) => Number(item);
join
join 的操作和 toString 类似，最后也要通过 map 遍历每个元素，让其变成 Number 类型
const arr = [1, [2, 3], [4, [5, [6]], 7]];
arr.join();
arr.join().split(',');
arr.join().split(',').map(item) => Number(item);
数组转树形结构
forEach
// 需转化数组示例
data = [
{ id: '01', lable: '项目经理', pid: '' },
{ id: '02', lable: '产品leader', pid: '01' },
{ id: '03', lable: 'UIleader', pid: '01' },
{ id: '04', lable: '技术leader', pid: '01' },
{ id: '05', lable: '测试leader', pid: '01' },
{ id: '06', lable: '运维leader', pid: '01' },
{ id: '07', lable: '产品经理', pid: '02' },
{ id: '08', lable: '产品经理', pid: '02' },
{ id: '09', lable: 'UI设计师', pid: '03' },
{ id: '10', lable: '前端工程师', pid: '04' },
]
function toTree(data) {
const tree = []
const otherObj = {}
data.forEach(item => {
item.children = []
otherObj[item.id] = item
})
data.forEach(item => {
if (item.pid) {
otherObj[item.pid].children.push(item)
} else {
tree.push(item)
}
})
return tree
}
toTree(data)
双层filter
let data = [
{ id: 1, text: 't11', parentId: 0 },
{ id: 2, text: 't11', parentId: 0 },
{ id: 3, text: 't11', parentId: 1 },
{ id: 4, text: 't11', parentId: 1 },
{ id: 5, text: 't11', parentId: 3 },
{ id: 6, text: 't11', parentId: 2 }
]
function treeData (data, id, parentId, childName) {
let cloneData = JSON.parse(JSON.stringify(data))
return cloneData.filter((father) => {
let newArr = cloneData.filter((child) => {
return father[id] === child[parentId]
})
father[childName] = newArr
return father[parentId] === 0
})
}
let msg = treeData(data, 'id', 'parentId', 'childaaa')
console.log(msg)
面试题：找出多维数组最大值
function fnArr(arr){
var newArr = [];
arr.forEach((item,index)=>{
newArr.push( Math.max(...item) )
})
return newArr;
}
console.log(fnArr([
[4,5,1,3],
[13,27,18,26],
[32,35,37,39],
[1000,1001,857,1]
]));
给字符串新增方法实现功能
给字符串对象定义一个addPrefix函数，当传入一个字符串str时，它会返回新的带有指定前缀的字符串，例如：
console.log( 'world'.addPrefix('hello') ) 控制台会输出helloworld
//解答：
String.prototype.addPrefix = function(str){
return str + this;
}
console.log( 'world'.addPrefix('hello') )
找出字符串出现最多次数的字符以及次数
var str = 'aaabbbbbccddddddddddx';
var obj = {};
for(var i=0;i<str.length;i++){
var char = str.charAt(i); //charAt从字符串中获取索引值
if( obj[char] ){
obj[char]++;
}else{
obj[char] = 1;
}
}
console.log( obj );
//统计出来最大值
var max = 0;
for( var key in obj ){
if( max < obj[key] ){
max = obj[key];
}
}
//拿最大值去对比
for( var key in obj ){
if( obj[key] == max ){
console.log('最多的字符是'+key);
console.log('出现的次数是'+max);
}
}
