- 多维数组转一维数组
var arr = [1,2, [1,2,3],4,5,[5,6,[1,2]],7,8]
// 转字符串后转回数组，此时数组值为字符串，然后用map转number
let arr1 = arr.join(',').split(',')
let res = arr1.map(item => Number (item))
// 方法二递归
var arr = [1,2, [10,20,30],4,5,[15,16,[21,31]],7,8]
var res = []
function fun (data){
for(let item of data) {
if(item instanceof Array){
fun(item)
} else {
res.push(item)
}
}
return res
}
console.log(fun(arr))
2.排序
// 1.冒泡排序
let arr = [1,3,6,2,10]
function fun (arr){
for (var i=0;i<arr.length-1;i++){
//控制每比较的次数
for (var j=0;j<arr.length-1-i;j++){
if (arr[j]<arr[j+1]){
// 或es6的数组解构语法
[arr[j], arr[j+1]] = [arr[j+1], arr[j]]
}
}
}
return arr
}
// 2.快速排序
// //快排
var arr = [2,5,1,4,9,10]
function fun (arr) {
var arr1 = []
var cindex = Math.floor(arr.length / 2)
var c = arr.splice(cindex, 1);
for (var i = 0; arr.length > i; i++){
if (arr[i] > c){
arr1.push(arr[i])
} else {
arr1.unshift(arr[i])
}
}
arr1.splice(cindex-1, 0, ...c)
return arr1
}
3.字符串中重复最多的字符
var str = 'aaabbbbccd' 或 var str = [1,1,1,1,2,2,3,4]
var obj = {} //转成对象格式
for(let i = 0; str.length > i; i++){
if(!obj[str[i]]){ //对象key值不存在时，新加入value默认1
obj[str[i]] = 1
}else {
obj[str[i]]++ // 存在自加
}
}
console.log(obj) // {a:3;b:4;c:2;d:1}
var max = 0 // 最多次数即对象value最大值
var n = '' // 最大值的key
for(var j in obj) {
if(obj[j] > max){
max = obj[j]
n = j
}
}
4.json对象去重函数
function uniqueArray(arr,key){
// new_arr数组是存放key值的对象，用于排除重复的对象
var new_arr=[];
// result用于存放new_arr排除后没有重复对象的值
var result=[];
for(var i=0; i<arr.length; i++){
// new_arr中不包含key值才能进入
if(!new_arr.includes(arr[i][key])){
//如果没有找到就把这个key放到arr里面，以便下次循环时用
new_arr.push(arr[i][key]);
//result中不存在的项push进去
result.push(arr[i]);
}
}
return result;
}
5.浅拷贝与深拷贝
1）深复制在计算机中开辟了一块内存地址用于存放复制的对象，
2）而浅复制仅仅是指向被复制的内存地址，如果原地址中对象被改变了，那么浅复制出来的对象也会相应改变。
//1.浅拷贝
ES6：Object.assign()
数组：
let arr = [1, 2, 3]
let copy_arr = []
1.copy_arr = Array.from(arr)
2.copy_arr = [...arr]
3.for(var i=0; i<arr.length; i++){
copy_arr[i]=arr[i];
}
对象：
let obj = {name: 'zhangsan',sex: '男'}
let copy_obj = {}
for(var i in obj){
copy_obj[i] = obj[i]
}
//2.深拷贝--递归复制
function deepCopy(obj){
let result = Array.isArray(obj)?[]:{};
if(obj && typeof obj === 'object'){
for(let key in obj){
if(obj.hasOwnProperty(key)){
// 如果key还是对象或数组继续调用该方法
if(obj[key]&&typeof obj[key]==='object'){
result[key]=deepCopy(obj[key]);
}else{
result[key]=obj[key];
}
}
}
}
return result;
}
6.倒计时
// 倒计时10秒
//1.延时器实现
var time = 10
var timer = setInterval(() => {
if(time>1){
time --
} else {
time = 0
clearInterval(timer)
}
console.log(time)
},1000)
//2.定时器实现
var time = 10
function fun(){
var timer = setTimeout(fun,1000)
if(time>1){
time --
} else {
time = 0
clearTimeout(timer)
}
console.log(time)
}
fun()
Json 对象，判断两个value值相等
function uniqueArray(arr,key,val){
// new_arr数组是存放key值的对象，用于排除重复的对象
var new_arr=[];
// result用于存放new_arr排除后没有重复对象的值
var result=[];
for(var i=0; i<arr.length; i++){
arr[i][key] = arr[i][key] - 0
arr[i][val] = arr[i][val] - 0
// new_arr中不包含key,val值才能进入
if(new_arr.includes(arr[i][key]) && new_arr.includes(arr[i][val])){
arr[i][val] += (Math.random() * 0.0001)
result.push(arr[i]);
} else {
new_arr.push(arr[i][key]);
new_arr.push(arr[i][val]);
result.push(arr[i]);
}
}
return result;
}
6.多层嵌套json对象添加属性
// 方法一 递归函数
// data: json对象数据
// beforeActive：添加的属性
dataFormat(data) {
if (!data.hasOwnProperty('beforeActive')) {
// data['tag'] = 'beforeActive';
data.beforeActive = true
}
// 要返回其枚举自身属性的对象
const propArr = Object.keys(data);
propArr.forEach(item => {
if (typeof data[item] === 'object') {
this.dataFormat(data[item]);
}
});
return data;
};
// 方法二
// obj为json对象，addkey：添加的属性。addvalue: 添加的属性值
mapObj(obj, addkey, addvalue){
for(let key in obj){
if (key === 'children'
&& obj.hasOwnProperty("children")
&& obj[key] instanceof Object
&& !obj instanceOf Array) {
obj[key][addkey] = addvalue
mapObj(obj[key],addkey,addvalue)
}
}
}
// 解析url
function analysisUrl(url){
let hash = url.slice(url.indexOf('?')+1).split('&')
let params = {}
for(let i in hash){
hash[i] = hash[i].split("=")
params[hash[i][0]]=hash[i][1]
}
return params
}
