js知识点～js数据类型判断

　　JavaScript 中有七种内置类型：

　　　　1、空值 (null)

　　　　2、未定义 (undefined)

　　　　3、布尔值 (boolean)

　　　　4、数字 (number)

　　　　5、字符串 (string)

　　　　6、对象 (object)

　　　　7、符号 (symbol，ES6中新增)

1、获取数据类型

/**
     *  **** getType 获取数据的类型 **
     * 返回值的元类型,返回值的 constructor 名的小写字母。undefined 或者 null 将会返回 undefined 或 null。
     * @param v 为传入判断的数据
     * @return string 返回数据类型
     */
    const getType = v => v === undefined ? 'undefined' : v === 'null' ? 'null' : v.constructor.name.toLowerCase();
    console.log("=======> getType")
    console.log(getType(new Set([1, 2, 3]))); // set
    console.log(getType(new Array(1, 2, 3))); // array
    console.log(getType(Object.create({ a: 1 }))); // object
    console.log(getType("1212")); // string
    console.log(getType(1212)); // number
    console.log(getType(true)); // boolean
    console.log(getType(Symbol('x'))); // symbol

    /**
     *  **** isType 判断数据的类型 **
     * 返回值的元类型,返回值的 constructor 名的小写字母。undefined 或者 null 将会返回 undefined 或 null。
     * @param v 为传入判断的数据
     * @return string 返回数据类型
     */
    const isType = val => Object.prototype.toString.call(val).slice(8, -1).toLowerCase();
    console.log("=======> isType")
    console.log(isType("1212")) // string
    console.log(isType(1212)) // number
    console.log(isType(true)) // boolean
    console.log(isType(null)) // null
    console.log(isType(undefined)) // undefined
    console.log(isType(NaN)) // number
    console.log(isType(Symbol('x'))) // symbol

2、检测提供的 val 是否属于指定的类型 type

/**
     *  **** is 检测提供的 val 是否属于指定的类型 type。 **
     * 运用 Array.includes() 确保 undefined 和 null 被排除在外，并且比较 val 的 constructor 属性和指定的类型 type 是否相等。
     * @param type 指定的类型
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const is = (type, val) => ![, null].includes(val) && val.constructor === type;
    console.log("=======> is")
    console.log(is(Array, [1])); // true
    console.log(is(ArrayBuffer, new ArrayBuffer())); // true
    console.log(is(Map, new Map())); // true
    console.log(is(RegExp, /./g)); // true
    console.log(is(Set, new Set())); // true
    console.log(is(WeakMap, new WeakMap())); // true
    console.log(is(WeakSet, new WeakSet())); // true
    console.log(is(String, '')); // true
    console.log(is(String, new String(''))); // true
    console.log(is(Number, 1)); // true
    console.log(is(Number, new Number(1))); // true
    console.log(is(Boolean, true)); // true
    console.log(is(Boolean, new Boolean(true))); // true

3、检测数据是否为布尔值(Boolean)

/**
     *  **** isBoolean 检测提供的变量是否是布尔类型。 **
     * 用 typeof 来检测 val 是否应该归为布尔原型。
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isBoolean = val => typeof val === 'boolean';
    console.log("=======> isBoolean")
    console.log(isBoolean(null)); // false
    console.log(isBoolean(false)); // true
    console.log(isBoolean(undefined)); // false

4、检测数据是否为空

　　注意： 检测提供的变量是否为 null 或者变量的 length 属性是否等于0

/**
     *  **** isEmpty 检测数据是否为空 **
     *  注意：检测提供的变量是否为 null 或者变量的 length 属性是否等于0。
     *  如果 value 是一个空的 object 、collection 、map 或者 set ，或者没有任何可枚举的属性以及任何没有被当做 collection 的类型都返回 true 。
     *  **** 数字类型与布尔值类型，直接检测为空, undefined, null 也为空
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isEmpty = val => val == null || !(Object.keys(val) || val).length;
    console.log("=======> isEmpty")
    console.log(isEmpty(new Map())); // true
    console.log(isEmpty(new Set())); // true
    console.log(isEmpty([])); // true
    console.log(isEmpty({})); // true
    console.log(isEmpty('')); // true
    console.log(isEmpty([1, 2])); // false
    console.log(isEmpty({ a: 1, b: 2 })); // false
    console.log(isEmpty('text')); // false
    console.log(isEmpty(123)); // true
    console.log(isEmpty('123')); // false
    console.log(isEmpty(true)); // true
    console.log(isEmpty(false)); // true
    console.log(isEmpty(undefined)); // true
    console.log(isEmpty(null)); // true

5、检测数据是否为function

/**
     *  **** isFunction 检测提供的变量的类型是否是 function 。 **
     *  使用 typeof 进行判断给定的变量是否是 function 原型。
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isFunction = val => typeof val === 'function';
    console.log("=======> isFunction")
    console.log(isFunction('x')); // false
    console.log(isFunction(x => x)); // true

6、检测数据是否为null 或者 undefined

/**
     *  **** isNil 检测提供的变量的类型是否是 null 或者 undefined 。 **
     *  使用严格相等运算符去对变量进行是否等于 null 或者 undefined 的检测。
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isNil = val => val === undefined || val === null;
    console.log("=======> isNil")
    console.log(isNil(null));  // true
    console.log(isNil(undefined));  // true
    console.log(isNil("1212")); // false

7、检测数据是否为null

/**
     *  **** isNull 检测提供的变量的类型是否是 null。 **
     *  使用严格相等运算符去对变量进行是否等于 null的检测。
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isNull = val => val === null;
    console.log("=======> isNull")
    console.log(isNil(null));  // true
    console.log(isNil(undefined));  // false
    console.log(isNil("1212")); // false

8、检测数据是否为undefined

/**
     *  **** isUndefined 检测提供的变量的类型是否是 undefined **
     *  使用严格相等运算符去对变量进行是否等于 undefined的检测。
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isUndefined = val => val === undefined;
    console.log("=======> isUndefined")
    console.log(isUndefined(null));  // false
    console.log(isUndefined(undefined));  // true
    console.log(isUndefined("1212")); // false

9、检测数据是否为number

/**
     *  **** isNumber 检测提供的变量的类型是否是 number **
     *  使用严格相等运算符去对变量进行是否等于 number的检测。
     *  注意： NaN 类型也是number
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isNumber = val => typeof val === 'number';
    console.log("=======> isNumber")
    console.log(isNumber('1'));  // false
    console.log(isNumber(1));  // true
    console.log(isNumber(NaN)); // true
    console.log(isNumber([1, 3])); // false
    console.log(isNumber(null)); // false
    console.log(isNumber(undefined)); // false

10、检测数据是否为object

/**
     *  **** isObject 检测给定的变量是否为 object 类型。**
     *  使用 Object 的 constructor 对给定的变量构造一个对象。如果变量是 null 或者 undefined ，将会生成一个空对象。否则生成一个类型和变量本身相等的对象。
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isObject = obj => obj === Object(obj);
    console.log("=======> isObject")
    console.log(isObject([1, 2, 3, 4])); // true
    console.log(isObject([])); // true
    console.log(isObject(['Hello!'])); // true
    console.log(isObject({ a: 1 })); // true
    console.log(isObject({})); // true
    console.log(isObject(x => x)); // true
    console.log(isObject(true)); // false

11、检测数据是否为string

/**
     *  **** isString 检测提供的变量的类型是否是 string **
     *  使用严格相等运算符去对变量进行是否等于 string
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isString = val => typeof val === 'string';
    console.log("=======> isString")
    console.log(isString('10')); // true
    console.log(isString(10)); // false
    console.log(isString(true)); // false

12、检测数据是否为symbol

/**
     *  **** isSymbol 检测一个变量是否是 symbol 类型。 **
     *  使用严格相等运算符去对变量进行是否等于 symbol的检测。
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isSymbol = val => typeof val === 'symbol';
    console.log("=======> isSymbol")
    console.log(isSymbol('x')); // false
    console.log(isSymbol(Symbol('x'))); // true

13、检测数据是否为合法的 JSON

　　　　注意：null 也为合法的json， 传入字符串数据(需要排除布尔值，数字 =》返回全部为true)

/**
     *  **** isValidJSON 检测一个变量是否是合法的 JSON 。 **
     *  使用 JSON.parse() 结合 try… catch 对变量进行判断，如果能正确解析返回 true ，否则返回 false 。
     * 注意： null 也为合法的json， 传入字符串数据(需要排除布尔值，数字 =》返回全部为true)
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isValidJSON = obj => {
        try {
            JSON.parse(obj);
            return true;
        } catch (e) {
            return false;
        }
    };
    console.log("=======> isValidJSON")
    console.log(isValidJSON('{"name":"Adam","age":20}')); // true
    console.log(isValidJSON('{"name":"Adam",age:"20"}')); // false
    console.log(isValidJSON(null)); // true
    console.log(isValidJSON(undefined)); // false
    console.log(isValidJSON(122)); // true
    console.log(isValidJSON('122')); // true
    console.log(isValidJSON('')); // false
    console.log(isValidJSON(false)); // true
    console.log(isValidJSON(false)); // true

14、检测数据是否为NaN

　　注意：以下4种方法中，只有 => ES6中提供的isNaN()方法，可以自动转换为Number类型，其他则不自动转化。

/**
     *  **** isStrictNaN 检测提供的变量的类型是否是 NaN **
     *  注意：不存在类型转换
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const isStrictNaN = val => val !== val;
    console.log("=======> isStrictNaN")
    console.log(isStrictNaN(NaN)); // true
    console.log(isStrictNaN('a')); // false
    console.log(isStrictNaN(null)); // false
    console.log(isStrictNaN(undefined)); // false
    console.log(isStrictNaN(true)); // false
    console.log(isStrictNaN(123)); // false

    /**
     *  **** hasNaN 检测提供的变量的类型是否是 NaN **
     *   ES6中提供的Object.is()方法。
     *  注意：不存在类型转换
     * @param val 为传入判断的数据
     * @return Boolean 返回数据类型
     */
    const hasNaN = val => Object.is(val, NaN);
    console.log("=======> hasNaN")
    console.log(hasNaN(NaN)); // true
    console.log(hasNaN('a')); // false
    console.log(hasNaN(null)); // false
    console.log(hasNaN(undefined)); // false
    console.log(hasNaN(true)); // false
    console.log(hasNaN(123)); // false


    /**
     *  **** isNaN 检测提供的变量的类型是否是 NaN **
     *   ES6中提供的Number.isNaN()
     * 注意：不存在类型转换
     */
    console.log("=======> Number.isNaN")
    console.log(Number.isNaN(NaN)); // true
    console.log(Number.isNaN('a')); // false
    console.log(Number.isNaN(null)); // false
    console.log(Number.isNaN(undefined)); // false
    console.log(Number.isNaN(true)); // false
    console.log(Number.isNaN(123)); // false

    /**
     *  **** isNaN 检测提供的变量的类型是否是 NaN **
     *   ES6中提供的isNaN()。
     * 注意：存在类型转换，转化为Number类型
     */
    console.log("=======> isNaN")
    console.log(isNaN(NaN)); // true
    console.log(isNaN('a')); // false
    console.log(isNaN(null)); // false
    console.log(isNaN(undefined)); // true
    console.log(isNaN(true)); // false
    console.log(isNaN(123)); // false