Programming

kangduu大约 5 分钟

使用JavaScript或jQuery实现一个无限级导航栏菜单

变量交换值的四种方式（不采用中间变量）

如何让 a=1,b=2 的值交换，不可使用中间变量

算术运算
```
a = a + b;
b = a - b;
a = a - b;
```
异或运算
```
a = a ^ b;
b = a ^ b;
a = a ^ b;
```
ES6解构
```
[a,b] = [b,a]
```

数组

a=[a,b];
b=a[0]
a=a[1];
// 必须先赋值 b

写一个正则表达式，获取字符串中所有数字字串

'dhsj32332fdahjo2222dfs3';
// [ '32332', '2222', '3' ]

// answer
'dhsj32332fdahjo2222dfs3'.match(/\d+/g)

正则表达式open in new window

字符串压缩

// 源str
let str = 'dadsdsddswwwwda';

// 压缩后 
_str = 'd1a1d1s1d2s1w4d1a1';

//规则
if(_str.length < str.length ) return _str;
else return str

// 数组的当前位与下一位比较
function compress(str) {
  if (typeof str !== 'string') return str
  let res = '', count = 1, strArr = str.split('');
  strArr.forEach((val, i) => {
    let nextVal = strArr[i + 1];
    if (nextVal === val) count++;
    else {
      res += val + count + ''
      count = 1
    }
  })
  if (res.length < str.length) return res
  else return str
}

0的除法运算问题

let course = false;
let result = course / 0;
if (result) console.log(result * 2 + '2' + 4);
else console.log(!result * 2 + '2' + 4);

// result '224'

布尔值 false，在数学运算中会转换为数字0；
在js中 0 / 0 的值为 NaN；
NaN在if语句的条件语句中，表示的是false（假）；
!NaN的值为true，转换为数字是 1

获取浏览器URL中查询字符串中的参数？

根据 ? 分割参数段
通过 & 获取数据

function queryWindowHrefParams() {
  let s_href = window.location.href,
      args = s_href.split('?');

  if (args[0] == s_href) return; //无参数

  let params_arr = args[1].split('&'),
      obj = {};
  for (let i = 0; i < params_arr.length; i++) {
    let ele = params_arr[i],
        arg = ele.split('=');
    obj[arg[0]] = arg[1]
  }
  return obj;
}

javascript去除字符串的空格？

正则表达式

所有空格：只有使用正则表达式才能完全兼容所有浏览器

str = str.replace(/\s*/g,"")

两头空格：

str = str.replace(/^\s*|\s*$/g,"")

开始空格：

str = str.replacr(/^\s*/,"")

结束空格：

str = str.replacr(/\s*$/,"")

String 静态方法

局限：无法去除中间的空格

两头空格：

str.trim()

左右空格：

str.trimLeft();
str.trimRight()

使用jquery，$.trim(str)方法

无法去除中间空格

    <script src="https://cdn.bootcss.com/jquery/3.2.0/jquery.js"></script>
    <script>
        var str = ' dk au k  '
        var res = $.trim(str)
        alert('-'+res+'-') // -dk au k-
    </script>

javascript检测一个变量是String类型？

typeof(obj) === 'string'

typeof obj === "string"

obj.constructor === String

js判断字符串出现最多的字符，并统计次数

function countStr(str) {
    var obj = {};
    for (var i = 0, l = str.length, n; i < l; i++) {
        k = str.charAt(i);
        if (obj[n]) {
            obj[n]++;
        } else {
            obj[n] = 1;
        }
    }
    var m = 0, i = null;
    for (var k in obj) {
        if (obj[k] > m) {
            m = obj[k];
            i = k;
        }
    }
    return i + ':' + m;
}

睡眠函数 sleep 利用Date对象

function sleep(ms) {
    let start = Date.now();
    while ((Date.now() - start) < ms) { }
}

类型判断

function checkType(target) {
    let typeStr = typeof (target),
        template = {
            '[object Array]': 'array -> Object',
            '[object Object]': 'object -> Object',
            '[object Null]': 'null -> Object'
        };
    if (typeStr === 'function') return 'function'
    if (typeStr !== 'object') return typeStr
    else return template[Object.prototype.toString.call(target)]
}

洗牌（乱序算法）一个排好序的数组打乱

//工具类
function orderArr(len) {
  let arr = [];
  for (let i = 1; i <= len; i++) {
    arr.push(i)
  }
  return arr
}

//方法一
function sort(arr) {
  let newArr = [];
  for (let i = 0, len = arr.length; i < len; i++) {
    let j = Math.floor(Math.random() * (len - i));//【*】
    newArr[i] = arr.splice(j, 1)[0];//【*】
  }
  return newArr;
}

console.log(sort(orderArr(12)));//[ 5, 8, 6, 3, 10, 4, 12, 7, 11, 2, 1, 9 ]

// 方法二
function sort2(arr) {
  return arr.sort(function () {
    return Math.random() - 0.5;//【*】
  });
}

console.log(sort2(orderArr(16)));//[ 3, 9, 12, 14, 7, 4, 2, 1, 8, 10, 13, 6, 11, 5, 16, 15 ]

数组从小到大输出

let arr = [5, 180, 39, 100];
arr.forEach(num => {
  //原理上利用setTimeout的第二个参数，将数组值传入就能按延迟时间输出
  setTimeout(() => {
    console.log(num)
  }, num)
});

返回长度为N的随机数字符串函数

function rand(n) {
  //长度最大限制
  var max = Math.pow(10, n);
  var str = "" + parseInt(Math.random() * max);
  //长度小于N的用 “0” 补齐，以实际情况考虑是否补齐
  var count = n - str.length;
  for (var i = 0; i < count; i++) {
    str += "0";
  }
  return str
}

这个方法的一个严重问题就是：若 n 很大，Math.pow()得到的数值失真【很大】

[1, 2, 3].map(parseInt)

var arr = [1, 2, 3].map(parseInt);
console.log(arr); // ?

解析

我们知道，map方法回调函数接受三个参数【只有第一个是必须的】，我们也习惯性的只是用了第一个参数【当前正在处理的元素】，这就是隐藏的问题所在。

原式 var arr = [1,2,3].map(parseInt) ,第一反应输出结果为 [1,2,3];

之所以如此，你第一反应的执行是这样的

callback 1 => parseInt('1') => 1
callback 2 => parseInt('2') => 2
callback 3 => parseInt('3') => 3
所以： 结果 [1,2,3]  是错误答案

正确的执行过程是

callback 1 => parseInt('1',0） => 1
callback 2 => parseInt('2',1) => NaN
callback 3 => parseInt('3',2) => NaN
所以： 结果是 [1,NaN,NaN]

注意：parseInt第一个参数是字符串

涉及知识

给定一个字符串（数字或大小写字母）, 找出最长的对称的子串（如有多个，输出任意一个）。

function strRev(str) {
    return str.split('').reverse().join('');
}
function findStr(str) {
    var maxStr = "";
    if (str.length === 1 || str.length === 0 || str === strRev(str)) return str;
    for (var i = 0; i < str.length; i++) {
        for (var j = str.length; j > i; j--){
            var subStr = str.substring(i,j);
            if (subStr === strRev(subStr)){
                if (subStr.length > maxStr.length) {
                    maxStr = subStr;
                }
            }
        }
    }
    if (maxStr === str.substr(0,1)) return -1;
    return maxStr
}

console.log(findStr('q'));

给定两个数字（0-9）字符串（长度不限），求他们的乘积？

var multiply = function (num1, num2) {
  if (num1 == "0" || num2 == "0") return 0;

  var res = new Array(num1.length + num2.length);
  for (var i = 0; i < res.length; i++) {
    res[i] = 0
  }

  // var res = []
  var a = num1.split(''),
      b = num2.split('');

  for (var i = 0; i < a.length; i++) {
    for (var j = 0; j < b.length; j++) {
      res[i + j] += a[i] * b[j]
    }
  }
  console.log(res)

  var carry = 0; //进位
  var str = [];

  for (var i = 0; i < res.length; i++) {
    res[i] += carry;
    carry = parseInt(res[i] / 10);
    res[i] = res[i] % 10;
    str[i] = res[i];
  }
  str = str.reverse().join("");  

  var index = 0;
  while (str[index] === "0") {
    index++
  }
  return str.substring(index);

  // return str.substr(index, num1.length + num2.length - 1 - index)
}
console.log(multiply('600', '2000'))
```### 25 辆车分成 5 组，每场比赛最多只能 5 辆车同时比赛，请问最少进行几场比赛可以赛出前三名？	

> 第一步，A、B、C、D、E每组进行一次比赛，得到每组的排名，然后将A1、B1、C1、D1、E1分为一组（f）；【1+1+1+1+1】
>
> 第二步，f组比赛一场，假设A1>B1>C1>D1>E1,则D和E组全部淘汰，A1冠军，然后A2、A3、B1、B2、C1分为一组（g）；【1】
>
> 第三步，g组比赛分出第二、三名。

Programming

# 使用JavaScript或jQuery实现一个无限级导航栏菜单

# 变量交换值的四种方式（不采用中间变量）

# 写一个正则表达式，获取字符串中所有数字字串

# 字符串压缩

# 0的除法运算问题

# 获取浏览器URL中查询字符串中的参数？

# javascript去除字符串的空格？

# 正则表达式

# String 静态方法

# 使用jquery，$.trim(str)方法

# javascript检测一个变量是String类型？

# js判断字符串出现最多的字符，并统计次数

# 睡眠函数 sleep 利用Date对象

# 类型判断

# 洗牌（乱序算法） 一个排好序的数组打乱

# 数组从小到大输出

# 返回长度为N的随机数字符串函数

# [1, 2, 3].map(parseInt)

# 解析

# 涉及知识

# 给定一个字符串（数字或大小写字母）, 找出最长的对称的子串（如有多个，输出任意一个）。

# 给定两个数字（0-9）字符串（长度不限），求他们的乘积？