目录

1 确定一个值是何种类型

2 typeof与instanceof 区别

1 typeof

2 instanceof

3 怎么判断对象类型？

1 instanceof

2  Object.prototype.toString.call(xx)。

4  typeof null // "object"的原因

5 思维导图

1 确定一个值是何种类型

https://wangdoc.com/javascript/types/general.html#typeof-%E8%BF%90%E7%AE%97%E7%AC%A6

typeof运算符

instanceof运算符

Object.prototype.toString方法

2 typeof与instanceof 区别

1 typeof

typeof 是一元运算符，同样返回一个值数据类型的字符串。数值、字符串、布尔值、undefined分别返回number、string、boolean、undefined；函数函数返回function；对象（除了函数）以及null返回object

除了 null 类型以及 Object 类型不能准确判断外，其他数据类型都能返回正确的类型。

//1 数字--number
console.log(typeof 123); //返回值：number

//2 字符串--string
console.log(typeof "123"); //返回值：string

//3 布尔值--boolean
console.log(typeof true); //返回值：boolean

//4 undefined--undefined
console.log(typeof undefined); //返回值：undefined

//5 null--object
console.log(typeof null); //返回值：object

//6 Symbol--symbol
let sym = Symbol("123");
console.log(typeof sym); //返回值：symbol

//7 函数--function
let fun = function (num){
    let nums = num;
}
console.log(typeof fun); //返回值：function

//8 函数--object
let obj = {
    a: 1
}
console.log(typeof obj); //返回值：object
console.log(typeof []); //返回值：object
console.log(typeof {}); //返回值：object

//9 未声明的变量
console.log(typeof a); //返回值：undefined   注意：在严格模式下也能返回这个值
console.log(a); //a is not defined  使用没有声明的变量会报错

2 instanceof

返回一个布尔值，判断某个对象是不是另一个对象的实例，表示对象是否为某个构造函数的实例。instanceof的原理是检查右边构造函数的prototype属性，是否在左边对象的原型链上。

//1 instanceof运算符返回一个布尔值
let obj = new Object("ji25");//生成一个String包装类型的对象
console.log(obj instanceof Object); //返回值：true
//上面语句等价于===
console.log(Object.prototype.isPrototypeOf(obj));//返回值：true
console.log(obj instanceof String); //返回值：true
//上面语句等价于===
console.log(String.prototype.isPrototypeOf(obj));//返回值：true

//2 由于任意对象（除了null）都是Object的实例,instanceof运算符可以判断一个值是否为非null的对象。
console.log(null instanceof Object); //返回值：false

//3 instanceof判断值的类型。
console.log([] instanceof Array); //返回值：true

//4 instanceof运算符只能用于对象，不适用原始类型的值。
console.log("str" instanceof String); //返回值：false

//5 对于undefined和null，instanceof运算符总是返回false。
console.log(undefined instanceof Object); //返回值：false
console.log(null instanceof Object); //返回值：false

3 怎么判断对象类型？

1 instanceof 

可以正确的判断对象的类型，instanceof的原理是检查右边构造函数的prototype属性，是否在左边对象的原型链上。

2  Object.prototype.toString.call(xx)。

通过Object.prototype.toString.call(xx)，这样我们就可以获得类似 [object Type] 的字符串。

其实Object.prototype.toString方法是Object原型上面的方法，所有继承于Object的实例对象都有该方法，为了使Object.prototype.toString应用于任何值，需要使用call函数改变绑定的对象



//对于所有的类型，返回值都是--[object Type]

//1 基本数据类型--返回值中的Type是值的数据类型的字符串
console.log(Object.prototype.toString.call(123)); //[object Number]
console.log(Object.prototype.toString.call("str")); //[object String]
console.log(Object.prototype.toString.call(true)); //[object Boolean]
console.log(Object.prototype.toString.call(undefined)); //[object Undefined]
console.log(Object.prototype.toString.call(null)); //[object Null]
console.log(Object.prototype.toString.call(Symbol(1))); //[object Symbol]
console.log("-------------");

//2 特殊对象
console.log(Object.prototype.toString.call([])); //[object Array]
console.log(Object.prototype.toString.call(function () {})); //[object Function]
console.log(Object.prototype.toString.call(new Date())); //[object Date]
console.log(Object.prototype.toString.call(/^.*$/)); //[object RegExp]
(function myFun() { //立即执行函数
    //arguments对象是函数中特有，表示传入的参数
    console.log(arguments);//[Arguments] { '0': 123, '1': '125' }
    console.log(Object.prototype.toString.call(arguments));//object Arguments]
})(123, "125");
(function myFun11() { //立即执行函数
    try{
        console.log(a);
    }catch (e) {
        console.log(Object.prototype.toString.call(e));//[object Error]
    }
})();

//3 其他普通对象
console.log(Object.prototype.toString.call({}));//[object Object]

4  typeof null // "object"的原因

null的类型是object，这是由于历史原因造成的。1995年的 JavaScript 语言第一版，只设计了五种数据类型（对象、整数、浮点数、字符串和布尔值），没考虑null，只把它当作object的一种特殊值。后来null独立出来，作为一种单独的数据类型，为了兼容以前的代码，typeof null返回object就没法改变了。

5 思维导图



百里于2020年5月8日

参考：JavaScript 教程、GitHub

如果有错，请您指出！如有侵权，请联系我删除！

可以通过typeof()这个方法来获取值的类型

var a ;
if(typeof(a)==="undefined"){
//a为undefined类型
}

a = 123;
if(typeof(a)==="number"){
//a为number类型
}

a={};
if(typeof(a)==="object"){
//a为object类型
}

a="abc";
if(typeof(a)==="string"){
//a为string类型
}

a=true;
if(typeof(a)==="boolean"){
//a为boolean类型
}

a=function(){};
if(typeof(a)==="function"){
//a为function类型
}

a=[];
if(typeof(a)==="object"){
//值为数组的时候,typeof返回也是"object"
}

要判断值是否为数组,可以通过instanceof方法,判断一个值是否为另一个值的实例
a=[];
if(a instanceof Array){
//a为数组
}

取出的值为null,并不是字符串“null”,用object == null 判断结果为false;





 

后面发现这个null和定义的null不同，后面找到object自带的方法



使用这个方法返回true......

JsonObject.isNull。当然，可以的话，尽量不用 JsonObject

   1。在执行的SQL语句一般都是_bstr_t   
  2.Connection   中的RecordsAffected   为VARIANT   
  3.使用get_Value()获得的记录的值为   VAARIANT   
      等等。。。   
  _bstr_t   中记录了字符串的长度，   
  _variant_t   记录有数据的类型和数据的值   
      如   _variant_t   ttt;   
      ttt.vt=I4_VT;   表示数据类型为整数   
      ttt.lVal   为数据的值
 
variant_t var;  

CString str; //转换以后的字符串



//以下代码演示如何转换为C标准字符串型
if (var.vt == VT_I4)
{
    long lNum;
    char szCh[21];
    str=var.bstrVal;
    WideCharToMultiByte 
             (CP_ACP, 0, var.bstrVal, -1,
              szCh, sizeof(szCh), NULL, NULL);
}

//以下代码演示如何转换成逻辑型
if( var.vt == VT_BOOL)
{
    BOOL bVar;
    lNum=var.lVal;
    bVar= var.boolVar==0? FALSE : TRUE;
}

//以下代码演示为其余类型（补充）
switch(var.vt)
{

case VT_BSTR:         //var is BSTR type
     str=var.bstrVal;
     break;

case VT_I2:           //var is short int type 
     str.Format("%d",(int)var.iVal);
     break;

case VT_I4:          //var is long int type
     str.Format("%d",var.lVal);
     break;

case VT_R4:         //var is float type
     str.Format("%10.6f",(double)var.fltVal);
     break;

case VT_R8:         //var is double type
     str.Format("%10.6f",var.dblVal);
     break;

case VT_CY:        //var is CY type
     str=COleCurrency(var).Format();
     break;

case VT_DATE:     //var is DATE type
     str=COleDateTime(var).Format();
     break;

case VT_BOOL:     //var is  VARIANT_BOOL
     str= (var.boolVal==0) ?"FALSE": "TRUE";
     break;

default:
     str.Format("Unk type %d/n",var.vt);
     TRACE("Unknown type %d/n",var.vt);
}