JavaScript回顾

一、JS算法

1.冒泡（Bubble Sort）

var example=[8,95,34,21,53,12];
 function sortarr(arr){
  for(i=0;i<arr.length-1;i++){
   for(j=0;j<arr.length-1-i;j++){
    if(arr[j]>arr[j+1]){
     var temp=arr[j];
     arr[j]=arr[j+1];
     arr[j+1]=temp;
    }
   }
  }
  return arr;
 }
 sortarr(example);
//当i=0的时候，里面的循环完整执行，从j=0执行到j=6,这也就是第一遍排序，结果是将最大的数排到了最后，这一遍循环结束后的结果应该是[8,34,21,53,12,95]
//当i=1的时候，里面的循环再次完整执行，由于最大的数已经在最后了，没有必要去比较数组的最后两项，这也是j<arr.length-1-i的巧妙之处，结果是[8,34,21,12,53,95]
//说到这里，规律就清楚了，每次将剩下数组里面最大的一个数排到最后面，当第一个循环执行到最后的时候，也就是i=6,此时，j=0,只需要比较数组的第一和第二项，比较完毕，返回

2.快速排序（Quick Sort）

var example=[1,4,3,8,9,6,2]
		
function quickSort(arr){
	if(arr.length<=1){
		return arr;
	}
	var left=[],right=[],current=arr.splice(0,1);
	for(let i=0;i<arr.length;i++){
		if(arr[i]<current){
			left.push(arr[i])
		}else{
			right.push(arr[i])
		}
	}
	return quickSort(left).concat(current,quickSort(right));
}
console.log(quickSort(example)); //[1, 2, 3, 4, 6, 8, 9]

//2.
function quickSort(arr,l,r){
    if(l < r){
        var i = l, j = r, x = arr[i];
        while(i<j){
            while(i<j && arr[j]>x)
                j--;
            
            if(i<j)
                //这里用i++，被换过来的必然比x小，赋值后直接让i自加，不用再比较，可以提高效率
                arr[i++] = arr[j];
            
            while(i<j && arr[i]<x)
                i++;
            
            if(i<j)
                //这里用j--，被换过来的必然比x大，赋值后直接让j自减，不用再比较，可以提高效率
                arr[j--] = arr[i];
        }
        arr[i] = x;
        
        quickSort(arr, l, i-1);
        quickSort(arr, i+1, r);
    }
}

3.统计字符串中出现次数最多的字母

//利用object的key唯一的性质和用中变量赋值获取出现最多的key和value
function findMaxDuplicateChar(str) {  
  if(str.length == 1) {
    return str;
  }
  let charObj = {};
  for(let i=0;i<str.length;i++) {
    if(!charObj[str.charAt(i)]) {
      charObj[str.charAt(i)] = 1;
    }else{
      charObj[str.charAt(i)] += 1;
    }
  }
  let maxChar = '',
      maxValue = 1;
  for(var k in charObj) {
    if(charObj[k] >= maxValue) {
      maxChar = k;
      maxValue = charObj[k];
    }
  }
  return maxChar;
}

4.数组出重

**
* unique an array 
**/
//利用object的key唯一
let unique = function(arr) {  
  let hashTable = {};
  let data = [];
  for(let i=0,l=arr.length;i<l;i++) {
    if(!hashTable[arr[i]]) {
      hashTable[arr[i]] = true;
      data.push(arr[i]);
    }
  }
  return data

}
//对象数组去重(简洁方便)
const unique= arr =>{
  let hash = {};
	return arr.reduce((item, next) => {
	  hash[next. phone]? '': hash[next.phone] = true && item.push(next);
		return item
	}, []);
}
unique(arr) 
/* [{
  id: 1,
  phone: 1880001,
  name: 'wang',
  },{
  id: 2,
  phone: 1880002,
  name: 'li',
  }] */

5.回文（单词翻转）

function checkPalindrom(str) {  
    return str == str.split('').reverse().join('');
}

二、JS对象篇

1.对象拷贝

//浅拷贝

//深拷贝
序列化
JSON.parse(JSON.stringify(obj));
//递归1
var deepCopy = function(obj) {
    if (typeof obj !== 'object') return;
    var newObj = obj instanceof Array ? [] : {};
    for (var key in obj) {
      if (obj.hasOwnProperty(key)) {
        newObj[key] = typeof obj[key] === 'object' ? deepCopy(obj[key]) : obj[key];
      }
    }
    return newObj;
  }
//递归2
function deepCopy(result, source) {
  for (var key in source) {
    var copy = source[key];
    if (source === copy) continue;//如window.window === window，会陷入死循环，需要处理一下
    if (is(copy, "Object")) {
      result[key] = arguments.callee(result[key] || {}, copy);
    } else if (is(copy, "Array")) {
      result[key] = arguments.callee(result[key] || [], copy);
    } else {
      result[key] = copy;
    }
  }
    
  return result;
  
  function is(obj, type) {
    var toString = Object.prototype.toString;
    return (type === "Null" && obj === null) ||
      (type === "Undefined" && obj === undefined ) ||
      toString.call(obj).slice(8, -1) === type;
  }

}

三、JS数组篇