SOURCE

function isNull(param) {
    return param === null
}

function isUndefined(param) {
    return param === undefined
}

function isNumber(param) {
    if (typeof param === 'number') {
        return param === 0 || !!param
    } else {
        return false
    }
}

function isString(param) {
    return typeof param === 'string'
}

function isBoolean(param) {
    return param === true || param === false
}

function isTrue(param) {
    return param === true
}

function isFalse(param) {
    return param === false
}

function isObject(param) {
    return typeof param === 'object' && param !== null
}

function isPlainObject(param) {
    return Object.prototype.toString.call(param) === '[object Object]'
}

function isFunction(param) {
    return Object.prototype.toString.call(param) === '[object Function]'
}

function isArray(param) {
    return Object.prototype.toString.call(param) === '[object Array]'
}

// 辅助工具函数： 测试
function test(describe, callback) {
    if (callback()) {
        let message = '%c ' + describe + ': √';
        console.log(message, 'color:#22cd2f;')
    } else {
        let message = '%c ' + describe + ': ×';
        console.log(message, 'color:#f00;font-weight:bold;')
    }
}

function equal(a, b) {
    return a === b
}

function notEqual(a, b) {
    return a !== b
}

test('null是null', () => {
    return equal(isNull(null), true)
});
test('"null"不是null', () => {
    return equal(isNull('null'), false)
});
test('undefined不是null', () => {
    return equal(isNull(undefined), false)
});
test('undefined是undefined', () => {
    return equal(isUndefined(undefined), true)
});
test('null不是undefined', () => {
    return equal(isUndefined(null), false)
})
test('0是数字', () => {
    return equal(isNumber(0), true)
});
test('1是数字', () => {
    return equal(isNumber(1), true)
});
test('-1.2是数字', () => {
    return equal(isNumber(-1.2), true)
});
test('NaN不是数字', () => {
    return equal(isNumber(NaN), false)
})
test('"123"是字符串', () => {
    return isTrue(isString('123'))
})
test('数字123不是字符串', () => {
    return isFalse(isString(123))
})
test('true 是 boolean', () => {
    return isTrue(isBoolean(true))
})
test('false 是 boolean', () => {
    return isTrue(isBoolean(false))
})
test('0 不是 boolean', () => {
    return isFalse(isBoolean(0))
})
test('1 不是 boolean', () => {
    return isFalse(isBoolean(1))
})
test('{}是object', () => {
    return isTrue(isObject({}))
})
test('Math是object', () => {
    return isTrue(isObject(Math))
})
test('[]是object', () => {
    return isTrue(isObject([]))
})
test('{} 是 plain object', () => {
    return isTrue(isPlainObject({}))
})
test('Math 不是 plain object', () => {
    return isFalse(isPlainObject(Math))
})
test('[] 不是 plain object', () => {
    return isFalse(isPlainObject([]))
})
test('null不是对象', () => {
    return isFalse(isObject(null))
})
test('123不是对象', () => {
    return isFalse(isObject(123))
})
test('parseInt是函数', () => {
    return isTrue(isFunction(parseInt))
})
test('Function不是函数', () => {
    return isTrue(isFunction(Function))
})
test('[]是数组', () => {
    return isTrue(isArray([]))
})
test('{1:22}不是数组', () => {
    return isFalse(isArray({1: 22}))
})