跳转到内容

JavaScript/运算符

来自华夏公益教科书，开放的书籍，为开放的世界



字符串连接

[编辑 | 编辑源代码]

+ 运算符根据其两个操作数的类型以两种不同的方式起作用。如果其中一个或两个都是字符串，它充当字符串连接符。如果两个都是数字，它充当算术加法。

字符串连接的一个例子是 "one " + "world"，结果为 "one world"。如果两个操作数之一不是字符串，它会在 + 操作执行之前隐式转换为字符串。

"use strict";

// regular concatenation
const word_1 = "one";
const word_2 = "world";
let   result = word_1 + " " + word_2;
alert(result);        //  "one world"

// implicit type conversion
const arr = [41, 42, 43];
result = word_1 + arr + word_2;   // first, the array is converted to a string
alert(result);        //  "one41,42,43world"

// dito
const x = 1;
result = x + word_2;
alert(result);        //  "1world"

算术运算符

[编辑 | 编辑源代码]

JavaScript 有算术运算符 +、-、*、/、%（余数）和 **（指数）。这些运算符按你在数学中学习的方式工作。乘法和除法将在加法和减法之前计算。如果你想改变这种优先级，你可以使用括号。

提示：与其他一些语言相反，除法运算可能导致浮点数 - 它并不总是纯粹的整数。

const a = 12 + 5;       // 17
const b = 12 - 5;       // 7
const c = 12 * 5;       // 60
const d = 12 / 5;       // 2.4   Division results in floating point numbers
const e = 12 % 5;       // 2     Remainder of 12/5 is 2
const f = 12 - 2  * 5;  // 2     Multiplication is calculated first
const g =(12 - 2) * 5;  // 50    Parenthesis are calculated first

一些数学运算，例如除以零，会导致返回的变量成为错误值之一 - 例如，infinity 或 NaN（非数字）。

余数运算符的返回值保留第一个操作数的符号。

+ 和 - 运算符也有单目版本，它们只对一个变量进行操作。当以这种方式使用时，+ 返回对象的数字表示，而 - 返回其负对应物。

"use strict";
const a = 42;
const b = +a;    // b is 42
const c = -a;    // c is -42

如上所述，+ 也用作字符串连接运算符：如果它的任何参数是字符串或不是数字，则所有参数都将转换为字符串并连接在一起。所有其他算术运算符的工作方式相反：它们在求值之前尝试将其参数转换为数字。

"use strict";
const a = 42;
const b = "2";
const c = "3";
alert(a + b);   //  "422"  (a string)
alert(a * b);   //  84     (a number)
alert(b * c);   //  6      (a number)

按位运算符

[编辑 | 编辑源代码]

有七个按位运算符：&、|、^、~、>>、<< 和 >>>。

这些运算符将它们的操作数转换为整数（将任何浮点数截断为 0），并在它们上执行指定的按位运算。逻辑按位运算符 &、| 和 ^ 在每个单独的位上执行 and、or 和 xor，并提供返回值。~（not 运算符）反转整数内的所有位，通常与逻辑按位运算符结合使用。

两个位移运算符 >>、<< 将位移向一个方向移动，这与乘以或除以二的幂的效果类似。最后一个位移运算符 >>> 的工作方式相同，但在移位时不保留符号位。

这些运算符是为与相关编程语言保持一致而保留的，但在大多数 JavaScript 程序中不太可能使用。

赋值运算符

[编辑 | 编辑源代码]

赋值运算符 = 将值赋给变量。原始类型，如字符串和数字，直接分配。但是，函数和对象名称只是指向相应函数或对象的指针。在这种情况下，赋值运算符只改变对对象的引用，而不是对象本身。例如，在执行以下代码后，将提醒“0, 1, 0”，即使传递给提醒的是 array_A，但更改的是 array_B。这是因为它们是对同一个对象的两个引用。

"use strict";
const array_A = [0, 1, 2];
const array_B = array_A;
array_B[2] = 0;
alert(array_A);  // 0, 1, 0

类似地，在执行完下一个代码片段后，x 指向一个空数组。

"use strict";
const z = [5];
const x = z;
z.pop();
alert (x);

如果上述任何一个算术或按位运算符的结果应分配给其第一个操作数，你可以使用更短的语法。将运算符，例如 +，直接与赋值运算符 = 结合，得到 +=。例如，x = x + 5 可以简写为 x += 5。

简写运算符/赋值语法如下

算术 逻辑 移位
+= &= >>=
-= |= <<=
*= ^= >>>=
/=
%=

例如，+= 在 for 循环中的常见用法

"use strict";
const arr = [1, 2, 3];
let sum = 0;
for (let i = 0; i < arr.length; i++) {
  sum += arr[i];  // same as: sum = sum + arr[i];
}
alert(sum);

自增运算符

[编辑 | 编辑源代码]

自增和自减运算符是算术运算符的一种特殊形式：++ 和 --。a++ 自增 a 并返回 a 的旧值。++a 自增 a 并返回 a 的新值。自减运算符的作用类似，但减少了变量。

例如，接下来的操作都执行相同的任务

"use strict";
let a = 1;
alert(a);     // 1

a = a + 1;
alert(a);     // 2

a += 1;
alert(a);     // 3

a++;
alert(a);     // 4

++a;
alert(a);     // 5

// but this SHOWS something different; see next chapter
alert(a++);   // shows 5 again
alert(a);     // nevertheless, 'a' was incremented to 6

前置和后置自增运算符

[编辑 | 编辑源代码]

自增运算符可以在变量之前或之后编写。该位置决定了它们是前置自增还是后置自增运算符。这会影响操作。

"use strict";

// increment occurs before a is assigned to b
let a = 1;
let b = ++a;  // a = 2, b = 2;

// increment occurs to c after c is assigned to d
let c = 1;
let d = c++;  // c = 2, d = 1;

由于前置和后置自增行为可能令人困惑，如果你避免使用自增运算符，代码可能更容易阅读。

"use strict";

// increment occurs before a is assigned to b
let a = 1;
a += 1;
let b = a;  // a = 2, b = 2;

// increment occurs to c after c is assigned to d
let c = 1;
let d = c;
c += 1;     // c = 2, d = 1;

比较运算符

[编辑 | 编辑源代码]

比较运算符确定其两个操作数是否满足给定条件。它们返回 true 或 false。

关于“等于”和“不等于”运算符，你必须小心。== 与 === 不同。第一个尝试将两种类型的类型互相适应，然后比较值。第二个同时比较类型和值，只有在类型和值相同的情况下才返回 true：3 == "0003" 为 true，而 3 === "3" 为 false。

操作符。 返回 注意
== true，如果两个操作数相等 可能改变操作数的类型
（例如，字符串作为整数）。
=== true，如果两个操作数严格相等 不改变操作数的类型。
如果它们是相同的类型和值，则返回 true。
!= true，如果两个操作数不相等 可能改变操作数的类型
（例如，字符串作为整数）。
!== true，如果两个操作数不严格相等 不改变操作数的类型。
如果它们在类型或值上不同，则返回 true。
> true，如果第一个操作数大于第二个操作数
>= true，如果第一个操作数大于或等于第二个操作数
< true，如果第一个操作数小于第二个操作数
<= true，如果第一个操作数小于或等于第二个操作数

我们建议使用严格版本 (=== 和 !==)，因为简单版本可能会导致 奇怪且不直观的状况，例如

0 == ''            // true
0 == '0'           // true
false == 'false'   // false (''Boolean to string'')
false == '0'       // true  (''Boolean to string'')
false == undefined // false
false == null      // false (''Boolean to null'')
null == undefined  // true

…虽然你可能想要

0 === ''            // false
0 === '0'           // false
false === 'false'   // false
false === '0'       // false
false === undefined // false
false === null      // false
null === undefined  // false

逻辑运算符

[编辑 | 编辑源代码]

逻辑运算符是 and、or 和 not - 写成 &&、|| 和 !。前两个分别接受两个布尔操作数。第三个接受一个并返回它的逻辑否定。

操作数是布尔值或求值为布尔值的表达式。

"use strict";
const a = 0;
const b = 1;

if (a === 0 && b === 1) {  // logical 'and'
  alert ("a is 0 AND b is 1");
}

if (a === 1 || b === 1) {  // logical 'or'
  alert ("a is 1 OR b is 1");
}

&& 和 || 是短路运算符：如果在评估第一个操作数后结果得到保证，它将跳过第二个操作数的评估。因此，&& 运算符也被称为守卫运算符，而 || 运算符被称为默认运算符。

"use strict";

// declare 'myArray' without initialization
let myArray;

// runtime error!
if (myArray.length > 0) {
  alert("The length of the array is: " + myArray.length);
}

// no error because the part after '&&' will not be executed!
if (myArray && myArray.length > 0) {
  alert("The length of the array is: " + myArray.length);
}

! 运算符用于确定给定布尔值的相反值：true 变为 false，而 false 变为 true。

注意：JavaScript 使用布尔值 false、数字 0、NaN、空字符串或内置类型 undefined 或 null 来表示 false。任何其他值都被视为 true。

关于这三个运算符的优先级，! 首先被计算，其次是 &&，最后是 ||。

      a  ||   b  &&   !c

    |       |       |    |
    |       |       └ 1. ┘
    |       └───── 2. ───┘
    └───────── 3. ───────┘

有关优先级和短路之间的关系的更多详细信息，请参阅 MDN

其他运算符

[edit | edit source]

? :

[edit | edit source]

? : 运算符（也称为“三元”运算符）是 if 语句的缩写。首先，它计算问号之前的部分。然后，如果为 true，则计算问号和冒号之间的部分并返回结果，否则计算冒号后的部分。

const target = (a == b) ? c : d;

但是，在使用它时要小心。虽然您可以用三元运算符替换冗长和复杂的 if/then/else 链，但这样做可能不是一个好主意。您可以替换

if (p && q) {
    return a;
} else {
    if (r != s) {
        return b;
    } else {
        if (t || !v) {
            return c;
        } else {
            return d;
        }
    }
}

为

return (p && q) ? a
  : (r != s) ? b
  : (t || !v) ? c
  : d

上面的例子是糟糕的编码风格/实践。当其他人（很可能就是你）编辑或维护你的代码时，理解和使用代码就会变得更加困难。

相反，最好让代码更易于理解。可以从上面的例子中移除一些过度的条件嵌套。

if (p && q) {
    return a;
}
if (r != s) {
    return b;
}
if (t || !v) {
    return c;
} else {
    return d;
}

delete

[edit | edit source]

delete obj.x 将属性 x 从对象 obj 中解绑。

delete 关键字从对象中删除属性。它会删除属性的值和属性本身。删除后，在再次添加该属性之前，无法使用该属性。delete 运算符旨在用于 对象属性。它对变量或函数没有影响。

new

[edit | edit source]

new cl 创建一个类型为 cl 的新对象。cl 操作数必须是构造函数。

instanceof

[edit | edit source]

o instanceof c 测试 o 是否是由构造函数 c 创建的对象。

typeof

[edit | edit source]

typeof x 返回一个字符串，描述 x 的类型。可能返回以下值。

类型 返回
boolean "boolean"
number "number"
string "string"
function "function"
undefined "undefined"
null "object"
其他（array，...） "object"

练习

[edit | edit source]
... 在另一个页面上提供（点击这里）。

另请参阅

[edit | edit source]
检索自 "https://wikibooks.cn/w/index.php?title=JavaScript/Operators&oldid=4428536"
华夏公益教科书