java與js的instanceof與typeof的使用

instanceof 用來測試一個物件是否為一個類的例項，能不能轉為某個類的物件。用法為：

boolean result = obj instanceof Class
其中 obj 為一個物件，Class 表示一個類或者一個介面，當 obj 為 Class 的物件，或者是其直接或間接子類，或者是其介面的實現類，結果result 都返回 true，否則返回false。

注意：編譯器會檢查 obj 是否能轉換成右邊的class型別，如果不能轉換則直接報錯，如果不能確定型別，則通過編譯，具體看執行時定。

obj 必須為引用型別，不能是基本型別

int i = 0;
System.out.println(i instanceof Integer);//編譯不通過
System.out.println(i instanceof Object);//編譯不通過
instanceof 運算子只能用作物件的判斷。

obj 為 class 類的直接或間接子類

public class Person {

}
public class Man extends Person{

}
Person p1 = new Person();
Person p2 = new Man();
Man m1 = new Man();
System.out.println(p1 instanceof Man);//false
System.out.println(p2 instanceof Man);//true
System.out.println(m1 instanceof Man);//true

注意第一種情況， p1 instanceof Man ，Man 是 Person 的子類，Person 不是 Man 的子類，所以返回結果為 false。

String 類中的重寫的 equals 方法

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}
 

js的typeof和instanceof方法

jsonof是一個一元運算，放在一個運算數之前，運算數可以是任意型別。它會返回一個字串，該字串說明運算數的型別。

typeof 返回值有六種可能： “number”， “string”，“boolean” ，“object”， “function” 和 "undefined "

typeof(1);

typeof(NaN);

typeof(Number.MIN_VALUE);

typeof(Infinity);

typeof(“123”);

typeof(true);

typeof(window);

typeof(document);

typeof(null);

typeof(eval);

typeof(Date);

typeof(sss);

typeof(undefined);

在 JavaScript 中，判斷一個變數的型別嚐嚐會用 typeof 運算子，在使用 typeof 運算子時採用引用型別儲存值會出現一個問題，無論引用的是什麼型別的物件，它都返回 “object”。ECMAScript 引入了另一個 Java 運算子 instanceof 來解決這個問題。instanceof 運算子與 typeof 運算子相似，用於識別正在處理的物件的型別。與 typeof 方法不同的是，instanceof 方法要求開發者明確地確認物件為某特定型別。例如：

// 判斷物件是否為 “未定義” 值(即 undefined)。
coreUtil.isUndefined = function (obj) { return obj === undefined || typeof obj === “undefined”; };
var oStringObject = new String(“hello world”);
console.log(oStringObject instanceof String); // 輸出 “true”
這段程式碼問的是“變數 oStringObject 是否為 String 物件的例項？”oStringObject 的確是 String 物件的例項，因此結果是"true"。儘管不像 typeof 方法那樣靈活，但是在 typeof 方法返回 “object” 的情況下，instanceof 方法還是很有用的。

通常來講，使用 instanceof 就是判斷一個例項是否屬於某種型別。例如：

$.extend($.fn.datagrid.methods, {
addEditor : function(jq, param) {
if (param instanceof Array) {
$.each(param, function(index, item) {
var e = $(jq).datagrid(‘getColumnOption’, item.field);
e.editor = item.editor;
});
} else {
//獲取datagrid欄位的屬性
var e = $(jq).datagrid(‘getColumnOption’, param.field);
//給編輯器賦值
e.editor = param.editor;
}
},
removeEditor : function(jq, param) {
if (param instanceof Array) {
$.each(param, function(index, item) {
var e = $(jq).datagrid(‘getColumnOption’, item);
e.editor = {};
});
} else {
var e = $(jq).datagrid(‘getColumnOption’, param);
e.editor = {};
}
}
});
另外，更重的一點是 instanceof 可以在繼承關係中用來判斷一個例項是否屬於它的父型別。例如：

// 判斷 foo 是否是 Foo 類的例項 , 並且是否是其父型別的例項
function Aoo(){}
function Foo(){}
Foo.prototype = new Aoo();//JavaScript 原型繼承

var foo = new Foo();
console.log(foo instanceof Foo)//true
console.log(foo instanceof Aoo)//true
上面的程式碼中是判斷了一層繼承關係中的父類，在多層繼承關係中，instanceof 運算子同樣適用。

console.log(Object instanceof Object);//true
console.log(Function instanceof Function);//true
console.log(Number instanceof Number);//false
console.log(String instanceof String);//false

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

console.log(Foo instanceof Function);//true
console.log(Foo instanceof Foo);//false
JavaScript instanceof 運算子程式碼

function instance_of(L, R) {//L 表示左表示式，R 表示右表示式
var O = R.prototype;// 取 R 的顯示原型
L = L.proto;// 取 L 的隱式原型
while (true) {
if (L === null)
return false;
if (O === L)// 這裡重點：當 O 嚴格等於 L 時，返回 true
return true;
L = L.proto;
}
}
Object instanceof Object，Function instanceof Function 和 Foo instanceof Foo 三個示例

Object instanceof Object

// 為了方便表述，首先區分左側表示式和右側表示式
ObjectL = Object, ObjectR = Object;
// 下面根據規範逐步推演
O = ObjectR.prototype = Object.prototype
L = ObjectL.proto = Function.prototype
// 第一次判斷
O != L
// 迴圈查詢 L 是否還有 proto
L = Function.prototype.proto = Object.prototype
// 第二次判斷
O == L
// 返回 true
Function instanceof Function

// 為了方便表述，首先區分左側表示式和右側表示式
FunctionL = Function, FunctionR = Function;
// 下面根據規範逐步推演
O = FunctionR.prototype = Function.prototype
L = FunctionL.proto = Function.prototype
// 第一次判斷
O == L
// 返回 true
Foo instanceof Foo

// 為了方便表述，首先區分左側表示式和右側表示式
FooL = Foo, FooR = Foo;
// 下面根據規範逐步推演
O = FooR.prototype = Foo.prototype
L = FooL.proto = Function.prototype
// 第一次判斷
O != L
// 迴圈再次查詢 L 是否還有 proto
L = Function.prototype.proto = Object.prototype
// 第二次判斷
O != L
// 再次迴圈查詢 L 是否還有 proto
L = Object.prototype.proto = null
// 第三次判斷
L == null
// 返回 false

作者：wespten
來源：CSDN
原文：https://blog.csdn.net/qq_35029061/article/details/83988428
版權宣告：本文為博主原創文章，轉載請附上博文連結！