js经典小demo日常记录

1、js手写冒泡排序

冒泡排序从第一个开始，依次与后一个比较大小，大于后一个则调换位置，最后一个则是最大的数，每轮循环确定的最大值不参与后面的循环比对。

dealArrSort(){
	var arr = [32,12,3,2,44,100];
	for(let i=0;i<arr.length;i++){
		for(let j=0;j<arr.length-i-1;j++){
			if(arr[j]>arr[j+1]){
				let temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
	console.log("result",arr);//[2, 3, 12, 32, 44, 100]
}

2、手写数组去重

dealUniqArr(){
	let oldArr = [1,1,'a','a',null,null,undefined,undefined];
	//First Blood
	let newArrSet = Array.from(new Set(oldArr));
	//Double Kill 
	let newArrlodash = _.union(oldArr);
	//Trible Kill
	let newArrFor = [];
	for(let i = 0;i<oldArr.length;i++){
		if(-1 === newArrFor.indexOf(oldArr[i])){
			newArrFor.push(oldArr[i]);
		}
	}
	//Quadra Kill
	//Penta Kill
	console.log("reslut",newArrSet,newArrlodash,newArrFor);//[1,'a',null,undefined]
}

3、查找字符串中第一个不重复的字符

getUniqCharacter(){
	let str = '12abzba21';
	for(let i=0;i<str.length;i++){
		if(str.indexOf(str[i]) === str.lastIndexOf(str[i])){
			console.log("result",str[i])// z
			return;
		}
	}
}

4、实现延迟执行后面逻辑

等待5秒返回Promise结果，结束同步方法，执行alert

/**
* @param {number} time 毫秒数
*/
async delayTest(time) {
  await this.delay(time);
  alert(`延迟了${time / 1000}秒弹出`);
},

delay(time) {
  return new Promise(resolve => {
    setTimeout(resolve(), time);
  })
},
}

5、数组对象-利用lodash取某一个属性值存在于另一个数组对象的数据

 /**
 *获取oldObjTwo中num存在于oldObjOne的数据
 */
  getArraySameData() {
    let oldObjOne = [
      { num: 'aa', age: '25' },
      { num: 'bb', age: '25' },
      { num: 'cc', age: '25' }
    ];
    let oldObjTwo = [
      { num: 'aa', sex: '男' },
      { num: 'ab', sex: '男' },
      { num: 'bb', sex: '女' }
    ];
    //将oldObjOne中数组转换成num为key值的对象
    let oldObjOneTransform = _.keyBy(oldObjOne, 'num');
    let newObj = _.filter(oldObjTwo, (item) => {
      return oldObjOneTransform[item.num]
    })
    console.log("reslut", newObj);// [ { num: 'aa', sex: '男' }, { num: 'bb', sex: '女' }]
  }

6、查找字符串中出现次数最多的字符和出现次数

 getMaxStr() {
      let str = 'sdfsds123';
      let obj = {};
      for (let i = 0; i < str.length; i++) {
        var chart = str.charAt(i);
        if (obj[chart]) {
          obj[chart]++;
        } else {
          obj[chart] = 1;
        }
      }
      console.log("obj", obj)

      let max = 0;
      let maxChar = null;
      for (let key in obj) {
        if (obj[key] > max) {
          max = obj[key];
          maxChar = key;
        }
      }
      console.log(`最多的字符为${maxChar}，出现${max}次`);
    }

7、获取对称数

/**
*	获取1-1000之间的对称数（如 1,2，121,676，999）；
*/
getSymmetricNum(){
	for(let i = i;i<=1000;i++){//遍历1-1000
		 i= i.toString();//将数字转成字符串
		 let arr = Object.values(i);//将字符串转成数组
		 arr = arr.reverse();//反转数组
		 let str = arr.join('');//将返转后的数组转换成字符串
		 if(i == str){//比较原数字字符串是否相等
			console.log("对称数："i);
		} 
	}
}

8、函数柯里化应用，封装一个满足以下预期的函数

//期望实现一个add方法，使计算结果能够满足如下预期：
add(1)(2)(3) = 6;
add(1, 2, 3)(4) = 10;
add(1)(2)(3)(4)(5) = 15;

function add() {
    // 第一次执行时，定义一个数组专门用来存储所有的参数
    var _args = Array.prototype.slice.call(arguments);

    // 在内部声明一个函数，利用闭包的特性保存_args并收集所有的参数值
    var _adder = function() {
        _args.push(...arguments);
        return _adder;
    };

    // 利用toString隐式转换的特性，当最后执行时隐式转换，并计算最终的值返回
    _adder.toString = function () {
        return _args.reduce(function (a, b) {
            return a + b;
        });
    }
    return _adder;
}

add(1)(2)(3)                // 6
add(1, 2, 3)(4)             // 10
add(1)(2)(3)(4)(5)          // 15
add(2, 6)(1)                // 9

仅记录所用～～～～～