JS对变量类型的判断

JS对变量类型的判断

JavaScript的数据类型

基本类型：

1. Number 类型 这种类型既可以表示 32 位的整数，还可以表示 64 位的浮点数。
2. String 类型 字符串类型，它是唯一没有固定大小的原始类型。
3. Boolean 类型 是 ECMAScript 中最常用的类型之一。它有两个值 true 和 false。
4. Null 类型 用于表示尚未存在的对象。
5. Undefined 类型当声明的变量未初始化时，该变量的默认值是 undefined。
6. NaN 表示非数（Not a Number），这种情况发生在类型（String、Boolean 等）转换失败时。它与自身不相等

这里说以下Number的独特性，也有个JavaScript的坑
八进制数和十六进制数
整数可以表示为八进制和十六进制。
八进制首字母为0，其后的数字可以是任何八进制数字（0-7）。

// 071 等于十进制的 57
let num = 071;

要创建十六进制的字面量，首位数字必须为 0，后面接字母 x，然后是任意的十六进制数字（0 到 9 和 A 到 F）。
字母可以是大写的，也可以是小写的。

var num=0x2a;//0x2a等于十进制的 42
var num=0x5F;//0x5F等于十进制的 95

尽管所有整数都可以表示为八进制或十六进制的字面量，但所有数学运算返回的都是十进制结果。

浮点数
定义浮点数必须包括小数点和小数点后的一位数字。

var FloatNumber=1.234;

JavaScript浮点数计算会有一个问题，Js中只有Number，而Number是已IEEE 754标准的64-bits的双精度数值。

由于计算时会将数字转换为二进制来存储和处理，并不能进行精确地浮点计算，这会导致精度的丢失。

解决方法

1. toFixed()
   使用toFixed进行保留小数，(0.1+0.2).toFixed(1) =0.3。但是toFixed的结果并不是十分精准，对于金额的计算不推荐使用。
2. 科学计算法，将浮点数转换为计算机能够精确计算的整数，计算完毕后再乘以10的-n次幂。

下面是一些网上找到的处理方法

    //加法  
    Number.prototype.add = function(arg){  
      var a,b,m;  
      try{a=this.toString().split(".")[1].length}catch(e){a=0}  
      try{b=arg.toString().split(".")[1].length}catch(e){b=0}  
      m=Math.pow(10,Math.max(a,b))  
      return (this*m+arg*m)/m  
    } 
    //减法   
    Number.prototype.sub = function (arg){  
      return this.add(-arg);  
    }  
    //乘法   
    Number.prototype.mul = function (arg)   {  
      var m=0,s1=this.toString(),s2=arg.toString();  
      try{m+=s1.split(".")[1].length}catch(e){}  
      try{m+=s2.split(".")[1].length}catch(e){}  
      return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)  
    }  
 
    //除法   
    Number.prototype.div = function (arg){  
      var t1=0,t2=0,r1,r2;  
      try{t1=this.toString().split(".")[1].length}catch(e){}  
      try{t2=arg.toString().split(".")[1].length}catch(e){}  
      with(Math){  
        r1=Number(this.toString().replace(".",""))  
        r2=Number(arg.toString().replace(".",""))  
        return (r1/r2)*pow(10,t2-t1);  
      }  
    }

引用类型

引用类型通常叫做类（class），也就是对象。

Object 对象

constructor
对创建对象的函数的引用（指针）。对于 Object 对象，该指针指向原始的 Object() 函数。

Prototype
对该对象的对象原型的引用。对于所有的对象，它默认返回 Object 对象的一个实例。

判断数据类型

1，typeof

typeof可以识别简单基本类型值(number,string,boolean)。

typeof 1 //number
typeof "1" //string
typeof true //boolean

但对于复合类型(Object,Array,Function)却只能识别为Function或Object。

typeof function a(){} //number
var obj = {}
typeof obj //object
var arr = []
typeof arr //object

对于undefined可以做出正确的识别

typeof undefined //undefined

null是一个只有一个值的特殊类型。表示一个空对象引用。

typeof null//object

2，instanceof

instanceof运算符用于测试构造函数的prototype属性是否出现在对象的原型链中的任何位置。

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}
var auto = new Car('Honda', 'Accord', 1998);

console.log(auto instanceof Car);//true

console.log(auto instanceof Object);//true

3，[[Class]]

[[class]]指的是隐藏在javascript内部的分类属性，它不可读，不可枚举，不可修改，不可配置。
强制把它转换成字符串，使它暴露出内部的[[class]]属性。

Object.prototype.toString.call(num);   //  "[object Number]"
Object.prototype.toString.call(str);   //  "[object String]"
Object.prototype.toString.call(bool);  //  "[object Boolean]"
Object.prototype.toString.call(arr);   //  "[object Array]"
Object.prototype.toString.call(func);  //  "[object Function]"
Object.prototype.toString.call(und);   //  "[object Undefined]"
Object.prototype.toString.call(nul);   //  "[object Null]"
Object.prototype.toString.call(date);  //  "[object Date]"
Object.prototype.toString.call(reg);   //  "[object RegExp]"
Object.prototype.toString.call(error);  //  "[object Error]"

function type(val){
    var s  = Object.prototype.toString.call(val);
    return s.slice(s.indexOf(" ")+1,s.length-1);
}
type(111) //Number
type("111") //String