


Detaillierte Analyse der sechs grundlegenden Datentypen in JavaScript
Dieser Artikel vermittelt Ihnen relevantes Wissen über die sechs grundlegenden Datentypen in JavaScript. Ich hoffe, er wird Ihnen hilfreich sein.
1. Groß-/Kleinschreibung beachten
In JavaScript wird bei allem (Variablen, Funktionen und Operatoren) die Groß-/Kleinschreibung beachtet. Dies bedeutet auch, dass der Variablennamentest und der Variablennamentest jeweils zwei verschiedene Variablen darstellen.
2. Bezeichner
Die sogenannten Bezeichner beziehen sich auf Variablen, Funktionsnamen und Operatoren oder Funktionsparameter. Die Formatregeln für Bezeichner lauten wie folgt:
1. Das erste Zeichen muss ein Zeichen, ein Unterstrich (_) oder ein Dollarzeichen ($) sein;
2.
Gemäß der Konvention werden JavaScript-Bezeichner im Camel-Case-Format geschrieben, d. h. ein Buchstabe wird kleingeschrieben und der erste Buchstabe der übrigen Wörter wird großgeschrieben. Zum Beispiel: firstChirld, myCar;
Natürlich ist die Verwendung des Small-Camel-Case-Schreibformats für Bezeichner nicht zwingend erforderlich, aber es kann uns das Verständnis des Codes erleichtern. Versuchen Sie beim Schreiben, das Small-Camel-Case-Schreibformat zu verwenden um anderen das Verständnis Ihres Codes zu erleichtern.
3. Kommentare
Die Kommentarmethoden in JavaScript sind in einzeilige Kommentare und mehrzeilige Kommentare unterteilt:
Einzeilige Kommentare:
//这是一个单行注释
Mehrzeilige Kommentare:
/* *这是一个 *多行注释 */
4. Anweisungen
In JavaScript Anweisungen werden in Punkte unterteilt, die mit einem Semikolon enden. Wenn das Semikolon weggelassen wird, bestimmt der Interpreter das Ende. Wie im folgenden Beispiel gezeigt:
var sum = a + b //即使没有分号也是有效语句——不推荐 var diff = a - b; //有效语句——推荐
5. Variablen
Der Variablentyp in JavaScript ist schwach typisiert. Der sogenannte schwache Typ bedeutet, dass er zum Speichern jeder Art von Daten verwendet werden kann. Mit anderen Worten: Jede Variable ist lediglich ein Platzhalter für die Aufnahme eines Werts.
Verwenden Sie beim Definieren einer Variablen das Schlüsselwort var, gefolgt vom Variablennamen (d. h. Bezeichner). Wie unten gezeigt:
var message;
JavaScript unterstützt auch die direkte Initialisierung von Variablen, sodass der Wert der Variablen beim Definieren der Variablen festgelegt werden kann. Wie unten gezeigt:
var message = "Hello world!";
Eine Sache, die beachtet werden muss, ist, dass eine mit dem Schlüsselwort var definierte Variable zu einer lokalen Variablen in dem Bereich wird, in dem die Variable definiert ist. Mit anderen Worten: Wenn var zum Definieren einer Variablen in einer Funktion verwendet wird, wird die Variable nach Beendigung der Funktion zerstört. Zum Beispiel:
function test(){ var message = "Hello"; //局部变量 } test(); console.log(message); //错误!
Der Grund für den Fehler ist, dass die Variable message mit var in der Funktion test() definiert ist. Beim Aufruf einer Funktion wird eine Variable erstellt und ihr ein Wert zugewiesen. Danach wird die Variable sofort zerstört, sodass die nächste Codezeile im Beispiel einen Fehler verursacht. Sie können jedoch eine globale Variable erstellen, indem Sie das Schlüsselwort var wie folgt weglassen:
function test(){ message = "Hello"; //全局变量 } test(); console.log(message); //"Hello"
Wenn Sie das Schlüsselwort var hier weglassen, wird die Nachricht zu einer globalen Variablen. Auf diese Weise ist die Variable definiert, solange die Funktion test() einmal aufgerufen wird. Nachdem die globale Variable festgelegt wurde, kann überall außerhalb der Funktion darauf zugegriffen werden.
Obwohl es möglich ist, globale Variablen durch Weglassen des Schlüsselworts var zu definieren, wird dies nicht empfohlen, da im lokalen Bereich definierte globale Variablen schwer zu pflegen sind.
Datentypen
Es gibt mehrere einfache Datentypen in JavaScript (auch Basic genannt). Datentyp): Undefiniert, Null, Boolean, Zahl und String. Es gibt auch einen komplexen Typ: Object ist im Wesentlichen eine Menge ungeordneter Name-Wert-Paare. JavaScript unterstützt keinen Mechanismus zum Erstellen benutzerdefinierter Typen und alle Werte sind einer dieser 6 Datentypen.
typeof-Operator
Da JavaScript schwach typisiert ist, muss es eine Möglichkeit geben, den Datentyp einer bestimmten Variablen zu erkennen – typeof ist ein Operator, der für die Erkennung des Datentyps einer bestimmten Variablen verantwortlich ist. Die Verwendung des Operators „typeof“ für einen Wert kann eine der folgenden Zeichenfolgen zurückgeben:
„undefiniert“ – wenn der Wert undefiniert ist;
„boolean“ – wenn der Wert vom Typ Boolean ist; Zeichenfolge“ – wenn der Wert eine Zeichenfolge ist;
„Zahl“ – wenn der Wert eine Zahl ist;
„Objekt“ – wenn der Wert ein Objekt oder Null ist;
-
„Funktion“ – – Wenn es sich bei diesem Wert um eine Funktion handelt; Beachten Sie, dass es sich bei typeof nicht um eine Funktion handelt. Daher sind die Klammern in diesem Beispiel zwar verwendbar, aber nicht erforderlich.
In JavaScript ist eine Funktion ein Objekt und kein Datentyp. Daher ist die Verwendung von „typeof“ erforderlich, um Funktionen von anderen Objekten zu unterscheiden. - Undefinierter TypDer undefinierte Typ hat nur einen Wert, nämlich den speziellen undefinierten Typ. Wenn eine Variable mit var deklariert, aber nicht initialisiert wird, ist der Wert der Variablen undefiniert. Zum Beispiel:
var message = "hello"; console.log(typeof message); //"string" console.log(typeof(message)); //"string" console.log(typeof 95); //"number"
var message; console.log(message == undefined); //true var message1 = "undefined"; console.log(message1 == undefined); //true
gibt undefiniert sowohl für initialisierte als auch für deklarierte Variablen zurück. Dieses Ergebnis ist logisch sinnvoll. Da sich diese beiden Variablen aus technischer Sicht grundsätzlich unterscheiden, ist es tatsächlich unmöglich, mit beiden Variablentypen echte Operationen durchzuführen,
Null类型
Null类型是第二个只有一个值得类型,这个特殊的值是null。从逻辑的角度来看,null值表示一个对象的空指针,而这也正是使用typeof操作符的检测null值时会返回“object”的原因,如下面的例子所示:
var message= null; console.log(message); //"object"
如果定义的对象将来用来保存对象,那么最好将这个变量初始化为null而不是其他的值。这样一来,只要直接检查null值就可以直接知道相应的变量是否已经保存了一个对象的引用,如下面的例子:
if(message != null){ //对message进行一系列的操作 }
实际上,undefined的值是派生自null值得,所以对它们进行相等性测试的时候要返回true:
console.log(null == undefined); //true
在这里,位于null和undefined之间的相等操作符(==)总是返回true。尽管null和undefined有这样的关系,但它们的的用途完全不同。如上面所述,无论在什么情况下,都没有必要把一个变量显示的表示为undefined,可是同样的规则对null却不适用。换句话说,只有保存对象的变量还没有真正的保存对象,就应该在明确地表示将该变量保存为null值。这样做不仅可以体现null值作为空指针的惯例,而且也有助于进一步的区分null和undefined。
Boolean类型
Boolean类型是JavaScript中使用最多的一种类型,该类型只有两个字面值:true和false。这两个值与数字值不是一回事,因此true不一定等于1,而false也不一定等于0。以下是为变量赋值的例子:
var first = true; var second = false;
需要注意的是,boolean类型的两个值区分大小写。也就是说True和true、False和false不是一回事。
True和False(以及其他混合大小形式)只是标识符,不是boolean值。
虽然boolean值只有两个值,但是JavaScript所有类型的值都有与这两个boolean值等价的值。要将一个值转换为相应的Boolean值,可以调用Boolean()函数。例如:
var message = "Hello world!"; var messageAsBoolean = Boolean(message); console.log(messageAsBoolean); //true
可以对任何类型的值调用Boolean()函数,而且总会返回一个boolean值。至于返回的是true还是false取决于要转换的实际类型及其实际值。下表给出了各种数据类型对其转换的相应规则:
数据类型 | 转换为true的值 | 转换为false的值 |
---|---|---|
Boolean | true | false |
String | 任何非空字符串 | “”(空字符串) |
Number | 任何非零数字值(包括无穷大) | 0和NaN |
Object | 任何对象 | null |
Undefined | n/a | undefined |
Number类型
在JavaScript中number类型定义了不同的数值字面量格式。例如:
var intNumber = 55; //十进制整数 var octalNum1 = 070; //八进制的56 var octaNum2 = 079; //无效的八进制数,解析为79 var octaNum3 = 08; //无效的八进制数,解析为8 var hexNum1 = 0xA; //十六进制的10 var hexNum2 = 0x1f; //十六进制的31
在进行算术计算时,所有八进制和十六进制表示的数值都会转换成十进制数值。
NaN
NaN即非数值,是一个特殊的数值。这个数用于表示一个本来要返回数值的操作数未返回数值的情况(这样就不会抛出错误了)。NaN本身有两个特点:
首先,任何涉及NaN的操作(例如NaN/10)都会返回NaN,这个特点在多步计算中有可能导致问题。
其次,NaN与任何值都不相等,包括NaN本身。例如:
console.log(NaN ==NaN ); //false
String类型
string类型用于表示零或多个Unicode字符组成的字符序列,即字符串。字符串可以由双引号(")或单引号(’)表示,因此下面两种写法都是有效的:
var firstName = "王文正"; var secondName = "王彬";
双引号开头的必须以双引号结尾,而当引号开头的必须以单引号结尾。下面这种会导致语法错误:
var name = "王彬'; //语法错误
字符字面量
String类型中包含了一些特殊字面量,也叫转义序列,用于表示非打印字符,或者有其他的用途的字符。这些字符字面量如下表所示:
字面量 | 含义 |
---|---|
\n | 换行 |
\t | 制表 |
\b | 退格 |
\r | 回车 |
\f | 进纸 |
\ | 斜杠 |
’ | 单引号 |
" | 双引号 |
\xnn | 以十六进制代码nn表示一个字符 |
\unnn | 以十六进制代码nnn表示一个Unicode字符 |
字符串的特点
JavaScript中的字符串是不可变的,也就是说,字符串一旦创建,它的值就是不可更改的。要更改某个变量中保存的字符串,首先要销毁原来的字符串,然后用另一个包含新值得字符串填充变量,例如:
var lang = "java"; lang = lang + "script"; console.log(lang); //javascript
Object类型
JavaScript中的对象是一组数据和功能的集合。对象可以通过执行new操作符后跟要创建的对象类型名称来创建。而创建Object类型的实例并为其添加属性或方法,就可以创建自定义对象。如下所示:
var o = new Object(); var o = new Object; //有效,但是不推荐这种做法;
Object的每个实例都具有以下下列属性和方法:
constructor:保存着用于创建当期那对象的函数。
hasOwnProperty(propertyName):用于检查给定的属性在当前对象实例中(而不是实际的原型中)是否存在。
isPrototypeOf(object):用于检查传入的对象那个是否是当前对象的原型。
propertyIsEnumerable(propertyName):用于检查给定的属性是否能够使用for-in语句
toLocaleString():返回对象的字符串表示,该字符串与执行环境的地区对应
valueOf():返回对象的字符串、数值或布尔值表示。通常与toString()方法的返回值相同
toString():返回对象的字符串表示
由于在JavaScript中Object是所有对象的基础,因此所有对象都具有这些基本的属性和方法。
【相关推荐:javascript学习教程】
Das obige ist der detaillierte Inhalt vonDetaillierte Analyse der sechs grundlegenden Datentypen in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

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



So implementieren Sie mit WebSocket und JavaScript ein Online-Spracherkennungssystem. Einführung: Mit der kontinuierlichen Weiterentwicklung der Technologie ist die Spracherkennungstechnologie zu einem wichtigen Bestandteil des Bereichs der künstlichen Intelligenz geworden. Das auf WebSocket und JavaScript basierende Online-Spracherkennungssystem zeichnet sich durch geringe Latenz, Echtzeit und plattformübergreifende Eigenschaften aus und hat sich zu einer weit verbreiteten Lösung entwickelt. In diesem Artikel wird erläutert, wie Sie mit WebSocket und JavaScript ein Online-Spracherkennungssystem implementieren.

WebSocket und JavaScript: Schlüsseltechnologien zur Realisierung von Echtzeit-Überwachungssystemen Einführung: Mit der rasanten Entwicklung der Internet-Technologie wurden Echtzeit-Überwachungssysteme in verschiedenen Bereichen weit verbreitet eingesetzt. Eine der Schlüsseltechnologien zur Erzielung einer Echtzeitüberwachung ist die Kombination von WebSocket und JavaScript. In diesem Artikel wird die Anwendung von WebSocket und JavaScript in Echtzeitüberwachungssystemen vorgestellt, Codebeispiele gegeben und deren Implementierungsprinzipien ausführlich erläutert. 1. WebSocket-Technologie

So implementieren Sie ein Online-Reservierungssystem mit WebSocket und JavaScript. Im heutigen digitalen Zeitalter müssen immer mehr Unternehmen und Dienste Online-Reservierungsfunktionen bereitstellen. Es ist von entscheidender Bedeutung, ein effizientes Online-Reservierungssystem in Echtzeit zu implementieren. In diesem Artikel wird erläutert, wie Sie mit WebSocket und JavaScript ein Online-Reservierungssystem implementieren, und es werden spezifische Codebeispiele bereitgestellt. 1. Was ist WebSocket? WebSocket ist eine Vollduplex-Methode für eine einzelne TCP-Verbindung.

Einführung in die Verwendung von JavaScript und WebSocket zur Implementierung eines Online-Bestellsystems in Echtzeit: Mit der Popularität des Internets und dem Fortschritt der Technologie haben immer mehr Restaurants damit begonnen, Online-Bestelldienste anzubieten. Um ein Echtzeit-Online-Bestellsystem zu implementieren, können wir JavaScript und WebSocket-Technologie verwenden. WebSocket ist ein Vollduplex-Kommunikationsprotokoll, das auf dem TCP-Protokoll basiert und eine bidirektionale Kommunikation zwischen Client und Server in Echtzeit realisieren kann. Im Echtzeit-Online-Bestellsystem, wenn der Benutzer Gerichte auswählt und eine Bestellung aufgibt

JavaScript und WebSocket: Aufbau eines effizienten Echtzeit-Wettervorhersagesystems Einführung: Heutzutage ist die Genauigkeit von Wettervorhersagen für das tägliche Leben und die Entscheidungsfindung von großer Bedeutung. Mit der Weiterentwicklung der Technologie können wir genauere und zuverlässigere Wettervorhersagen liefern, indem wir Wetterdaten in Echtzeit erhalten. In diesem Artikel erfahren Sie, wie Sie mit JavaScript und WebSocket-Technologie ein effizientes Echtzeit-Wettervorhersagesystem aufbauen. In diesem Artikel wird der Implementierungsprozess anhand spezifischer Codebeispiele demonstriert. Wir

JavaScript-Tutorial: So erhalten Sie HTTP-Statuscode. Es sind spezifische Codebeispiele erforderlich. Vorwort: Bei der Webentwicklung ist häufig die Dateninteraktion mit dem Server erforderlich. Bei der Kommunikation mit dem Server müssen wir häufig den zurückgegebenen HTTP-Statuscode abrufen, um festzustellen, ob der Vorgang erfolgreich ist, und die entsprechende Verarbeitung basierend auf verschiedenen Statuscodes durchführen. In diesem Artikel erfahren Sie, wie Sie mit JavaScript HTTP-Statuscodes abrufen und einige praktische Codebeispiele bereitstellen. Verwenden von XMLHttpRequest

Verwendung: In JavaScript wird die Methode insertBefore() verwendet, um einen neuen Knoten in den DOM-Baum einzufügen. Diese Methode erfordert zwei Parameter: den neuen Knoten, der eingefügt werden soll, und den Referenzknoten (d. h. den Knoten, an dem der neue Knoten eingefügt wird).

Einführung in die Methode zum Abrufen des HTTP-Statuscodes in JavaScript: Bei der Front-End-Entwicklung müssen wir uns häufig mit der Interaktion mit der Back-End-Schnittstelle befassen, und der HTTP-Statuscode ist ein sehr wichtiger Teil davon. Das Verstehen und Abrufen von HTTP-Statuscodes hilft uns, die von der Schnittstelle zurückgegebenen Daten besser zu verarbeiten. In diesem Artikel wird erläutert, wie Sie mithilfe von JavaScript HTTP-Statuscodes erhalten, und es werden spezifische Codebeispiele bereitgestellt. 1. Was ist ein HTTP-Statuscode? HTTP-Statuscode bedeutet, dass der Dienst den Dienst anfordert, wenn er eine Anfrage an den Server initiiert
