[JavaScript知识库]JavaScript高级第一节

前言：因为是js高级，写的是个人觉得重要的，所以内容写的比较简单，没有细讲，主要还是看代码。

目录：

1. 作用域
2. 浮点数加减乘除运算
3. 递归函数
4. 字符串相关算法
   1. 统计字符串出现次数最多字符
   2. 字符串去重
5. js判断变量为空
   1. 空对象
   2. 空数组
   3. 空字符串
   4. null 和undefined

1.作用域

定义：在 JavaScript 中, 作用域为可访问变量，对象，函数的集合。

例子：第一行的变量a是全局变量，第二个a为show()函数中变量。如果在立即执行函数中直接打印a会输出2，立即函数调用fn()函数，会输出1，原因是先从该函数内找，找不到就去创建该作用域（即函数）的作用域找

var a = 1
function fn(){
    console.log(a);
}
function show(fn){
    var a = 2;
    (function(){
        fn()
    })()
}
show(fn)   //1

2.浮点数加减乘除运算

思路：把小数变整数计算? ? ?小数 * 倍数, 倍数 = 10的小数点后最长的长度平方

代码如下：

第一步，找到小数点后的长度

function getlength(num) {
    let length = 0;
    try {
    length = String(num).split('.')[1].length
    } catch (e) {
    //TODO handle the exception
    }
    return length;
}

第二步， 找到乘的倍数

function getbeishu(numa, numb) {
    let lena = getlength(numa)
    let lenb = getlength(numb)
    let longer = Math.max(lena, lenb);
    return Math.pow(10, longer);
}

第三步，加减乘除运算

function add(num1, num2) {
    let beishu = getBeishu(num1, num2);
    return (num1 * beishu + num2 * beishu) / beishu;
}

function sub(num1, num2) {
    let beishu = getBeishu(num1, num2);
    return (num1 * beishu - num2 * beishu) / beishu;
}

function mul(num1, num2) {
    let numlena = getlength(num1);
    let numlenb = getlength(num2);
    let num1toStr = String(num1);
    let num2toStr = String(num2);
    return Number(num1toStr.replace('.', '')) * Number(num2toStr.replace('.', '')) / Math.pow(10, numlena + numlenb)
}

function dev(num1, num2) {
    let numlena = getlength(num1);
    let numlenb = getlength(num2);
    let num1toStr = String(num1);
    let num2toStr = String(num2);
    return Number(num1toStr.replace('.', '')) / Number(num2toStr.replace('.', '')) / Math.pow(10, numlena - numlenb)
}

console.log(add(0.01, 0.0002));
console.log(sub(0.01, 0.0002));
console.log(mul(0.01, 0.345));
console.log(dev(0.01, 0.0002));

3.递归函数

定义：指函数直接或间接调用函数本身，则称该函数为递归函数。递归函数必须要有结束条件，简单点说就是一个函数中有一个终止递归的条件，一个需要一直执行的递归内容，最后调用自己，如果没有终止条件则会一直调用函数。

例子1：偶数求和

function sum(num) {
    if (num % 2 != 0) {
        num--
    }
    if (num == 1) {
        return 1
    } else if (num == 0) {
        return 0
    } else {
        return num + sum(num - 2)
    }
}
console.log(sum(10))

例子2：斐波那契数列

function fn(n) {
    if (n == 0 || n == 1) return 1
    return fn(n - 1) + fn(n - 2)
}
console.log(fn(4)); //1 1 2 3 5 8 13

4.字符串相关算法

统计字符串中字符出现次数最多

方法1：利用对象键值对

function getmax(str) {
    let obj = {}
    for (let i = 0; i < str.length; i++) {
        //如果没有该字符的键就加,以字符为键，1位值, 如{ 'h', 1 }
        if (!obj[str[i]]) {
            obj[str[i]] = 1
        } else { //如果有，就对该键的值加1，如{ 'h', 2}
            obj[str[i]]++
        }
    }
    let maxnum = 0
    let maxstr = ''
    //遍历对象找出最大的值和对应的键
    for (let item in obj) {
        if (obj[item] > maxnum) {
            maxnum = obj[item]
            maxstr = item
        }
    }
    console.log(maxnum);
    console.log(maxstr);
}
let str = 'helloworld'
getmax(str)

方法2：利用str.lastIndexOf()方法

let maxnum = 0
let maxstr = ''

function getmax(str) {
    //将字符串转数组,排序后,再转字符串 如helloworld => dehllloorw 让相同字符在一起
    let newstr = str.split('').sort().join('')
    for (let i = 0; i < newstr.length; i++) {
        //当前字符最后出现的位置 - 当前字符的位置 + 1 = 出现次数
        nownum = newstr.lastIndexOf(newstr[i]) - i + 1
        //找最大出现次数
        if (nownum > maxnum) {
            maxnum = nownum
            maxstr = newstr[i]
        }
        i = newstr.lastIndexOf(newstr[i])
    }
}
let str = 'helloworld'
getmax(str)
console.log(maxstr);
console.log(maxnum);

字符串去重

方法1：对象键值对

function deduplication(str) {
    let obj = {}
    let arr = []
    for (let i = 0; i < str.length; i++) {
        if (!obj[str[i]]) { //如果对象没有该字符的键就增加键，并放入数组
            obj[str[i]] = true
            arr.push(str[i])
        }
    }
    return arr.join('')
}
let str = 'helloworld'
console.log(deduplication(str));

方法2：利用call()方法调用数组filter()方法过滤掉重复的字符

function deduplication(str) {
    //通过call()函数调用数组的filter()方法
    let newstr = Array.prototype.filter.call(str, function(item, index, arr) {
        //通过indexOf()函数 判断是否是第一次出现的字符
        return arr.indexOf(item) === index
    })
    return newstr.join('')
}
let stra = 'helloworld'
console.log(deduplication(stra));

5.js判断变量为空

第一、空对象

方法1：es6中可以使用Object.keys(obj)

var obj = {};
var arr = Object.keys(obj);
alert(arr.length == 0); //true 为空， false 不为空

方法2：将json对象转化为json字符串，再判断该字符串是否为"{}"

var data = {};
var b = (JSON.stringify(data) == "{}");
alert(b);   //true 为空， false 不为空

第二、空数组

方法1：

let arrz = []
if (Array.prototype.isPrototypeOf(arrz) && arrz.length === 0) {
    console.log('true');
}

方法2：

var item = [];
console.log(JSON.stringify(item) === '[]'); // true

第三、空字符串

let str = ''
if (str === '' || str.trim().length == 0) {
    console.log('true');
}

第四 null 和undefined

if (obj == null) {} // 判断null或者undefined
if (obj === undefined) {} //只能判断undefined