JS各种 数据类型的识别 与 筛选、提取

JS各种 数据类型的识别 与 筛选、提取： 

'use strict';
        // 数据类型数组
        let arr = ['100px', 'abc' - 6, [], -98765, 34, -2, 0, '300', , function () { alert(1); }, null, document, [], true, '200px' - 30, '23.45元', 5, Number('abc'), function () { alert(3); }, 'xyz' - 90];

        let string = '', number = [], object = '', functs = '', boolean = '', isnan = [], isnum = [], maxnum = -Infinity;

        arr.forEach((item, index) => {

            // NaN的下标位置
            if (isNaN(parseInt(item)) && typeof item == 'number') {
                isnan.push(index);
            };

            // 可转成数字的项
            if (!isNaN(parseInt(item))) {
                isnum.push(item)
            };

            // 最大的数字
            if (Number(item) > maxnum) {
                maxnum = Number(item)
            };

            switch (typeof (item)) {

                case 'string':
                    // if (!isNaN(Number(item))) {
                    //     number.push(Number(item));
                    // } else {
                    //     string += item + ' ';
                    // };
                    // 所有的字符;
                    string += item + ' ';
                    break;

                case 'number':
                    // 所有的数字;
                    if (!isNaN(Number(item))) {
                        number.push(item);
                    };
                    break;

                case 'object':
                    // 所有的对象;
                    object += item + ' ';
                    break;

                case 'function':
                    // 所有的函数;
                    functs += item + ' ';
                    break;

                case 'boolean':
                    // 所有的布尔;
                    boolean += String(item) + ' ';
                    break;

                default:
                    break;
            };
        });

        console.log(`所有的字符：${string}`);

        console.log(`可转为数字：${isnum}`);

        console.log(`所有的数字：${number.join(' ')}`);

        console.log(`最大的数字：${maxnum || Math.max.apply(null, number)}`);

        console.log(`最小的数字：${Math.min.apply(null, number)}`);

        console.log(`所有的对象：${object}`);

        console.log(`所有的函数：${functs}`);

        console.log(`所有的布尔：${boolean}`);

        console.log(`NaN的位置：${isnan}`);

 

JS如何判断变量数据类型：

1、Object.prototype.toString.call()  该特性可以判断多种数据类型!

function dataType(o) {
    return Object.prototype.toString.call(o);
};

// 数组
var arr = [1, 2, 3,];
console.log(dataType(arr)); //[object Array]

// 对象
var obj = { name: 'MyName', job: '前端开发' };
console.log(dataType(obj)); //[object Object]

// 函数
var fn = function () { }
console.log(dataType(fn));  //[object function]

2、instanceof Array 该特性可以判断多种数据类型!

// 数组
var arr = [1, 2, 3,];
console.log(arr instanceof Array); //true


// 对象
var obj = { name: 'MyName', job: '前端开发' };
console.log(obj instanceof Object); //true

// 函数
var fn = function () { }
console.log(fn instanceof Function); //true

/*
 * instanceof 可以判断一个变量是否属于某个对象的实例；
 * 左边操作数是一个对象，右边操作数是一个函数对象或者函数构造器。
 *
 * 原理是通过判断左操作数的对象的原型链上是否具有右操作数的构造函数的prototype属性。
 */

3、'abc'.constructor === String 该特性可以判断多种数据类型!

// 字符
var str = 'abc123'
console.log(str.constructor === String); //true

// 数字
var num = 123456;
console.log(num.constructor === Number); //true

// 布尔
var bool = false;
console.log(bool.constructor === Boolean); //true

// 数组
var arr = [1, 2, 3,];
console.log(arr.constructor === Array);  //true

// 对象
var obj = { name: 'MyName', job: '前端开发' };
console.log(obj.constructor === Object);  //true

// 函数
var fn = function () { }
console.log(fn.constructor === Function); //true

/*
 * constructor 可以返回对象相对应的构造函数，这样个特性同样可以用于数据类型判断。
 */

 

JS如何判断变量是否是数组Array类型：

1、Array.isArray() 数组判断

var arr = [1, 2, 3];
console.log(Array.isArray(arr)); //true

2、Array.from() 字符串转数组

var str = 'abc123';
console.log(Array.from(str)); // ["a", "b", "c", "1", "2", "3"]