javascript instanceof,typeof的区别_javascript技巧
为什么结果会是false呢?
你要区分string 与 String的区别
aColors[0] 是 string值类型, 当然不是String的实例啦。参考下面代码
var aColors = ["red", "green", "blue"];
aColors[0]= new String("1")
alert(typeof aColors[0]); //output "Object"
alert(aColors[0] instanceof String); //output "true";
更多可以参考下面的文章:
instanceof 运算符
返回一个 Boolean 值,指出对象是否是特定类的一个实例。
result = object instanceof class
参数
result
必选项。任意变量。
object
必选项。任意对象表达式。
class
必选项。任意已定义的对象类。
说明
如果 object 是 class 的一个实例,则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例,或者 object 是 null,则返回 false。
示例
下面的例子举例说明了 instanceof 运算符的用法。
function objTest(obj){
var i, t, s = ""; // 创建变量。
t = new Array(); // 创建一个数组。
t["Date"] = Date; // 填充数组。
t["Object"] = Object;
t["Array"] = Array;
for (i in t)
{
if (obj instanceof t[i]) // 检查 obj 的类。
{
s += "obj is an instance of " + i + "\n";
}
else
{
s += "obj is not an instance of " + i + "\n";
}
}
return(s); // 返回字符串。
}
var obj = new Date();
document.write(objTest(obj));
instanceof和typeof都能用来判断一个变量是否为空或是什么类型的变量。
typeof用以获取一个变量的类型,typeof一般只能返回如下几个结果:number,boolean,string,function,object,undefined。我们可以使用typeof来获取一个变量是否存在,如if(typeof a!="undefined"){},而不要去使用if(a)因为如果a不存在(未声明)则会出错,对于Array,Null等特殊对象使用typeof 一律返回object,这正是typeof的局限性。
如果我们希望获取一个对象是否是数组,或判断某个变量是否是某个对象的实例则要选择使用instanceof。instanceof用于判断一个变量是否某个对象的实例,如var a=new Array();alert(a instanceof Array);会返回true,同时alert(a instanceof Object)也会返回true;这是因为Array是object的子类。再如:function test(){};var a=new test();alert(a instanceof test)会返回true。
谈到instanceof我们要多插入一个问题,就是function的arguments,我们大家也许都认为arguments是一个Array,但如果使用instaceof去测试会发现arguments不是一个Array对象,尽管看起来很像。
另外:
测试 var a=new Array();if (a instanceof Object) alert('Y');else alert('N');
得'Y'
但 if (window instanceof Object) alert('Y');else alert('N');
得'N'
所以,这里的instanceof测试的object是指js语法中的object,不是指dom模型对象。
使用typeof会有些区别
alert(typeof(window) 会得 object
年轻的时候,先少废话,多做事。

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



Die Funktion von „instanceof“ besteht darin, zu bestimmen, ob ein Objekt eine Instanz einer bestimmten Klasse ist oder ob es eine Schnittstelle implementiert. Instanz von ist ein Operator, mit dem überprüft wird, ob ein Objekt von einem bestimmten Typ ist. Verwendungsszenarien des Instanzoperators: 1. Typprüfung: Kann verwendet werden, um den spezifischen Typ eines Objekts zu bestimmen, um je nach Typ unterschiedliche Logik auszuführen. 2. Schnittstellenbeurteilung: Kann verwendet werden, um festzustellen, ob ein Objekt eine Schnittstelle implementiert , um zu bestimmen, ob ein Objekt eine Schnittstelle implementiert. 3. Abwärtstransformation usw.

Konzept 1. Dieser Operator wird verwendet, um Objekte zu bearbeiten und zu prüfen, ob das Objekt von einem bestimmten Typ ist (Typ oder Schnittstellentyp). Format 2. Wenn das Objekt, auf das die Variable auf der linken Seite des Rechners zeigt, ein Objekt der Klasse oder Schnittstelle auf der rechten Seite des Operators ist, ist das Ergebnis wahr. (Objectreferencevariable)instanceof(class/interfacetype) Instanzpaketcom.verify_instanceof;publicclassTestInstanceOf{publicstaticvoidmain(String[]args){//Die folgenden vier Codezeilen werden zum Beweisen verwendet: Instanzvon

Instanceof ist ein Operator in JavaScript, der verwendet wird, um zu erkennen, ob das „Prototyp“-Attribut des Konstruktors irgendwo in der Prototypenkette des Objekts vorkommt. Die Syntax lautet „Objektinstanz des Konstruktors“, wobei „Objekt“ das zu erkennende Objekt und „Konstruktor“ das ist Zu erkennendes Objekt.

In Java ist „Instanz von“ ein binärer Operator, mit dem überprüft wird, ob ein Objekt eine Instanz einer Klasse oder eine Instanz einer Unterklasse einer Klasse ist. Seine Syntax lautet „Objektinstanz der Klasse“, wobei „Objekt“ ein Objekt ist. Anführungszeichen: „Klasse“ ist eine Klasse Name oder Schnittstellenname.

Die Gründe für die Nichtverwendung von „instanceof“ sind: 1. Die von Ihnen verwendete Programmiersprache unterstützt möglicherweise nicht den „instanceof“-Operator. 2. Sie sind der Meinung, dass die Verwendung anderer Methoden die Anforderungen besser erfüllen kann effektiver oder für Ihre Bedürfnisse besser geeignet sein; 3. Sie sind nicht mit der Verwendung des Operators „instanceof“ vertraut oder unsicher über sein Verhalten.

Der Grund dafür ist: Mit dem Operator „instanceof“ wird überprüft, ob ein Objekt eine Instanz einer bestimmten Klasse (oder ihrer abgeleiteten Klasse) ist. Wenn das Objekt keine Instanz einer Klasse ist, kann keine Typbestimmung durchgeführt werden und es wird ein Fehler ausgegeben. Um diesen Fehler zu vermeiden, müssen Sie bei Verwendung des Instanzoperators sicherstellen, dass das Objekt eine Instanz einer Klasse ist. Wenn Sie sich über den Typ eines Objekts nicht sicher sind, können Sie andere Methoden verwenden, um den Typ zu bestimmen.

Wenn Sie den Operator „instanceof“ zum Überprüfen des Typs eines Objekts verwenden und das Ergebnis „true“ ist, bedeutet dies, dass das Objekt eine Instanz des angegebenen Typs ist. Der Compiler konvertiert das Objekt jedoch nicht automatisch in den angegebenen Typ, sodass eine Umwandlung erforderlich ist. Beim Casting handelt es sich um die Konvertierung eines Objekts von einem Typ in einen anderen. Wenn Sie nach Verwendung des Operators „instanceof“ feststellen, dass es sich bei dem Objekt um eine Instanz des angegebenen Typs handelt und Sie mit diesem Typ arbeiten möchten, müssen Sie eine Konvertierung des Umwandlungstyps durchführen.

Dieser Operator wird nur für Objektreferenzvariablen verwendet. Dieser Operator prüft, ob ein Objekt zu einem bestimmten Typ (Klassentyp oder Schnittstellentyp) gehört. Der Instanzoperator wird als -(Objektreferenzvariable)instanzvon(Klasse/Schnittstellentyp) geschrieben. Wenn das Objekt, auf das durch die Variable auf der linken Seite des Operators verwiesen wird, die IS-A-Prüfung des Klassen-/Schnittstellentyps auf der rechten Seite besteht, wird das Ergebnis erfolgreich sein wahr sein. Hier ist ein Beispiel – Beispiel einer Live-Demonstration publicclassTest{ publicstaticvoidmain(Stringargs[]){&nbs
