From 01b0e12ba27b5069248fd09235e9a7143915ee30 Mon Sep 17 00:00:00 2001 From: Irvin Date: Wed, 16 Feb 2022 02:02:49 +0800 Subject: remove `notranslate` class in zh-CN --- .../guide/expressions_and_operators/index.html | 86 +++++++++++----------- 1 file changed, 43 insertions(+), 43 deletions(-) (limited to 'files/zh-cn/web/javascript/guide/expressions_and_operators') diff --git a/files/zh-cn/web/javascript/guide/expressions_and_operators/index.html b/files/zh-cn/web/javascript/guide/expressions_and_operators/index.html index 1ea851d0f7..b90c70b5e0 100644 --- a/files/zh-cn/web/javascript/guide/expressions_and_operators/index.html +++ b/files/zh-cn/web/javascript/guide/expressions_and_operators/index.html @@ -33,18 +33,18 @@ translation_of: Web/JavaScript/Guide/Expressions_and_Operators

JavaScript 拥有二元和一元运算符， 和一个特殊的三元运算符（条件运算符）。一个二元运算符需要两个操作数，分别在运算符的前面和后面：

-
操作数1 运算符 操作数2
+
操作数1 运算符 操作数2
 

 
 
例如, 3+4 或 x*y。

 
 
一个一元运算符需要一个操作数，在运算符前面或后面：

 
-
运算符 操作数

+
运算符 操作数

 
 
或

 
-
操作数 运算符

+
操作数 运算符

 
 
例如, x++ 或 ++x。

 
@@ -136,7 +136,7 @@ translation_of: Web/JavaScript/Guide/Expressions_and_Operators
 
 
对于更复杂的赋值，解构赋值语法是一个能从数组或对象对应的数组结构或对象字面量里提取数据的 Javascript 表达式。

 
-
var foo = ["one", "two", "three"];
+
var foo = ["one", "two", "three"];
 
 // 不使用解构
 var one   = foo[0];
@@ -150,7 +150,7 @@ var [one, two, three] = foo;

 
 
比较运算符比较它的操作数并返回一个基于表达式是否为真的逻辑值。操作数可以是数字，字符串，逻辑，对象值。字符串比较是基于标准的字典顺序，使用Unicode值。在多数情况下，如果两个操作数不是相同的类型， JavaScript 会尝试转换它们为恰当的类型来比较。这种行为通常发生在数字作为操作数的比较。类型转换的例外是使用 === 和 !== 操作符，它们会执行严格的相等和不相等比较。这些运算符不会在检查相等之前转换操作数的类型。下面的表格描述了该示例代码中的各比较运算符

 
-
var var1 = 3;
+
var var1 = 3;
 var var2 = 4;

 
 
@@ -224,7 +224,7 @@ var var2 = 4;
算术运算符使用数值(字面量或者变量)作为操作数并返回一个数值.标准的算术运算符就是加减乘除(+ - * /)。当操作数是浮点数时，这些运算符表现得跟它们在大多数编程语言中一样（特殊要注意的是，除零会产生{{jsxref("Infinity")}}）。例如：

 
-
1 / 2;  // 0.5
+
1 / 2;  // 0.5
 1 / 2 == 1.0 / 2.0; // true
 

 
@@ -378,7 +378,7 @@ var var2 = 4;

  

- 
Before: 11100110111110100000000000000110000000000001
+ 
Before: 11100110111110100000000000000110000000000001
 After:              10100000000000000110000000000001

  

 

@@ -507,7 +507,7 @@ After:              10100000000000000110000000000001
下面是&&（逻辑"与"）操作符的示例。

 
-
var a1 =  true && true;     // t && t returns true
+
var a1 =  true && true;     // t && t returns true
 var a2 =  true && false;    // t && f returns false
 var a3 = false && true;     // f && t returns false
 var a4 = false && (3 == 4); // f && f returns false
@@ -518,7 +518,7 @@ var a7 = "Cat" && false;    // t && f returns false
 
 
下面是||（逻辑"或"）操作符的示例。

 
-
var o1 =  true || true;     // t || t returns true
+
var o1 =  true || true;     // t || t returns true
 var o2 = false || true;     // f || t returns true
 var o3 =  true || false;    // t || f returns true
 var o4 = false || (3 == 4); // f || f returns false
@@ -529,7 +529,7 @@ var o7 = "Cat" || false;    // t || f returns Cat
 
 
下面是！（逻辑"非"）操作符的示例。

 
-
var n1 = !true;  // !t returns false
+
var n1 = !true;  // !t returns false
 var n2 = !false; // !f returns true
 var n3 = !"Cat"; // !t returns false
 

@@ -551,11 +551,11 @@ var n3 = !"Cat"; // !t returns false
 
 
例如，

 
-
console.log("my " + "string"); // console logs the string "my string".

+
console.log("my " + "string"); // console logs the string "my string".

 
 
简写操作符 += 也可以用来拼接字符串，例如：

 
-
var myString = "alpha";
+
var myString = "alpha";
 
 myString += "bet"; // 返回 "alphabet"  
 

@@ -564,14 +564,14 @@ var n3 = !"Cat"; // !t returns false
 
 
条件运算符是JavaScript中唯一需要三个操作数的运算符。运算的结果根据给定条件在两个值中取其一。语法为：

 
-
条件 ? 值1 : 值2
+
条件 ? 值1 : 值2
 

 
 
如果条件为真，则结果取值1。否则为值2。你能够在任何允许使用标准运算符的地方使用条件运算符。

 
 
例如，

 
-
var status = (age >= 18) ? "adult" : "minor";
+
var status = (age >= 18) ? "adult" : "minor";
 

 
 
当 age 大于等于18的时候，将“adult”赋值给 status；否则将“minor”赋值给 status。

@@ -582,7 +582,7 @@ var n3 = !"Cat"; // !t returns false
 
 
例如，假如 a 是一个二维数组，每个维度各有10个元素，以下代码利用逗号操作符来同时改变两个变量的值。这段代码的功能是打印出该二维数组的对角线元素的值：

 
-
var x = [0,1,2,3,4,5,6,7,8,9]
+
var x = [0,1,2,3,4,5,6,7,8,9]
 var a = [x, x, x, x, x];
 
 for (var i = 0, j = 9; i <= j; i++, j--)
@@ -596,7 +596,7 @@ for (var i = 0, j = 9; i <= j; i++, j--)
 
 
delete操作符，删除一个对象的属性或者一个数组中某一个键值。语法如下:

 
-
delete objectName.property;
+
delete objectName.property;
 delete objectName[index];
 delete property; // legal only within a with statement
 

@@ -609,7 +609,7 @@ delete property; // legal only within a with statement
 
 
如果 delete 操作成功，属性或者元素会变成 undefined。如果 delete可行会返回true，如果不成功返回false。

 
-
x = 42;
+
x = 42;
 var y = 43;
 myobj = new Number();
 myobj.h = 4;    // create property h
@@ -626,7 +626,7 @@ delete myobj;   // returns true (can delete if declared implicitly)
 
 
delete 删除数组中的一个元素，这个元素就不在数组中了。例如，trees[3]被删除，trees[3] 仍然可寻址并返回undefined。

 
-
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
 delete trees[3];
 if (3 in trees) {
   // 不会被执行
@@ -635,7 +635,7 @@ if (3 in trees) {
 
 
如果想让数组中存在一个元素但是是undefined值，使用undefined关键字而不是delete操作. 如下： trees[3]分配一个undefined,但是这个数组元素仍然存在:

 
-
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
+
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
 trees[3] = undefined;
 if (3 in trees) {
   // this gets executed（会被执行）
@@ -646,7 +646,7 @@ if (3 in trees) {
 
 
typeof操作符 可通过下面2种方式使用：

 
-
typeof operand
+
typeof operand
 typeof (operand)
 

 
@@ -654,7 +654,7 @@ typeof (operand)
 
 
假设你定义了如下的变量：

 
-
var myFun = new Function("5 + 2");
+
var myFun = new Function("5 + 2");
 var shape = "round";
 var size = 1;
 var today = new Date();
@@ -662,7 +662,7 @@ var today = new Date();
 
 
typeof 操作符将会返回如下的结果：

 
-
typeof myFun;     // returns "function"
+
typeof myFun;     // returns "function"
 typeof shape;     // returns "string"
 typeof size;      // returns "number"
 typeof today;     // returns "object"
@@ -671,26 +671,26 @@ typeof dontExist; // returns "undefined"
 
 
对于关键词 true 和 null， typeof 操作符将会返回如下结果：

 
-
typeof true; // returns "boolean"
+
typeof true; // returns "boolean"
 typeof null; // returns "object"
 

 
 
对于一个数值或字符串， typeof 操作符将会返回如下结果：

 
-
typeof 62;            // returns "number"
+
typeof 62;            // returns "number"
 typeof 'Hello world'; // returns "string"
 

 
 
对于属性值，typeof 操作符将会返回属性所包含值的类型：

 
-
typeof document.lastModified; // returns "string"
+
typeof document.lastModified; // returns "string"
 typeof window.length;         // returns "number"
 typeof Math.LN2;              // returns "number"
 

 
 
对于方法和函数，typeof 操作符将会返回如下结果：

 
-
typeof blur;        // returns "function"
+
typeof blur;        // returns "function"
 typeof eval;        // returns "function"
 typeof parseInt;    // returns "function"
 typeof shape.split; // returns "function"
@@ -698,7 +698,7 @@ typeof shape.split; // returns "function"
 
 
对于预定义的对象，typeof 操作符将会返回如下结果：

 
-
typeof Date;     // returns "function"
+
typeof Date;     // returns "function"
 typeof Function; // returns "function"
 typeof Math;     // returns "object"
 typeof Option;   // returns "function"
@@ -709,7 +709,7 @@ typeof String;   // returns "function"
 
 
void 运算符运用方法如下：

 
-
void (expression)
+
void (expression)
 void expression
 

 
@@ -719,11 +719,11 @@ void expression
 
 
如下创建了一个超链接文本，当用户单击该文本时，不会有任何效果。

 
-
<a href="javascript:void(0)">Click here to do nothing</a>

+
<a href="javascript:void(0)">Click here to do nothing</a>

 
 
下面的代码创建了一个超链接，当用户单击它时，提交一个表单。

 
-
<a href="javascript:void(document.form.submit())">
+
<a href="javascript:void(document.form.submit())">
 Click here to submit</a>

 
 
关系操作符

@@ -734,14 +734,14 @@ Click here to submit</a>

 
 
in操作符，如果所指定的属性确实存在于所指定的对象中，则会返回true，语法如下：

 
-
propNameOrNumber in objectName
+
propNameOrNumber in objectName
 

 
 
在这里 propNameOrNumber可以是一个代表着属性名的字符串或者是一个代表着数组索引的数值表达式，而objectName则是一个对象名。

 
 
下面的例子是 in 操作的常见用法。

 
-
// Arrays
+
// Arrays
 var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
 0 in trees;        // returns true
 3 in trees;        // returns true
@@ -765,7 +765,7 @@ var mycar = {make: "Honda", model: "Accord", year: 1998};
 
 
如果所判别的对象确实是所指定的类型，则返回true。其语法如下：

 
-
objectName instanceof objectType
+
objectName instanceof objectType
 

 
 
objectName 是需要做判别的对象的名称,而objectType是假定的对象的类型, 例如{{jsxref("Date")}}或 {{jsxref("Array")}}.

@@ -774,7 +774,7 @@ var mycar = {make: "Honda", model: "Accord", year: 1998};
 
 
例如, 下面的代码使用instanceof去判断 theDay是否是一个 Date 对象. 因为theDay是一个Date对象, 所以if中的代码会执行.

 
-
var theDay = new Date(1995, 12, 17);
+
var theDay = new Date(1995, 12, 17);
 if (theDay instanceof Date) {
   // statements to execute
 }
@@ -891,13 +891,13 @@ if (theDay instanceof Date) {
 
 
this关键字被用于指代当前的对象，通常，this指代的是方法中正在被调用的对象。用法如下：

 
-
this["propertyName"]
+
this["propertyName"]
 this.propertyName
 

 
 
假设一个用于验证对象value属性的validate函数，传参有对象，最高值和最低值。

 
-
function validate(obj, lowval, hival){
+
function validate(obj, lowval, hival){
   if ((obj.value < lowval) || (obj.value > hival))
     console.log("Invalid Value!");
 }
@@ -905,7 +905,7 @@ this.propertyName
 
 
你可以在任何表单元素的onchange事件处理中调用validat函数，用this来指代当前的表单元素，用例如下：

 
-
<p>Enter a number between 18 and 99:</p>
+
<p>Enter a number between 18 and 99:</p>
 <input type="text" name="age" size=3 onChange="validate(this, 18, 99);">
 

 
@@ -913,7 +913,7 @@ this.propertyName
 
 
分组操作符（）控制了表达式中计算的优先级. 举例来说, 你可以改变先乘除后加减的顺序，转而先计算加法。

 
-
var a = 1;
+
var a = 1;
 var b = 2;
 var c = 3;
 
@@ -941,7 +941,7 @@ a * c + b * c // 9

 
 
Comprehensions特性被许多编程语言所采用，该特性能够使你快速地通过一个已有的数组来创建出一个新的数组，比如：

 
-
[for (i of [ 1, 2, 3 ]) i*i ];
+
[for (i of [ 1, 2, 3 ]) i*i ];
 // [ 1, 4, 9 ]
 
 var abc = [ "A", "B", "C" ];
@@ -956,14 +956,14 @@ var abc = [ "A", "B", "C" ];
 
 
你可以使用new operator 创建一个自定义类型或者是预置类型的对象实例。用法如下：

 
-
var objectName = new objectType([param1, param2, ..., paramN]);
+
var objectName = new objectType([param1, param2, ..., paramN]);
 

 
 
super

 
 
super 关键字可以用来调用一个对象父类的函数，它在用来调用一个类的父类的构造函数时非常有用，比如：

 
-
super([arguments]); // calls the parent constructor. super.functionOnParent([arguments]);

+
super([arguments]); // calls the parent constructor. super.functionOnParent([arguments]);

 
 
扩展语句

 
@@ -971,12 +971,12 @@ var abc = [ "A", "B", "C" ];
 
 
例如：现在你有一个数组，你想创建一个新数组，并将刚才那个作为它的一部分，用array的字面语法是不够的，你不得不写一些代码实现它，比如用些push, splice, concat等等。但是用spread syntax就没问题了：

 
-
var parts = ['shoulder', 'knees'];
+
var parts = ['shoulder', 'knees'];
 var lyrics = ['head', ...parts, 'and', 'toes'];

 
 
类似的，扩展语句也可以用在函数调用的时候:

 
-
function f(x, y, z) { }
+
function f(x, y, z) { }
 var args = [0, 1, 2];
 f(...args);

 
-- 
cgit v1.2.3-54-g00ecf