## 解析 URL Params 对象

尽可能的全面正确的解析一个任意 url 的所有参数为 Object，注意边界条件的处理。

```javascript
let url =
  'http://www.domain.com/?user=admin&id=123&id=456&city=%E5%8C%97%E4%BA%AC&enabled';

parseParam(url);
/* 要求输出结果
{ 
    user: 'anonymous',
    id: [ 123, 456 ], // 重复出现的 key 要组装成数组，能被转成数字的就转成数字类型
    city: '北京', // 中文需解码
    enabled: true, // 未指定值得 key 约定为 true
}
*/
```

## trim 实现去除字符串首尾指定字符

```javascript
String.prototype.trim = function(char, type) {
  if (char) {
    if (type == 'left') {
      return this.replace(new RegExp('^\\' + char + '+', 'g'), '');
    } else if (type == 'right') {
      return this.replace(new RegExp('\\' + char + '+$', 'g'), '');
    }
    return this.replace(
      new RegExp('^\\' + char + '+|\\' + char + '+$', 'g'),
      ''
    );
  }
  return this.replace(/^\s+|\s+$/g, '');
};

// 去除字符串首尾的全部空白
var str = ' Ruchee ';
console.log('xxx' + str.trim() + 'xxx'); // xxxRucheexxx

// 去除字符串左侧空白
str = ' Ruchee ';
console.log('xxx' + str.trim(' ', 'left') + 'xxx'); // xxxRuchee xxx

// 去除字符串右侧空白
str = ' Ruchee ';
console.log('xxx' + str.trim(' ', 'right') + 'xxx'); // xxx Rucheexxx

// 去除字符串两侧指定字符
str = '/Ruchee/';
console.log(str.trim('/')); // Ruchee

// 去除字符串左侧指定字符
str = '/Ruchee/';
console.log(str.trim('/', 'left')); // Ruchee/

// 去除字符串右侧指定字符
str = '/Ruchee/';
console.log(str.trim('/', 'right')); // /Ruchee
```

## 判断一个字符串是否是回文?

```javascript
/*
 * 方法一
 * @return boolean
 */
function checkPalindrom(str) {
  return (
    str ==
    str
      .split('')
      .reverse()
      .join('')
  );
}
console.log(checkPalindrom('abccba')); // true
console.log(checkPalindrom('abcdecba')); // false

/*
 * 方法二
 * @return boolean
 */
function checkPalindrom(str) {
  let newStr = '';
  for (let i = str.length - 1; i >= 0; i--) {
    newStr += str[i];
  }
  console.log(newStr === str);
}
checkPalindrom('abccba'); // true
checkPalindrom('abcdecba'); // false
```

## 去掉一组整型数组重复的值

```javascript
输入: [1, 13, 24, 11, 11, 14, 1, 2];
输出: [1, 13, 24, 11, 14, 2];

function unique(arr) {
  let newArray = [];
  let obj = {};

  for (let i = 0; i < arr.length; i++) {
    if (!obj[arr[i]]) {
      obj[arr[i]] = true;
      newArray.push(arr[i]);
    }
  }
  return newArray;
}
```

## 统计一个字符串出现最多的字母和出现的次数

```javascript
  输入：absadaaaa
  输出 ： a, 6

  function computedStr (str) {
    let charObj = {}
    for (let i = 0; i < str.length; i++) {
      if (!charObj[str[i]]) {
        charObj[str[i]] = 1
      } else {
        charObj[str[i]] += 1
      }
    }

    let maxCharStr = ''
    let maxCount = 0
    console.log(charObj)
    for (let i in charObj) {
      if (charObj[i] > maxCount) {
        maxCharStr = i
        maxCount = charObj[i]
      }
    }
    return maxCharStr + ',' + maxCount
  }

  console.log(computedStr('abaaaasdad'))   // a,6

```

## 统计一个字符串出现的字母和出现的次数

```javascript
 输入: aaabbbccdddd
 输入: {a: 3, b: 3, c: 2, d: 4}

 var strs = 'aaabbbccdddd'
 var result = str.split('').reduce((acc, curValue) => {
  acc[curValue]++ || (acc[curValue] = 1)
  return acc
 }, {})

 // 或者想装逼可以这么写
 var strs = 'aaabbbccdddd'
 var result = str
  .split('')
  .reduce((acc, curValue) => (acc[curValue]++ || (acc[curValue] = 1), acc), {})

 console.log(result) // {a: 3, b: 3, c: 2, d: 4}

```

## 最大子序和

```javascript
  输入: [-2,1,-3,4,-1,2,1,-5,4],
  输出: 6
  解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

  var maxSubArray = function(nums) {
    let max = nums[0]
    let sum = nums[0]

    for (let i = 1; i < nums.length; i++) {
      if (sum + nums[i] > nums[i]) { // 如果 -2 + 1 > 1
        sum = sum + nums[i]
      } else {
        sum = nums[i]
      }
      max = Math.max(max, sum)
    }

    return max
  }
  let nums = [-2,1,-3,4,-1,2,1,-5,4]
  console.log(maxSubArray(nums))
```

## 缺省数字

```javascript
给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。

输入: [3,0,1]
输出: 2

输入: [9,6,4,2,3,5,7,0,1]
输出: 8

```

```javascript
  思路一
   - 对nums做排序，从i=0的位置开始遍历数组
   - 如果i+1位置的元素减去i位置的元素为1，则i后移
   - 否则循环停止，最后返回i位置的元素加1即所需的返回值

  var missingNumber = function (nums) {
    for (let i = 0; i < nums.length; i++) {
      for (let j = 0; j < nums.length-i-1; j++) {
        if (nums[j] > nums[j+1]) {
          let temp = nums[j+1]
          nums[j+1] = nums[j]
          nums[j] = temp
        }
      }
    }
    if (nums[0] != 0) {
      return 0;
    }
    let res = null
    for (let q = 0; q < nums.length-1; q++) {
      if (nums[q+1] - nums[q] == 1) {
        continue
      } else {
        res = nums[q]+1
        break
      }
    }
    return res
  }

  思路二 (较好)
   - 用等差数列求和的方式算出前n个数的和
   - 然后依次减去数组中的每一个数，最后剩下的就是缺失的数值

  var missingNumber = function (nums) {
    let n = nums.length+1
    let sum = n * (n-1) / 2
    for (let i = 0; i < nums.length; i++) {
      sum = sum - nums[i]
    }
    return sum
  }

  思路三
   - 新建一个长度为n的数组arr都是0，然后依次遍历一遍nums
   - 把相应位置的0变成1，然后遍历一下arr看看哪个地方还是0，那么这个地方的下表对应的数就是缺失的数值了

```