Résumé de l'utilisation de certains opérateurs non traditionnels en JavaScript

Javascript prend en charge de nombreux autres opérateurs.

i. Opérateur conditionnel (?:)

L'opérateur conditionnel est le seul opérateur ternaire en JavaScript. Habituellement, cet opérateur s'écrit « ? : ». Cet opérateur a trois opérandes. Le premier opérande est avant "?" et le deuxième est entre "?" Le troisième opérande est dès après ":", par exemple

x > x : -x; // Trouver la valeur absolue de x
L'opérande de l'opérateur conditionnel peut être de n'importe quel type. Le premier opérande est traité comme une valeur booléenne. S'il est vrai, le deuxième opérande est évalué et le résultat est renvoyé. Affectation Si la première opérande de valeur est fausse, alors la troisième opérande est évaluée. et renvoie le résultat du calcul. Les deuxième et troisième opérandes sont toujours évalués à l'un d'eux. Il est impossible de faire les deux en même temps. En fait, le même effet peut être obtenu en utilisant les instructions if (5.4.1). L'opérateur "?:" ne fournit qu'une forme abrégée. Voici un scénario d'utilisation typique de "?:", qui détermine si une variable est définie. Si elle est définie, elle est utilisée. Si elle n'est pas définie, une valeur par défaut est utilisée.

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

est équivalent au code suivant, mais celui ci-dessus est plus concis

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

opérateur ii.typeof()

typeof est un opérateur unaire, placé devant un seul opérande, l'opérande peut être de n'importe quel type et la valeur de retour représente une chaîne représentant le type d'opération.

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

L'utilisation la plus courante de typeof est écrite dans des expressions comme celle-ci

(typeof value == "string") ? L'opérateur typeof est également très utile dans l'instruction switch (5.4.3). Il convient de noter que l'opération typeof peut être accompagnée de parenthèses. Cela fait ressembler typeof à un nom de fonction au lieu d'un mot-clé

typeof(i)

opérateur iii.delete

delete est un opérateur unaire, il est utilisé pour supprimer les propriétés d'un objet ou d'éléments d'un tableau. Tout comme les opérateurs d’affectation, d’incrémentation et de décrémentation. La suppression a également des effets secondaires. Il est utilisé pour les opérations de suppression. Il n'est pas utilisé pour renvoyer une valeur.

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

Il convient de noter que la suppression d'un attribut ou la suppression d'un élément du tableau ne définit pas seulement une valeur indéfinie. Lorsqu'un attribut est supprimé, l'attribut n'existe plus. La lecture d'une valeur qui n'existe pas renverra un résultat indéfini. Concernant la suppression et certaines situations en mode strict, ceux qui ont besoin d'apprendre peuvent expérimenter par eux-mêmes.

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

opérateur iii.void.

void est un opérateur unaire Avant que l'opérande n'apparaisse, l'opérande peut être de n'importe quel type. Cet opérateur n'est pas couramment utilisé : les opérandes sont évalués comme d'habitude, mais le résultat est ignoré et undéfini est renvoyé. Puisque void ignore la valeur de l'opérande, il est plus logique de programmer avec void lorsque l'opérande a des effets secondaires.

Il s'agit de l'URL client la plus couramment utilisée. Écrivez une expression avec des effets secondaires dans l'URL, et void empêche le navigateur d'afficher le résultat de cette expression.

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

iiii. Opérateur virgule. (,)

L'opérateur virgule est un opérateur binaire et ses opérandes peuvent être de n'importe quel type. Il évalue d'abord l'opérande de gauche, puis l'opérande de droite.

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

C'est fondamentalement équivalent au code ci-dessous

i = 0; j = 1;

évaluera toujours l'expression de gauche, Mais le calcul Le résultat est ignoré, c'est-à-dire que si l'expression de gauche a des effets secondaires, une opération de virgule sera utilisée pour rendre le code plus fluide. Le scénario le plus couramment utilisé pour l’opérateur virgule est celui d’une boucle for, qui comporte généralement plusieurs variables de boucle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!