最近開源了一個 Vue 元件，還不夠完善，歡迎大家來一起完善它，也希望大家能給個 star 支援一下，謝謝各位了。

github 地址：https://github.com/qq44924588...

智米們肯定知道，JS 是種弱型別語言，對變數的型別沒有限制。

例如，如果我們使用字串型別建立了一個變數，後面又可以為同一變數分配一個數字：

let message = 'Hello'; // 分配一個字串

message = 14; // 分配一個數字

這種動態性為我們提供了靈活性並簡化了變數宣告。

不好方面，我們永遠不能確保變數包含某種型別的值。 例如，以下函式greet(who)需要一個字串引數，但是，我們可以使用任何型別的引數來呼叫該函式：

function greet(who) {
  return `Hello, ${who}!`
}

greet('World'); // => 'Hello, World!'
// You can use any type as argument
greet(true);    // => 'Hello, true!'
greet([1]);     // => 'Hello, 1!'

有時我們需要在 JS 中檢查變數的型別，要怎麼做？

使用typeof運算子以及instanceof來檢查例項型別。

1.typeof運算子

在 JS 中，基本型別有String、Number、Boolean

typeof是用於確定expression型別的運算子：

consttypeAsString =typeofexpression;

expression的計算結果是我們要查詢的型別的值。expression可以是變數myVariable，屬性訪問器myObject.myProp，函式呼叫myFunction()或數字14。

typeof expression，取決於expression的值，結果可能為:'string'，'number'，'boolean'，'symbol'，'undefined'，'object'，'function'

我們來看看typeof運算子每種型別的情況：

A) String:

const message = 'hello!';
typeof message; // => 'string'

B) Number:

const number = 5;
typeof number; // => 'number'

typeof NaN;    // => 'number'

C) Boolean:

const ok = true;
typeof ok; // => 'boolean'

D) Symbol:

const symbol = Symbol('key');
typeof symbol; // => 'symbol'

E) undefined:

const nothing = undefined;
typeof nothing; // => 'undefined'

F) Objects:

const object = { name: 'Batman' };
typeof object; // => 'object'

const array = [1, 4, 5];
typeof array; // => 'object'

const regExp = /Hi/;
typeof regExp; // => 'object'

G) Functions:

function greet(who) {
  return `Hello, ${who}!`
}

typeof greet; // => 'function'

1.1 typeof null

如上我們看到的，用typeof判斷物件結果是'object'。

但是，typeof null也會計算為'object'！

const missingObject = null;
typeof missingObject; // => 'object'

typeof null為'object'是 JS 初始實現中的一個錯誤。

因此，在使用typeof檢測物件時，需要另外檢查null：

function isObject(object) {
  return typeof object === 'object' && object !== null;
}

isObject({ name: 'Batman' }); // => true
isObject(15);                 // => false
isObject(null);               // => false

1.2 typeof 和未定義的變數

雖然typeof expression通常決定於expression的型別，但也可以使用typeof來確定是否定義了變數。

// notDefinedVar is not defined
notDefinedVar; // throws ReferenceError

typeof有一個不錯的屬性，當typeof評估未定義變數的型別時，不會引發ReferenceError錯誤：

// notDefinedVar is not defined
typeof notDefinedVar; // => 'undefined'

變數notDefinedVar沒有在當前作用域內定義。然而，typeof notDefinedVar不會丟擲引用錯誤，而是將結果計算為'undefined'。

我們可以使用typeof來檢測是否未定義變數，如果typeof myVar === 'undefined'為true， 則myVar未定義。

2. instanceof 運算子

使用 JS 函式的通常方法是通過在其名稱後新增一對括號來呼叫它：

function greet(who) {
  return `Hello, ${who}!`;
}

greet('World'); // => 'Hello, World!'

greet('World')是常規函式呼叫。

JS 函式可以做更多的事情：它們甚至可以構造物件！ 要使函式構造物件，只需在常規函式呼叫之前使用new關鍵字：www.uyangjinhua.cn

function Greeter(who) {
  this.message = `Hello, ${who}!`;
}

const worldGreeter = new Greeter('World');
worldGreeter.message; // => 'Hello, World!'

new Greeter('World')是建立例項worldGreeter的建構函式呼叫。

如何檢查 JS 是否使用特定建構函式建立了特定例項？ 使用instanceof運算子：www.8117761.com

constbool=objectinstanceof Constructor;

其中object是對物件求值的表示式，而Constructor是構造物件的類或函式，instanceof計算為布林值。

worldGreeter例項是使用Greeter建構函式建立的，因此worldGreeter instanceof Greeter計算結果為true。

從ES6 開始，可以使用class來定義物件。例如，定義一個類Pet，然後建立它的一個例項myPet:

class Pet {
  constructor(name) {
    this.name = name;
  }
}

const myPet = new Pet('Lily');

new Pet('Lily')是建立例項myPet的構造呼叫。

由於myPet是使用Pet類構造的-const myPet = new Pet('Lily'), 所以myPet instanceof Pet的結果為true：

myPet instanceof Pet;//=>true

但是，普通物件不是Pet的例項：

const plainPet = { name: 'Zoe' };
plainPet instanceof Pet; // => false

我們發現instanceof對於確定內建的特殊例項(如正則表示式、陣列)很有用：

function isRegExp(value) {
  return value instanceof RegExp;
}
isRegExp(/Hello/); // => true
isRegExp('Hello'); // => false

function isArray(value) {
  return value instanceof Array;
}
isArray([1, 2, 3]); // => true
isArray({ prop: 'Val' }); // => false

2.1 instanceof 和父類

現在，Cat擴充套件了父類Pet：

class Cat extends Pet {
  constructor(name, color) {
    super(name);
    this.color = color;
  }
}

const myCat = new Cat('Callie', 'red');

不出所料，myCat是Cat類的例項：

myCat instanceof Pet;//=>true

但同時，myCat也是基類Pet的一個例項:

myCat instanceof Pet;//=>true

3. 總結

JS 是一種弱型別的語言，這意味著對變數的型別沒有限制。

typeof expression可以用來檢視expression的型別，結果是可能是其中的一個:'string'，'number'，'boolean'，'symbol'，'undefined'，'object'，'function'。

typeof null的值為'object'，因此使用typeof檢測物件的正確方法是typeof object ==='object'&& object！== null。

instanceof運算子讓我們確定例項的建構函式。 如果object是Constructor的例項，則object instanceof Constructor為true。