typeof和instanceof

typeof

定义

typeof返回一个字符串，表示未经过计算的操作数的类型

语法

typeof 运算符后面接操作数

typeof operand

typeof(operand)

参数

operand 

一个表示对象或者原始值的表达式，其类型会被返回

描述

// 数值
typeof 123 // 'number'
typeof NaN  // 'number'; // 尽管它是 "Not-A-Number" (非数值) 的缩写
typeof Number('1') // 'number'; // Number 会尝试把参数解析成数值
typeof 3.14 // 'number';

//字符串
typeof '123' // 'string'
typeof (typeof 1) === 'string'; // typeof 总是返回一个字符串
typeof String(1) === 'string'; // String 将任意值转换为字符串，比 toString 更安全

// 布尔值
typeof true === 'boolean';
typeof false === 'boolean';
typeof Boolean(1) === 'boolean'; // Boolean() 会基于参数是真值还是虚值进行转换
typeof !!(1) === 'boolean'; // 两次调用 ! (逻辑非) 操作符相当于 Boolean()

// Symbols (ECMAScript 2015 新增)
typeof Symbol() === 'symbol';
typeof Symbol('foo') === 'symbol';
typeof Symbol.iterator === 'symbol';

// Undefined
typeof undefined //'undefined'
typeof asdfg  // 'undefined'

//对象

typeof  { a:1} // 'object'

// 使用 Array.isArray 或者 Object.prototype.toString.call
// 区分数组和普通对象
typeof [1, 2, 4] === 'object';

typeof new Date() === 'object';
typeof null === 'object';

 

//函数

// 函数
typeof function() {} === 'function';
typeof class C {} === 'function'
typeof Math.sin === 'function';

 // null

typeof null  //"object"

在 JavaScript 最初的实现中，JavaScript 中的值是由一个表示类型的标签和实际数据值表示的。对象的类型标签是 0。

由于 null 代表的是空指针（大多数平台下值为 0x00），因此，null 的类型标签是 0，typeof null 也因此返回 "object"。（参考来源）

// Bigint  (ECMAScript 2020 新增)

typeof BigInt(123)  // "bigint"
typeof 42n === 'bigint' 

使用 new 操作符 

// 除 Function 外的所有构造函数的类型都是 'object'
var str = new String('String');
var num = new Number(100);

typeof str; // 返回 'object'
typeof num; // 返回 'object'

var func = new Function();

typeof func; // 返回 'function'

 

语法中的括号

// 括号有无将决定表达式的类型。
var iData = 99;

typeof iData + ' Wisen'; // 'number Wisen'
typeof (iData + ' Wisen'); // 'string'
typeof (1+2) //'number'

//如果没有括号
typeof 1+2 //"number2"

typeof '1'+'22' //"string22"

 

错误

在加入了块级作用域的 let 和 const 之后，在其被声明之前对块中的 let 和 const 变量使用 typeof 会抛出一个 ReferenceError。

块作用域变量在块的头部处于“暂存死区”，直至其被初始化，在这期间，访问变量将会引发错误。

typeof str
let str = 'asd' // Uncaught ReferenceError:

typeof num //"undefined"
var num = 123

 

instanceof

定义

instanceof 运算符用于检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上。

语法

object instanceof constructor

参数

object

某个实例对象

constructor

某个构造函数

function C (){}
var o = new C()
o instanceof C // true

构造函数 C 的原型constructor.prototype  是否存在 o 的原型链上

构造函数D.prototype的指向和 Object.getPrototypeOf(o) 实例的执行 是相同的，所以构造函数 D的原型在 实例对象 o 的原型链上 

function D (){}
function C (){}
D.prototype = new C(); // 继承
var o3 = new D();
o3 instanceof D; // true
o3 instanceof C; // true 因为 C.prototype 现在在 o3 的原型链上

 这样可以判断变量是 null,还是对象

var a = {}
a instanceof Object //true
null instanceof Object //false

[] instanceof Array //true

还不能完全判断是否是数组，数组本身是对象的子类 

var b = []
b instanceof Object
//true

var c = new Array()
c instanceof Object
//true

判断数组可以使用 Array.isArray(arr) 方法

var c = new Array()
var a = {}
c instanceof Object
//true
Array.isArray(c)
//true
Array.isArray(a)
//false

也可以使用 

Object.prototype.toString.call([])
// "[object Array]"
Object.prototype.toString.call({})
// "[object Object]"

使用了 instanceof 来判断 String，String 和 Date 对象同时也属于Object 类型（他们是由 Object 类派生出来的）。

这里要注意一点，使用对象文字符号创建的对象在这里是一个例外：虽然原型未定义，

但 instanceof Object 返回 true。但是，使用对象文字符号创建的对象在这里是一个例外：

虽然原型未定义，但 instanceof Object 返回 true。

var simpleStr = "This is a simple string";
var myString  = new String();
var newStr    = new String("String created with constructor");
var myDate    = new Date();
var myObj     = {};
var myNonObj  = Object.create(null);

simpleStr instanceof String; // 返回 false, 非对象实例，因此返回 false
myString  instanceof String; // 返回 true
newStr    instanceof String; // 返回 true
myString  instanceof Object; // 返回 true

myObj instanceof Object;    // 返回 true, 尽管原型没有定义
({})  instanceof Object;    // 返回 true, 同上
myNonObj instanceof Object; // 返回 false, 一种创建非 Object 实例的对象的方法

myString instanceof Date; //返回 false

myDate instanceof Date;     // 返回 true
myDate instanceof Object;   // 返回 true
myDate instanceof String;   // 返回 false