Warum ist JavaScript eine schwach typisierte Sprache?

In einer schwach typisierten Sprache können Datentypen ignoriert werden und einer Variablen können Werte verschiedener Datentypen zugewiesen werden. JavaScript-Variablen können bei verschiedenen Gelegenheiten als unterschiedliche Typen interpretiert werden, was eine implizite Konvertierung und Erzwingung von Variablentypen ermöglicht. In JavaScript können Variablen verwendet werden, ohne ihren Datentyp im Voraus zu deklarieren. Zu diesem Zeitpunkt trifft der JavaScript-Interpreter je nach Situation das, was er für das richtige Urteil hält.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, JavaScript-Version 1.8.5, Dell G3-Computer.

Statische Sprache: Wir rufen statische Sprachen auf, die den Datentyp der Variablen bestätigen müssen, bevor sie verwendet werden können. 静态语言：我们把在使用之前就需要确认其变量数据类型的称为静态语言。

动态语言：我们把在运行过程中需要检查数据类型的语言称为动态语言。

通常把偷偷进行类型转换的操作成为隐式类型转换：

而支持隐式类型转换的语言称为弱类型语言，不支持隐式类型转换的语言称为强类型语言。

强类型语言：

强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。

弱类型语言：

数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。

弱类型语言允许变量类型的隐式转换，允许强制类型转换等，如字符串和数值可以自动转化；而强类型语言一般不允许这么做。

JavaScript是弱类型语言

JavaScript属于“宽松类型”的编程语言，这意味着JavaScript变量在不同的场合可以解释为不同的类型。

在JavaScript中，不必事先声明变量的数据类型就可以使用变量，这时JavaScript解释器会根据情况做出他认为正确的判断。如果我们现在变量里保存了一个字符串，稍后又想把它当做数值使用，这在JavaScript里是完全可行的，前提是这个字符串必须包含像数字的内容。

js弱类型的体现

一般规律是，约束越强越不容易出错，但编写程序时也越麻烦。在JavaScript中，因为约束比较弱，所以容易出现这种错误：最简单的例子：

再比如下面这个例子：

var a =200;
var b ="1";
var c= a + b;

你可能期望c是201，但实际上它是"2001"，这个错误在强类型语言中决不会出现。然而正是因为JavaScript没有这些约束，所以可以很方便地拼接数字和字符串类型。

再比如下面这个例子：

var a = '11';
a = a - '';
console.log(typeof a);// -->number

“-”可以是一元运算符（取负），也可以是二元（减法运算）

在循环语句中（if，while）中，一个Object对象可以隐式的转换从BOOLEAN值。

var obj = {name:'jack'}
if(obj){
    //do more
}

比较难以发现的是在alert()函数中。

String.prototype.fn = function(){return this};
var a = 'hello';
alert(typeof a.fn()); //-->object
alert(a.fn()); //-->hello

我们知道this可以理解成当前类的实例对象，既然是对象那么typeof a.fn()自然返回是object了。

关键是最后的alert(a.fn())，a.fn()返回的明明是对象，但却隐式的转换成了字符串“hello

Dynamische Sprache: Wir bezeichnen Sprachen, die während des Betriebs Datentypen überprüfen müssen, als dynamische Sprachen.

Normalerweise wird der Vorgang der heimlichen Typkonvertierung als Implizite Typkonvertierung bezeichnet: Die Sprache, die die implizite Typkonvertierung unterstützt, heißt Schwach typisierte Sprache und unterstützt keine implizite Typkonvertierung Typkonvertierung. Eine Typkonvertierungssprache wird als stark typisierte Sprache bezeichnet.

Stark typisierte Sprache:🎜🎜Eine Sprache, die Datentypdefinitionen erzwingt. Mit anderen Worten: Sobald einer Variablen ein bestimmter Datentyp zugewiesen wird, bleibt sie immer dieser Datentyp, wenn sie nicht umgewandelt wird. Beispiel: Wenn Sie eine Ganzzahlvariable a definieren, kann das Programm a nicht als Zeichenfolgentyp behandeln. Eine stark typisierte Definitionssprache ist eine typsichere Sprache. 🎜🎜Schwach typisierte Sprache: 🎜🎜Eine Sprache, in der Datentypen ignoriert werden können. Es handelt sich um das Gegenteil einer stark typisierten Definitionssprache, bei der einer Variablen Werte unterschiedlicher Datentypen zugewiesen werden können. 🎜🎜Schwach typisierte Sprachen ermöglichen die implizite Konvertierung von Variablentypen, erzwungene Typkonvertierungen usw. Beispielsweise können Zeichenfolgen und Werte automatisch konvertiert werden, während stark typisierte Sprachen dies im Allgemeinen nicht zulassen. 🎜🎜JavaScript ist eine schwach typisierte Sprache🎜🎜JavaScript ist eine „lose typisierte“ Programmiersprache, was bedeutet, dass JavaScript-Variablen es sind Die Anlässe können als unterschiedliche Typen interpretiert werden. 🎜🎜In JavaScript können Sie Variablen verwenden, ohne ihren Datentyp im Voraus zu deklarieren. Zu diesem Zeitpunkt trifft der JavaScript-Interpreter je nach Situation das, was er für das richtige Urteil hält. Wenn wir jetzt einen String in einer Variablen speichern und ihn später als Zahlenwert verwenden wollen, ist das in JavaScript durchaus machbar, sofern der String so etwas wie eine Zahl enthalten muss. 🎜🎜Die Verkörperung schwacher js-Typen🎜🎜Die allgemeine Regel lautet: Je stärker die Einschränkung, desto weniger fehleranfällig ist sie, aber desto problematischer ist sie beim Schreiben eines Programms. Da in JavaScript die Einschränkungen relativ schwach sind, kann diese Art von Fehler auftreten: Das einfachste Beispiel: 🎜🎜 Ein weiteres Beispiel ist das folgende: 🎜rrreee🎜 Sie können erwarten, dass c 201 ist, aber tatsächlich ist es „2001“. , dieser Fehler tritt nie in stark typisierten Sprachen auf. Gerade weil JavaScript jedoch nicht über diese Einschränkungen verfügt, kann es problemlos numerische und String-Typen verketten. 🎜🎜
🎜🎜Ein weiteres Beispiel ist das Folgende:🎜rrreee🎜🎜🎜🎜“-“ kann ein unärer Operator (negativ) oder ein binärer Operator (Subtraktionsoperation) sein. 🎜🎜🎜In einer Schleifenanweisung (if, while) kann ein Objektobjekt eine implizite Konvertierung von BOOLEAN durchführen Wert. 🎜rrreee🎜Schwieriger zu finden ist die Funktion „alert()“. 🎜rrreee🎜🎜🎜 🎜🎜Wir wissen das Es kann als Instanzobjekt der aktuellen Klasse verstanden werden. Da es sich um ein Objekt handelt, gibt typeof a.fn() natürlich ein Objekt zurück. 🎜🎜Der Schlüssel ist der letzte alert(a.fn()). Was von a.fn() zurückgegeben wird, ist offensichtlich ein Objekt, wird aber implizit in umgewandelt eine Zeichenfolge. „hello“ wird angezeigt. 🎜🎜【Verwandte Empfehlungen: 🎜Javascript-Video-Tutorial🎜, 🎜Programmiervideo🎜】🎜

Das obige ist der detaillierte Inhalt vonWarum ist JavaScript eine schwach typisierte Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!