Zusammenfassung der Verwendung einiger nicht gängiger Operatoren in JavaScript

Javascript unterstützt viele andere verschiedene Operatoren.

i. Bedingungsoperator (?:)

Der Bedingungsoperator ist der einzige ternäre Operator in JavaScript. Normalerweise wird dieser Operator als „?:“ geschrieben. Der erste Operand steht vor „?“ und der zweite Operand steht zwischen „?“. Der dritte Operand steht beispielsweise nach „

x > // Ermitteln Sie den absoluten Wert von x
“. jede Art. Der erste Operand wird als boolescher Wert behandelt. Wenn er wahr ist, wird der zweite Operand ausgewertet und das Ergebnis zurückgegeben. Zuweisung: Wenn der erste Wertoperand falsch ist, wird der dritte Operand ausgewertet. und das Berechnungsergebnis zurückgeben. Der zweite und dritte Operand ergeben immer einen von ihnen. Es ist unmöglich, beides gleichzeitig zu tun. Tatsächlich kann der gleiche Effekt mit if-Anweisungen (5.4.1) erzielt werden. Der Operator „?:“ stellt nur eine Kurzform bereit. Hier ist ein typisches Verwendungsszenario von „?:“, das bestimmt, ob eine Variable definiert ist, wird sie verwendet. Wenn sie nicht definiert ist, wird ein Standardwert verwendet.

 grett = "hello" + (username ? username : "three");

entspricht dem folgenden Code, der obige ist jedoch prägnanter

grett = "hello";
if (username)
   grett += username;
else
   grett + "three"

ii.typeof()-Operator

typeof ist ein unärer Operator. Wird vor einem einzelnen Operanden platziert, kann der Operand einen beliebigen Typ haben und der Rückgabewert stellt eine Zeichenfolge dar, die den Operationstyp darstellt.

   x             __ typeof x
            undefined     __ "undefined"
            null           __  "object"
            ture或false    __"boolean"
            任意数字或NaN     __ "Number"
            任意字符串                        __ "String"
            任意函数                            __ "function"
            任意内容对象（非函数）__ "object"
            任意宿主对象                    __ 由编译器各自实现的字符串，但不是"undefined" "boolean" "number" "string"

Die häufigste Verwendung von typeof wird in Ausdrücken wie diesem geschrieben

(typeof value == "string") ? "" + value + "":value;
Der Typeof-Operator ist auch in der Switch-Anweisung (5.4.3) sehr nützlich. Es ist zu beachten, dass der Typeof-Vorgang durch Klammern ergänzt werden kann. Dadurch sieht typeof wie ein Funktionsname und nicht wie ein Schlüsselwort aus

typeof(i)

iii.delete-Operator

delete ist ein unärer Operator. Er wird verwendet um Eigenschaften eines Objekts oder Elemente eines Arrays zu löschen. Genau wie Zuweisungs-, Inkrementierungs- und Dekrementierungsoperatoren. Löschen hat auch Nebenwirkungen. Es wird für Löschvorgänge verwendet. Es wird nicht verwendet, um einen Wert zurückzugeben.

var o = {
                x: 1,
                y: 2
            }
            delete o.x;
            "x" in o; //=>false
            var a = [1, 2, 3];
            delete a[2]; // 删除数组中最后一个元素
            2 in a; //=> false 元素2已经在数组中不存在了
            a.length; //=>3,注意，数组长度并没有改变，尽管上一行删除了这个元素，但删除操作留下了一个洞。实际上并没有修改数组的长度，因此a的长度仍然为3

Es ist zu beachten, dass das Löschen eines Attributs oder das Löschen eines Array-Elements nicht nur einen undefinierten Wert setzt. Wenn ein Attribut gelöscht wird, ist das Attribut nicht mehr vorhanden. Das Lesen eines nicht vorhandenen Werts führt zu einer undefinierten Löschung und einigen Situationen im strikten Modus. Hier sind einige Beispiele.

var o = {x: 1,y: 2};
            delete o.x; //删除一个对象属性，返回true
            typeof o.x; //属性不存在，返回"undefined"
            delete o.x; //删除不存在的属性，返回true;
            delete o; //不能删除通过var关键字声明的变量，返回false
            delete 1; //参数不是一个左值。
            this.x = 1;// 给全局定义一个属性，这里没有使用var
            delete x ; //试图删除它，在非严格模式下返回true
                       //在严格模式下回抛出异常，这时使用"delete this.x"来代替
             x;        //运行时出错，没有定义x

iii.void-Operator.

void ist ein unärer Operator. Bevor der Operand erscheint, kann der Operand einen beliebigen Typ haben. Dieser Operator wird nicht häufig verwendet: Die Operanden werden wie üblich ausgewertet, das Ergebnis wird jedoch ignoriert und undefiniert zurückgegeben. Da void den Wert des Operanden ignoriert, ist es sinnvoller, mit void zu programmieren, wenn der Operand Nebenwirkungen hat.

Dies ist die am häufigsten verwendete Client-URL. Schreiben Sie einen Ausdruck mit Nebenwirkungen in die URL, und void verhindert, dass der Browser das Ergebnis dieses Ausdrucks anzeigt.

<a href="javascript:void window.open();">new</a>

iiii. (,)

Der Kommaoperator ist ein binärer Operator und seine Operanden können von jedem Typ sein. Es wertet zuerst den linken Operanden und dann den rechten Operanden aus.

 i = 0, j = 1, k = 2;

Es entspricht im Grunde dem folgenden Code

i = 0; j = 1;
wertet immer den Ausdruck auf der linken Seite aus Das Ergebnis wird ignoriert, das heißt, nur wenn der linke Ausdruck Nebenwirkungen hat, wird die Kommaoperation verwendet, um den Code glatter zu machen. Das am häufigsten verwendete Szenario für den Kommaoperator ist eine for-Schleife, die normalerweise mehrere Schleifenvariablen enthält.

//for循环中的第一个逗号是var语句的一部分
             //第二个逗号是逗号运算符
             //它将两个表达式(i++和j++)放在一条(for循环中)语句中
            for (var i = 0, j = 10; i < j; i++, j--);
            console.log(i + j);

Das obige ist der detaillierte Inhalt vonZusammenfassung der Verwendung einiger nicht gängiger Operatoren in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!