indexes访问数组内部的数据。数组索引使用字符串使用的相同括号表示法编写，但不是指定字符，而是指定数组中的条目。与字符串一样，数组使用从零开始的索引，因此数组中的第一个元素是元素0 。 例 var array = [50,60,70];注意
阵列[0]; //等于50
var data = array [1]; //等于60
array [0] 。尽管JavaScript能够正确处理，但这可能会让其他程序员在阅读代码时感到困惑。 indexes 来访问数组中的数据。
+
+数组索引与字符串索引一样使用中括号，但字符串索引得到的是一个字符，而数组索引得到的是一个元素。数组索引与字符串索引一样是从 0 开始的，所以数组中第一个元素的索引编号是 0。
+array [0]尽管 JavaScript 能够正确处理，但可能会让看你代码的其他程序员感到困惑
+myData的变量，并使用括号表示法将其设置为等于myArray的第一个值。 myData的变量，并把myArray的第一个索引上的值赋给它。
+myData应该等于myArray的第一个值。
+ - text: 变量myData的值应该等于myArray的第一个值。
testString: assert((function(){if(typeof myArray !== 'undefined' && typeof myData !== 'undefined' && myArray[0] === myData){return true;}else{return false;}})());
- - text: 应使用括号表示法访问变量myArray的数据。
+ - text: 应使用方括号访问变量myArray中的数据。
testString: assert((function(){if(code.match(/\s*=\s*myArray\[0\]/g)){return true;}else{return false;}})());
```
@@ -50,7 +67,7 @@ var myArray = [50,60,70];
var arr = [注意
[1,2,3]，
[4,5,6]
[7,8,9]
[[10,11,12]，13,14]
]。
ARR [3]; //等于[[10,11,12]，13,14]
ARR [3] [0]; //等于[10,11,12]
ARR [3] [0] [1]; //等于11
array [0][0] ，甚至不允许使用此array [0] [0] 。尽管JavaScript能够正确处理，但这可能会让其他程序员在阅读代码时感到困惑。 [index]访问的是第 N 个子数组，第二个[index]访问的是第 N 个子数组的第N个元素。
+示例
+
+```js
+var arr = [
+ [1,2,3],
+ [4,5,6],
+ [7,8,9],
+ [[10,11,12], 13, 14]
+];
+arr[3]; // equals [[10,11,12], 13, 14]
+arr[3][0]; // equals [10,11,12]
+arr[3][0][1]; // equals 11
+```
+
+提示array [0][0]，甚至array [0] [0]，都是不正确的。尽管 JavaScript 能够处理，但可能会让看你代码的其他程序员感到困惑。
+myArray选择一个元素，使myData等于8 。 myArray选择一个元素，使得myData的值为8。
+myData应该等于8 。
+ - text: myData应该等于8。
testString: assert(myData === 8);
- - text: 您应该使用括号表示法从myArray读取正确的值。
- testString: assert(/myData=myArray\[2\]\[1\]/.test(code.replace(/\s/g, '')));
+ - text: 你应该使用方括号从myArray中取值。
+ testString: 'assert(/myArray\[2\]\[1\]/g.test(code) && !/myData\s*=\s*(?:.*[-+*/%]|\d)/g.test(code));'
```
@@ -47,7 +67,7 @@ var myData = myArray[0][0];
var ourPets = [
{
animalType：“猫”，
名称：[
“Meowzer”
“蓬松”，
“洁猫”
]
}，
{
动物类型：“狗”，
名称：[
“点”，
“库巴”
“羊羊”
]
}
]。
ourPets [0] .names [1]; //“蓬松”
ourPets [1] .names [0]; //“Spot”
myPlants检索第二个树。 myPlants的第二棵树。
+secondTree应该等于“松树”
+ - text: secondTree应该等于 "pine"。
testString: assert(secondTree === "pine");
- - text: 使用点和括号表示法访问myPlants
+ - text: 使用点操作符和中括号操作符来检索变量myPlants。
testString: assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
```
@@ -65,7 +95,12 @@ var secondTree = ""; // Change this line
var ourStorage = {
“桌子”：{
“抽屉”：“订书机”
}，
“内阁”：{
“顶级抽屉”：{
“folder1”：“一个文件”，
“folder2”：“秘密”
}，
“底部抽屉”：“苏打水”
}
};
ourStorage.cabinet [“top drawer”]。folder2; //“秘密”
ourStorage.desk.drawer; //“订书机”
myStorage对象并将glove box属性的内容分配给gloveBoxContents变量。对于名称中包含空格的属性，请使用括号表示法。 myStorage对象，将glove box属性的内容赋值给变量gloveBoxContents。在适用的地方使用点操作符来访问属性，否则使用中括号操作符。
+gloveBoxContents应该等于“地图”
+ - text: gloveBoxContents应该等于"maps"。
testString: assert(gloveBoxContents === "maps");
- - text: 使用点和括号表示法访问myStorage
+ - text: 应使用点操作符和中括号操作符来访问myStorage。
testString: assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
```
@@ -56,7 +80,12 @@ var gloveBoxContents = undefined; // Change this line
[] ）。如果您尝试访问的对象的属性在其名称中有空格，则需要使用括号表示法。但是，您仍然可以在没有空格的对象属性上使用括号表示法。以下是使用括号表示法读取对象属性的示例： var myObj = {请注意，其中包含空格的属性名称必须使用引号（单引号或双引号）。
“太空名称”：“柯克”，
“更多空间”：“Spock”，
“NoSpace”：“USS Enterprise”
};
myObj [“空间名称”]; //柯克
myObj ['更多空间']; // Spock
MyObj中[ “无空间”]; // USS Enterprise
[])，如果你想访问的属性的名称有一个空格，这时你只能使用中括号操作符([])。
+当然，如果属性名不包含空格，也可以使用中括号操作符。
+这是一个使用中括号操作符([])读取对象属性的例子：
+
+```js
+var myObj = {
+ "Space Name": "Kirk",
+ "More Space": "Spock",
+ "NoSpace": "USS Enterprise"
+};
+myObj["Space Name"]; // Kirk
+myObj['More Space']; // Spock
+myObj["NoSpace"]; // USS Enterprise
+```
+
+提示：属性名称中如果有空格，必须把属性名称用单引号或双引号包裹起来。
+testObj属性"an entree" testObj "an entree"和"the drink"的testObj ，并分别将它们分配给entreeValue和drinkValue 。 testObj的an entree属性值和the drink属性值，并分别赋值给entreeValue和drinkValue。
+entreeValue应该是一个字符串
+ - text: entreeValue应该是一个字符串。
testString: assert(typeof entreeValue === 'string' );
- - text: entreeValue的值应该是"hamburger"
+ - text: entreeValue的值应该是"hamburger"。
testString: assert(entreeValue === 'hamburger' );
- - text: drinkValue应该是一个字符串
+ - text: drinkValue应该是一个字符串。
testString: assert(typeof drinkValue === 'string' );
- - text: drinkValue的值应该是"water"
+ - text: drinkValue的值应该是"water"。
testString: assert(drinkValue === 'water' );
- - text: 您应该使用括号表示法两次
+ - text: 你应该使用中括号两次。
testString: assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
```
@@ -49,7 +69,6 @@ var testObj = {
var entreeValue = testObj; // Change this line
var drinkValue = testObj; // Change this line
-
```
@@ -59,7 +78,7 @@ var drinkValue = testObj; // Change this line
. ）和括号表示法（ [] ），类似于数组。当您知道要提前访问的属性的名称时，使用点符号。以下是使用点表示法（ . ）读取对象属性的示例： var myObj = {
prop1：“val1”，
prop2：“val2”
};
var prop1val = myObj.prop1; // val1
var prop2val = myObj.prop2; // val2
.)，一个是中括号操作符([])。
+当你知道所要读取的属性的名称的时候，使用点操作符。
+这是一个使用点操作符读取对象属性的例子：
+
+```js
+var myObj = {
+ prop1: "val1",
+ prop2: "val2"
+};
+var prop1val = myObj.prop1; // val1
+var prop2val = myObj.prop2; // val2
+```
+
+testObj的属性值。将变量hatValue设置为等于对象的属性hat ，并将变量shirtValue设置为等于对象的属性shirt 。 testObj，把hat的属性值赋给变量hatValue，把shirt的属性值赋给shirtValue。
+hatValue应该是一个字符串
+ - text: hatValue应该是一个字符串。
testString: assert(typeof hatValue === 'string' );
- - text: hatValue的值应该是"ballcap"
+ - text: hatValue的值应该是"ballcap"。
testString: assert(hatValue === 'ballcap' );
- - text: shirtValue应该是一个字符串
+ - text: shirtValue应该是一个字符串。
testString: assert(typeof shirtValue === 'string' );
- - text: shirtValue的值应该是"jersey"
+ - text: shirtValue的值应该是"jersey"。
testString: assert(shirtValue === 'jersey' );
- - text: 你应该使用点符号两次
+ - text: 你应该使用点操作符两次。
testString: assert(code.match(/testObj\.\w+/g).length > 1);
```
@@ -49,7 +66,6 @@ var testObj = {
var hatValue = testObj; // Change this line
var shirtValue = testObj; // Change this line
-
```
@@ -59,7 +75,7 @@ var shirtValue = testObj; // Change this line
var dogs = {另一种可以使用此概念的方法是在程序执行期间动态收集属性的名称，如下所示：
Fido：“Mutt”，Hunter：“Doberman”，Snoopie：“Beagle”
};
var myDog =“猎人”;
var myBreed = dogs [myDog];
的console.log（myBreed）; //“杜宾犬”
var someObj = {请注意，在使用变量名来访问属性时，我们不会使用引号，因为我们使用的是变量的值 ，而不是名称 。
propName：“约翰”
};
function propPrefix（str）{
var s =“prop”;
return s + str;
}
var someProp = propPrefix（“Name”）; // someProp现在保存值'propName'
的console.log（someObj中[someProp]）; // “约翰”
playerNumber变量使用括号表示法在testObj查找玩家16 。然后将该名称分配给player变量。 playerNumber，通过中括号操作符找到testObj中playerNumber为16的值。然后把名字赋给变量player。
+playerNumber应该是一个数字
+ - text: playerNumber应该是一个数字。
testString: assert(typeof playerNumber === 'number');
- - text: 变量player应该是一个字符串
+ - text: 变量player应该是一个字符串。
testString: assert(typeof player === 'string');
- - text: player的价值应该是“蒙大拿”
+ - text: player点值应该是 "Montana"。
testString: assert(player === 'Montana');
- - text: 您应该使用括号表示法来访问testObj
+ - text: 你应该使用中括号访问testObj。
testString: assert(/testObj\s*?\[.*?\]/.test(code));
- - text: 您不应该直接将值Montana分配给变量player 。
+ - text: 你不应该直接将Montana赋给player。
testString: assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
- - text: 您应该在括号表示法中使用变量playerNumber
+ - text: 你应该在中括号中使用playerNumber变量。
testString: assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));
```
@@ -51,7 +82,6 @@ var testObj = {
var playerNumber; // Change this Line
var player = testObj; // Change this Line
-
```
@@ -61,7 +91,7 @@ var player = testObj; // Change this Line
ourDog添加"bark"属性： ourDog.bark = "bow-wow";或者我们的ourDog["bark"] = "bow-wow";现在当我们评估我们的ourDog.bark ，我们会得到他的吠声，“低头哇”。 ourDog添加"bark"属性：
+ourDog.bark = "bow-wow";
+或者
+ourDog["bark"] = "bow-wow";
+现在当我们访问ourDog.bark时会得到 ourDog 的 bark 值 "bow-wow".
+myDog添加"bark"属性并将其设置为狗声，例如“woof”。您可以使用点或括号表示法。 myDog添加一个"bark"属性，设置它的值为狗的声音，例如："woof"。你可以使用点或中括号操作符。
+"bark"添加到myDog 。
+ - text: 给myDog添加"bark"属性。
testString: assert(myDog.bark !== undefined);
- - text: 不要在设置部分添加"bark"
- testString: assert(!/bark[^\n]:/.test(code));
+ - text: 不能在初始化 myDog 的时候添加"bark"属性。
+ testString: 'assert(!/bark[^\n]:/.test(code));'
```
@@ -61,7 +71,7 @@ var myDog = {
Number是JavaScript中的数据类型，表示数字数据。现在让我们尝试使用JavaScript添加两个数字。当放置在两个数字之间时，JavaScript使用+符号作为加法运算。 例 myVar = 5 + 10; //分配15
Number是 JavaScript 中的一种数据类型，表示数值。
+现在让我们来尝试在 JavaScript 中做加法运算。
+JavaScript 中使用+号进行加法运算。
+示例
+
+```js
+myVar = 5 + 10; // assigned 15
+```
+
+0使总和等于20 。 0让变量 sum 的值为20。
+sum应该等于20
+ - text: sum应该等于20。
testString: assert(sum === 20);
- - text: 使用+运算符
+ - text: 要使用+运算符。
testString: assert(/\+/.test(code));
```
@@ -43,7 +56,7 @@ var sum = 10 + 0;
switch语句中，您可能无法将所有可能的值指定为case语句。相反，您可以添加default语句，如果找不到匹配的case语句，将执行该语句。可以把它想象成if/else链中的最后一个else语句。 default语句应该是最后一种情况。 switch（num）{
案例值1：
语句1;
打破;
案例值2：
语句2;
打破;
...
默认：
defaultStatement;
打破;
}
switch语句中你可能无法用 case 来指定所有情况，这时你可以添加 default 语句。当再也找不到 case 匹配的时候 default 语句会执行，非常类似于 if/else 组合中的 else 语句。
+default语句应该是最后一个 case。
+
+```js
+switch (num) {
+ case value1:
+ statement1;
+ break;
+ case value2:
+ statement2;
+ break;
+...
+ default:
+ defaultStatement;
+ break;
+}
+```
+
+answer ： "a" - “苹果” "b" - “鸟” "c" - “猫” default - “东西” answer的switch语句："a" - "apple""b" - "bird""c" - "cat"default - "stuff"
+switchOfStuff("a")的值应为“apple”
+ - text: switchOfStuff("a")应该有一个值为 "apple"。
testString: assert(switchOfStuff("a") === "apple");
- - text: switchOfStuff("b")的值应为“bird”
+ - text: switchOfStuff("b")应该有一个值为 "bird"。
testString: assert(switchOfStuff("b") === "bird");
- - text: switchOfStuff("c")的值应为“cat”
+ - text: switchOfStuff("c")应该有一个值为 "cat"。
testString: assert(switchOfStuff("c") === "cat");
- - text: switchOfStuff("d")的值应为“stuff”
+ - text: switchOfStuff("d")应该有一个值为 "stuff"。
testString: assert(switchOfStuff("d") === "stuff");
- - text: switchOfStuff(4)的值应为“stuff”
+ - text: switchOfStuff(4)应该有一个值为 "stuff"。
testString: assert(switchOfStuff(4) === "stuff");
- - text: 您不应该使用任何if或else语句
+ - text: 不能使用任何if或else表达式。
testString: assert(!/else/g.test(code) || !/if/g.test(code));
- - text: 您应该使用default语句
+ - text: 你应该有一个default表达式。
testString: assert(switchOfStuff("string-to-trigger-default-case") === "stuff");
- - text: 你应该至少有3个break语句
+ - text: 你应该有至少 3 个break表达式。
testString: assert(code.match(/break/g).length > 2);
```
@@ -68,7 +90,26 @@ switchOfStuff(1);
## Solution
+= ）运算符将变量附加到字符串。 +=)运算符来将变量追加到字符串。
+someAdjective并使用+=运算符将其附加到myStr 。 someAdjective的值，并使用+=运算符把它追加到变量myStr上。
+someAdjective应设置为至少3个字符长的字符串
+ - text: someAdjective应该是一个至少包含三个字符的字符串。
testString: assert(typeof someAdjective !== 'undefined' && someAdjective.length > 2);
- - text: 使用+=运算符将someAdjective附加到myStr
+ - text: 使用+=操作符把someAdjective追加到myStr的后面。
testString: assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
```
@@ -51,7 +56,20 @@ var myStr = "Learning to code is ";
sum ，它将两个数字相加，然后： ourSum = sum(5, 12);将调用sum函数，它返回值17并将其分配给ourSum变量。 sum其功能就是将两个数字相加，那么：
+ourSum = sum(5, 12);
+将调用sum函数，返回return了一个数值17，然后把它赋值给了ourSum变量。
+7调用processArg函数，并将其返回值分配给已processed的变量。 processArg函数并给参数一个值7，然后把返回的值赋值给变量processed。
+processed的值应为2
+ - text: processed的值应该是2。
testString: assert(processed === 2);
- - text: 您应该将processArg分配给已processed
- testString: assert(/processed\s*=\s*processArg\(\s*7\s*\)/.test(code));
+ - text: 你应该把processArg的返回值赋给processed。
+ testString: assert(/processed\s*=\s*processArg\(\s*7\s*\)\s*;/.test(code));
```
@@ -50,6 +58,7 @@ function processArg(num) {
// Only change code below this line
+
```
@@ -59,7 +68,7 @@ function processArg(num) {
object这个术语。对象类似于arrays ，除了不使用索引访问和修改数据，您可以通过所谓的properties访问对象中的数据。对象对于以结构化方式存储数据很有用，并且可以表示真实世界对象，如猫。这是一个示例cat对象： var cat = {在此示例中，所有属性都存储为字符串，例如 -
“名字”：“胡须”，
“腿”：4，
“尾巴”：1，
“敌人”：[“水”，“狗”]
};
"name" ， "legs"和"tails" 。但是，您也可以使用数字作为属性。您甚至可以省略单字符串属性的引号，如下所示： var anotherObject = {但是，如果您的对象具有任何非字符串属性，JavaScript将自动将它们作为字符串进行类型转换。
制作：“福特”，
5：“五”，
“模特”：“焦点”
};
object。
+对象和数组很相似，数组是通过索引来访问和修改数据，而对象是通过属性来访问和修改数据。
+对象适合用来存储结构化数据，就和真实世界的对象一模一样，比如一只猫。
+这是一个对象的示例：
+
+```js
+var cat = {
+ "name": "Whiskers",
+ "legs": 4,
+ "tails": 1,
+ "enemies": ["Water", "Dogs"]
+};
+```
+
+在这个示例中所有的属性以字符串的形式储存，例如，"name"、"legs"和"tails"。但是，你也可以使用数字作为属性，你甚至可以省略字符串属性的引号，如下所示：
+
+```js
+var anotherObject = {
+ make: "Ford",
+ 5: "five",
+ "model": "focus"
+};
+```
+
+但是，如果你的对象具有任何非字符串属性，JavaScript 将自动将它们转换为字符串类型。
+myDog的狗的对象，其中包含属性"name" （字符串）， "legs" ， "tails"和"friends" 。您可以将这些对象属性设置为您想要的任何值，因为"name"是一个字符串， "legs"和"tails"是数字， "friends"是一个数组。 myDog的对象，它里面有这些属性："name"、"legs"、"tails"、"friends"。
+你可以设置对象属性为任何值，只需要确保"name"是字符串，"legs"和"tails"是数字，"friends"是数组。
+myDog应该包含属性name ，它应该是一个string 。
+ - text: myDog应该包含name属性，并且是一个字符串string。
testString: assert((function(z){if(z.hasOwnProperty("name") && z.name !== undefined && typeof z.name === "string"){return true;}else{return false;}})(myDog));
- - text: myDog应该包含属性legs ，它应该是一个number 。
+ - text: myDog应该包含legs属性，并且是一个数字number。
testString: assert((function(z){if(z.hasOwnProperty("legs") && z.legs !== undefined && typeof z.legs === "number"){return true;}else{return false;}})(myDog));
- - text: myDog应该包含属性tails ，它应该是一个number 。
+ - text: myDog应该包含tails属性，并且是一个数字number。
testString: assert((function(z){if(z.hasOwnProperty("tails") && z.tails !== undefined && typeof z.tails === "number"){return true;}else{return false;}})(myDog));
- - text: myDog应该包含属性friends ，它应该是一个array 。
+ - text: myDog应该包含friends属性，并且是一个数组array。
testString: assert((function(z){if(z.hasOwnProperty("friends") && z.friends !== undefined && Array.isArray(z.friends)){return true;}else{return false;}})(myDog));
- - text: myDog应该只包含所有给定的属性。
+ - text: myDog应该只包含给出的属性。
testString: assert((function(z){return Object.keys(z).length === 4;})(myDog));
```
@@ -54,7 +84,6 @@ var myDog = {
};
-
```
@@ -64,7 +93,7 @@ var myDog = {
if/else语句可以链接在一起以用于复杂的逻辑。这是多个链式if / else if语句的伪代码 ： if（ condition1 ）{
语句1
} else if（ condition2 ）{
语句2
} else if（ condition3 ）{
声明3
。 。 。
} else {
statementN
}
if/else语句串联在一起可以实现复杂的逻辑，这是多个if/else if语句串联在一起的伪代码：
+
+```js
+if (condition1) {
+ statement1
+} else if (condition2) {
+ statement2
+} else if (condition3) {
+ statement3
+. . .
+} else {
+ statementN
+}
+```
+
+if / else if语句以满足以下条件： num < 5 - return“Tiny” num < 10 - 返回“Small” num < 15 - 返回“中” num < 20 - 返回“Large” num >= 20 - 返回“巨大” if/else if语句串联起来实现下面的逻辑：
+num < 5- return "Tiny"num < 10- return "Small"num < 15- return "Medium"num < 20- return "Large"num >= 20 - return "Huge"
+else语句
+ - text: 你应该有至少 4 个else表达式。
testString: assert(code.match(/else/g).length > 3);
- - text: 你应该至少有四个if语句
+ - text: 你应该有至少 4 个if表达式。
testString: assert(code.match(/if/g).length > 3);
- - text: 你应该至少有一个return语句
+ - text: 你应该有至少 1 个return表达式。
testString: assert(code.match(/return/g).length >= 1);
- - text: testSize(0)应该返回“Tiny”
+ - text: testSize(0)应该返回 "Tiny"。
testString: assert(testSize(0) === "Tiny");
- - text: testSize(4)应该返回“Tiny”
+ - text: testSize(4)应该返回 "Tiny"。
testString: assert(testSize(4) === "Tiny");
- - text: testSize(5)应返回“Small”
+ - text: testSize(5)应该返回 "Small"。
testString: assert(testSize(5) === "Small");
- - text: testSize(8)应该返回“Small”
+ - text: testSize(8)应该返回 "Small"。
testString: assert(testSize(8) === "Small");
- - text: testSize(10)应该返回“Medium”
+ - text: testSize(10)应该返回 "Medium"。
testString: assert(testSize(10) === "Medium");
- - text: testSize(14)应返回“Medium”
+ - text: testSize(14)应该返回 "Medium"。
testString: assert(testSize(14) === "Medium");
- - text: testSize(15)应该返回“Large”
+ - text: testSize(15)应该返回 "Large"。
testString: assert(testSize(15) === "Large");
- - text: testSize(17)应该返回“Large”
+ - text: testSize(17)应该返回 "Large"。
testString: assert(testSize(17) === "Large");
- - text: testSize(20)应该返回“巨大”
+ - text: testSize(20)应该返回 "Huge"。
testString: assert(testSize(20) === "Huge");
- - text: testSize(25)应该返回“巨大”
+ - text: testSize(25)应该返回 "Huge"。
testString: assert(testSize(25) === "Huge");
```
@@ -64,7 +84,6 @@ function testSize(num) {
// Change this value to test
testSize(7);
-
```
@@ -76,7 +95,21 @@ testSize(7);
## Solution
//将告诉JavaScript忽略当前行上的其余文本： //这是一个内嵌评论。您可以使用
/*开头并以*/结尾的多行注释： /* 这是一个最佳实践
多行评论* /
//注释掉当前行的代码
+
+```js
+// This is an in-line comment.
+```
+
+你也可以使用多行注释来注释你的代码，以/*开始，用*/来结束，就像下面这样：
+
+```js
+/* This is a
+multi-line comment */
+```
+
+最佳实践//样式注释。
+ - text: 创建一个//样式的注释, 被注释的文本至少要包含 5 个字符。
testString: assert(code.match(/(\/\/)...../g));
- - text: 创建包含至少五个字母的/* */样式注释。
+ - text: 创建一个/* */样式的注释, 被注释的文本至少要包含 5 个字符。
testString: assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm));
```
@@ -44,7 +64,10 @@ tests:
## Solution
true或false值。最基本的运算符是等于运算符== 。等于运算符比较两个值，如果它们是等价的则返回true否则返回false 。请注意，相等性与赋值（ = ）不同，后者将运算符右侧的值分配给左侧的变量。 function equalityTest（myVal）{如果
if（myVal == 10）{
返回“平等”;
}
返回“不等于”;
}
myVal等于10 ，则等于运算符返回true ，因此大括号中的代码将执行，函数将返回"Equal" 。否则，该函数将返回"Not Equal" 。为了使JavaScript能够比较两种不同的data types （例如， numbers和strings ），它必须将一种类型转换为另一种类型。这被称为“类型强制”。但是，一旦它完成，它可以比较如下术语： 1 == 1 //是的
1 == 2 //假
1 =='1'//是的
“3”== 3 //是的
true或false值。
+最基本的运算符是相等运算符：==。相等运算符比较两个值，如果它们是同等，返回true，如果它们不等，返回false。值得注意的是相等运算符不同于赋值运算符（=），赋值运算符是把等号右边的值赋给左边的变量。
+
+```js
+function equalityTest(myVal) {
+ if (myVal == 10) {
+ return "Equal";
+ }
+ return "Not Equal";
+}
+```
+
+如果myVal等于10，相等运算符会返回true，因此大括号里面的代码会被执行，函数将返回"Equal"。否则，函数返回"Not Equal"。
+在 JavaScript 中，为了让两个不同的数据类型（例如数字和字符串）的值可以作比较，它必须把一种类型转换为另一种类型。然而一旦这样做，它可以像下面这样来比较：
+
+```js
+1 == 1 // true
+1 == 2 // false
+1 == '1' // true
+"3" == 3 // true
+```
+
+equality operator添加到指示的行，以便当val等于12时，函数将返回“Equal” 相等运算符添加到指定的行，这样当val的值为12的时候，函数会返回"Equal"。
+testEqual(10)应该返回“Not Equal”
+ - text: testEqual(10)应该返回 "Not Equal"。
testString: assert(testEqual(10) === "Not Equal");
- - text: testEqual(12)应返回“Equal”
+ - text: testEqual(12)应该返回 "Equal"。
testString: assert(testEqual(12) === "Equal");
- - text: testEqual("12")应返回“Equal”
+ - text: testEqual("12")应该返回 "Equal"。
testString: assert(testEqual("12") === "Equal");
- - text: 您应该使用==运算符
+ - text: 你应该使用==运算符。
testString: assert(code.match(/==/g) && !code.match(/===/g));
```
@@ -46,7 +72,6 @@ function testEqual(val) {
// Change this value to test
testEqual(10);
-
```
@@ -58,7 +83,14 @@ testEqual(10);
## Solution
> ）比较两个数字的值。如果左边的数字大于右边的数字，则返回true 。否则，它返回false 。与等于运算符一样，大于运算符将在比较时转换数据类型的值。 例子 5> 3 //是的
7>'3'//是的
2> 3 //假
'1'> 9 //假
>）来比较两个数字。如果大于运算符左边的数字大于右边的数字，将会返回true。否则，它返回false。
+与相等运算符一样，大于运算符在比较的时候，会转换值的数据类型。
+例如
+
+```js
+5 > 3 // true
+7 > '3' // true
+2 > 3 // false
+'1' > 9 // false
+```
+
+greater than运算符添加到指示的行，以便返回语句有意义。 大于运算符到指定的行，使得返回的语句是有意义的。
+testGreaterThan(0)应返回“10或Under”
+ - text: testGreaterThan(0)应该返回 "10 or Under"。
testString: assert(testGreaterThan(0) === "10 or Under");
- - text: testGreaterThan(10)应返回“10或Under”
+ - text: testGreaterThan(10)应该返回 "10 or Under"。
testString: assert(testGreaterThan(10) === "10 or Under");
- - text: testGreaterThan(11)应该返回“Over 10”
+ - text: testGreaterThan(11)应该返回 "Over 10"。
testString: assert(testGreaterThan(11) === "Over 10");
- - text: testGreaterThan(99)应该返回“Over 10”
+ - text: testGreaterThan(99)应该返回 "Over 10"。
testString: assert(testGreaterThan(99) === "Over 10");
- - text: testGreaterThan(100)应该返回“Over 10”
+ - text: testGreaterThan(100)应该返回 "Over 10"。
testString: assert(testGreaterThan(100) === "Over 10");
- - text: testGreaterThan(101)应返回“超过100”
+ - text: testGreaterThan(101)应该返回 "Over 100"。
testString: assert(testGreaterThan(101) === "Over 100");
- - text: testGreaterThan(150)应该返回“超过100”
+ - text: testGreaterThan(150)应该返回 "Over 100"。
testString: assert(testGreaterThan(150) === "Over 100");
- - text: 您应该至少使用>运算符两次
+ - text: 你应该使用>运算符至少两次。
testString: assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);
```
@@ -58,7 +73,6 @@ function testGreaterThan(val) {
// Change this value to test
testGreaterThan(10);
-
```
@@ -70,7 +84,17 @@ testGreaterThan(10);
## Solution
greater than or equal to运算符（ >= ）比较两个数字的值。如果左边的数字大于或等于右边的数字，则返回true 。否则，它返回false 。与等于运算符一样， greater than or equal to运算符将在比较时转换数据类型。 例子 6> = 6 //是的
7> ='3'//是的
2> = 3 //假
'7'> = 9 //假
大于等于运算符（>=）来比较两个数字的大小。如果大于等于运算符左边的数字比右边的数字大或者相等，它会返回true。否则，它会返回false。
+与相等运算符相似，大于等于运算符在比较的时候会转换值的数据类型。
+例如
+
+```js
+6 >= 6 // true
+7 >= '3' // true
+2 >= 3 // false
+'7' >= 9 // false
+```
+
+greater than or equal to运算符添加到指示的行，以便返回语句有意义。 大于等于运算符到指定行，使得函数的返回语句有意义。
+testGreaterOrEqual(0)应返回“小于10”
+ - text: testGreaterOrEqual(0)应该返回 "Less than 10"。
testString: assert(testGreaterOrEqual(0) === "Less than 10");
- - text: testGreaterOrEqual(9)应返回“小于10”
+ - text: testGreaterOrEqual(9)应该返回 "Less than 10"。
testString: assert(testGreaterOrEqual(9) === "Less than 10");
- - text: testGreaterOrEqual(10)应返回“10或Over”
+ - text: testGreaterOrEqual(10)应该返回 "10 or Over"。
testString: assert(testGreaterOrEqual(10) === "10 or Over");
- - text: testGreaterOrEqual(11)应返回“10或Over”
+ - text: testGreaterOrEqual(11)应该返回 "10 or Over"。
testString: assert(testGreaterOrEqual(11) === "10 or Over");
- - text: testGreaterOrEqual(19)应返回“10或Over”
+ - text: testGreaterOrEqual(19)应该返回 "10 or Over"。
testString: assert(testGreaterOrEqual(19) === "10 or Over");
- - text: testGreaterOrEqual(100)应该返回“20或Over”
+ - text: testGreaterOrEqual(100)应该返回 "20 or Over"。
testString: assert(testGreaterOrEqual(100) === "20 or Over");
- - text: testGreaterOrEqual(21)应返回“20或Over”
+ - text: testGreaterOrEqual(21)应该返回 "20 or Over"。
testString: assert(testGreaterOrEqual(21) === "20 or Over");
- - text: 您应该使用>=运算符至少两次
+ - text: 你应该使用>=运算符至少两次。
testString: assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);
```
@@ -58,7 +73,6 @@ function testGreaterOrEqual(val) {
// Change this value to test
testGreaterOrEqual(10);
-
```
@@ -70,7 +84,19 @@ testGreaterOrEqual(10);
## Solution
!= ）与等于运算符相反。它意味着“不等于”并返回false ，其中相等性将返回true ， 反之亦然 。与等式运算符一样，不等式运算符将在比较时转换数据类型的值。 例子 1！= 2 //是的
1！=“1”//假
1！='1'//假
1！= true // false
0！= false // false
!=）与相等运算符是相反的。这意味着不相等运算符中，如果“不为真”并且返回false的地方，在相等运算符中会返回true，反之亦然。与相等运算符类似，不相等运算符在比较的时候也会转换值的数据类型。
+例如
+
+```js
+1 != 2 // true
+1 != "1" // false
+1 != '1' // false
+1 != true // false
+0 != false // false
+```
+
+if语句中添加不等式运算符!= ，以便当val不等于99时函数将返回“Not Equal” if语句中，添加不相等运算符!=，这样函数在当val不等于 99的时候，会返回 "Not Equal"。
+testNotEqual(99)应返回“Equal”
+ - text: testNotEqual(99)应该返回 "Equal"。
testString: assert(testNotEqual(99) === "Equal");
- - text: testNotEqual("99")应该返回“Equal”
+ - text: testNotEqual("99")应该返回 "Equal"。
testString: assert(testNotEqual("99") === "Equal");
- - text: testNotEqual(12)应该返回“Not Equal”
+ - text: testNotEqual(12)应该返回 "Not Equal"。
testString: assert(testNotEqual(12) === "Not Equal");
- - text: testNotEqual("12")应该返回“Not Equal”
+ - text: testNotEqual("12")应该返回 "Not Equal"。
testString: assert(testNotEqual("12") === "Not Equal");
- - text: testNotEqual("bob")应返回“Not Equal”
+ - text: testNotEqual("bob")应该返回 "Not Equal"。
testString: assert(testNotEqual("bob") === "Not Equal");
- - text: 你应该使用!=运算符
+ - text: 你应该使用!=运算符。
testString: assert(code.match(/(?!!==)!=/));
```
@@ -50,7 +65,6 @@ function testNotEqual(val) {
// Change this value to test
testNotEqual(10);
-
```
@@ -62,7 +76,14 @@ testNotEqual(10);
## Solution
< ）比较两个数字的值。如果左边的数字小于右边的数字，则返回true 。否则，它返回false 。与等于运算符一样， 少于运算符在比较时转换数据类型。 例子 2 <5 //是的
'3'<7 //是的
5 <5 //假
3 <2 //假
'8'<4 //假
<）比较两个数字的大小。如果小于运算符左边的数字比右边的数字小，它会返回true。否则会返回false。与相等运算符类似，小于 运算符在做比较的时候会转换值的数据类型。
+例如
+
+```js
+2 < 5 // true
+'3' < 7 // true
+5 < 5 // false
+3 < 2 // false
+'8' < 4 // false
+```
+
+less than运算符添加到指示的行，以便返回语句有意义。 小于运算符到指定行，使得函数的返回语句有意义。
+testLessThan(0)应该返回“25岁以下”
+ - text: testLessThan(0)应该返回 "Under 25"。
testString: assert(testLessThan(0) === "Under 25");
- - text: testLessThan(24)应该返回“25岁以下”
+ - text: testLessThan(24)应该返回 "Under 25"。
testString: assert(testLessThan(24) === "Under 25");
- - text: testLessThan(25)应该返回“55岁以下”
+ - text: testLessThan(25)应该返回 "Under 55"。
testString: assert(testLessThan(25) === "Under 55");
- - text: testLessThan(54)应该返回“55岁以下”
+ - text: testLessThan(54)应该返回 "Under 55"。
testString: assert(testLessThan(54) === "Under 55");
- - text: testLessThan(55)应返回“55或以上”
+ - text: testLessThan(55)应该返回 "55 or Over"。
testString: assert(testLessThan(55) === "55 or Over");
- - text: testLessThan(99)应返回“55或以上”
+ - text: testLessThan(99)应该返回 "55 or Over"。
testString: assert(testLessThan(99) === "55 or Over");
- - text: 您应该至少使用<运算符两次
+ - text: 你应该使用<运算符至少两次。
testString: assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);
```
@@ -56,7 +71,6 @@ function testLessThan(val) {
// Change this value to test
testLessThan(10);
-
```
@@ -68,7 +82,19 @@ testLessThan(10);
## Solution
less than or equal to运算符（ <= ）比较两个数字的值。如果左边的数字小于或等于右边的数字，则返回true 。如果左侧的数字大于右侧的数字，则返回false 。与等于运算符一样， less than or equal to转换数据类型。 例子 4 <= 5 //是的
'7'<= 7 //是的
5 <= 5 //是的
3 <= 2 //假
'8'<= 4 //假
小于等于运算符（<=）比较两个数字的大小。如果在小于等于运算符左边的数字小于或者等于右边的数字，它会返回true。如果在小于等于运算符左边的数字大于右边的数字，它会返回false。与相等运算符类似，小于等于运算符会转换数据类型。
+例如
+
+```js
+4 <= 5 // true
+'7' <= 7 // true
+5 <= 5 // true
+3 <= 2 // false
+'8' <= 4 // false
+```
+
+less than or equal to运算符添加到指示的行，以便返回语句有意义。 小于等于运算符到指定行，使得函数的返回语句有意义。
+testLessOrEqual(0)应该返回“小于或等于12”
+ - text: testLessOrEqual(0)应该返回 "Smaller Than or Equal to 12"。
testString: assert(testLessOrEqual(0) === "Smaller Than or Equal to 12");
- - text: testLessOrEqual(11)应返回“小于或等于12”
+ - text: testLessOrEqual(11)应该返回 "Smaller Than or Equal to 12"。
testString: assert(testLessOrEqual(11) === "Smaller Than or Equal to 12");
- - text: testLessOrEqual(12)应返回“小于或等于12”
+ - text: testLessOrEqual(12)应该返回 "Smaller Than or Equal to 12"。
testString: assert(testLessOrEqual(12) === "Smaller Than or Equal to 12");
- - text: testLessOrEqual(23)应返回“小于或等于24”
+ - text: testLessOrEqual(23)应该返回 "Smaller Than or Equal to 24"。
testString: assert(testLessOrEqual(23) === "Smaller Than or Equal to 24");
- - text: testLessOrEqual(24)应返回“小于或等于24”
+ - text: testLessOrEqual(24)应该返回 "Smaller Than or Equal to 24"。
testString: assert(testLessOrEqual(24) === "Smaller Than or Equal to 24");
- - text: testLessOrEqual(25)应该返回“超过24”
+ - text: testLessOrEqual(25)应该返回 "More Than 24"。
testString: assert(testLessOrEqual(25) === "More Than 24");
- - text: testLessOrEqual(55)应该返回“超过24”
+ - text: testLessOrEqual(55)应该返回 "More Than 24"。
testString: assert(testLessOrEqual(55) === "More Than 24");
- - text: 你应该至少使用<=运算符两次
+ - text: 你应该使用<=运算符至少两。
testString: assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);
```
@@ -70,7 +85,19 @@ testLessOrEqual(10);
## Solution
=== ）是相等运算符（ == ）的对应物。但是，与尝试将两个值转换为常见类型的等式运算符不同，严格相等运算符不执行类型转换。如果要比较的值具有不同的类型，则认为它们不相等，并且严格相等运算符将返回false。 例子 3 === 3 //是的在第二个示例中，
3 ==='3'//假
3是Number类型， '3'是String类型。 ===）是相对相等操作符（==）的另一种比较操作符。与相等操作符不同的是，它会同时比较元素的值和数据类型。
+如果比较的值类型不同，那么在严格相等运算符比较下它们是不相等的，会返回 false 。
+示例
+
+```js
+3 === 3 // true
+3 === '3' // false
+```
+
+3是一个数字类型的，而'3'是一个字符串类型的，所以 3 不全等于 '3'。
+if语句中使用strict equality运算符，因此当val严格等于7时，函数将返回“Equal” if语句值使用严格相等运算符，这样当val严格等于7的时候，函数会返回"Equal"。
+testStrict(10)应返回“Not Equal”
+ - text: testStrict(10)应该返回 "Not Equal"。
testString: assert(testStrict(10) === "Not Equal");
- - text: testStrict(7)应返回“Equal”
+ - text: testStrict(7)应该返回 "Equal"。
testString: assert(testStrict(7) === "Equal");
- - text: testStrict("7")应返回“Not Equal”
+ - text: testStrict("7")应该返回 "Not Equal"。
testString: assert(testStrict("7") === "Not Equal");
- - text: 您应该使用===运算符
+ - text: 你应该使用===运算符。
testString: assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);
```
@@ -46,7 +60,6 @@ function testStrict(val) {
// Change this value to test
testStrict(10);
-
```
@@ -58,7 +71,14 @@ testStrict(10);
## Solution
!== ）与严格相等运算符的逻辑相反。它意味着“严格不等于”并返回false ，其中严格相等将返回true ， 反之亦然 。严格的不等式不会转换数据类型。 例子 3！== 3 //假
3！=='3'//是的
4！== 3 //是的
!==）与全等运算符是相反的。这意味着严格不相等并返回false的地方，用严格相等运算符会返回true，反之亦然。严格不相等运算符不会转换值的数据类型。
+示例
+
+```js
+3 !== 3 // false
+3 !== '3' // true
+4 !== 3 // true
+```
+
+strict inequality operator添加到if语句，以便当val不严格等于17时，函数将返回“Not Equal” if语句中，添加严格不相等运算符!==，这样如果val与17严格不相等的时候，函数会返回 "Not Equal"。
+testStrictNotEqual(17)应返回“Equal”
+ - text: testStrictNotEqual(17)应该返回 "Equal"。
testString: assert(testStrictNotEqual(17) === "Equal");
- - text: testStrictNotEqual("17")应返回“Not Equal”
+ - text: testStrictNotEqual("17")应该返回 "Not Equal"。
testString: assert(testStrictNotEqual("17") === "Not Equal");
- - text: testStrictNotEqual(12)应该返回“Not Equal”
+ - text: testStrictNotEqual(12)应该返回 "Not Equal"。
testString: assert(testStrictNotEqual(12) === "Not Equal");
- - text: testStrictNotEqual("bob")应返回“Not Equal”
+ - text: testStrictNotEqual("bob")应该返回 "Not Equal"。
testString: assert(testStrictNotEqual("bob") === "Not Equal");
- - text: 你应该使用!==运算符
+ - text: 应该使用 !== 运算符。
testString: assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);
```
@@ -40,12 +53,7 @@ tests:
```js
// Setup
function testStrictNotEqual(val) {
- // Only Change Code Below this Line
-
- if (val) {
-
- // Only Change Code Above this Line
-
+ if (val) { // Change this line
return "Not Equal";
}
return "Equal";
@@ -53,7 +61,6 @@ function testStrictNotEqual(val) {
// Change this value to test
testStrictNotEqual(10);
-
```
@@ -65,7 +72,14 @@ testStrictNotEqual(10);
## Solution
true时， 逻辑和运算符（ && ）才返回true。如果将if语句嵌套在另一个语句中，则可以实现相同的效果： if（num> 5）{如果
if（num <10）{
返回“是”;
}
}
返回“否”;
num大于5且小于10则仅返回“Yes”。相同的逻辑可以写成： if（num> 5 && num <10）{
返回“是”;
}
返回“否”;
true，逻辑与 运算符（&&）才会返回true。
+同样的效果可以通过 if 语句的嵌套来实现：
+
+```js
+if (num > 5) {
+ if (num < 10) {
+ return "Yes";
+ }
+}
+return "No";
+```
+
+只有当num的值在 6 和 9 之间（包括 6 和 9）才会返回 "Yes"。相同的逻辑可被写为：
+
+```js
+if (num > 5 && num < 10) {
+ return "Yes";
+}
+return "No";
+```
+
+val小于或等于50且大于或等于25 ，则返回"Yes" 。否则，将返回"No" 。 val小于或等于50并且大于或等于25，返回"Yes"。否则，将返回"No"。
+&&运算符
- testString: assert(code.match(/&&/g).length === 1);
- - text: 你应该只有一个if语句
+ - text: 你应该使用&&运算符一次。
+ testString: assert(code.match(/&&/g).length === 1,);
+ - text: 你应该只有一个if表达式。
testString: assert(code.match(/if/g).length === 1);
- - text: testLogicalAnd(0)应返回“否”
+ - text: testLogicalAnd(0)应该返回 "No"。
testString: assert(testLogicalAnd(0) === "No");
- - text: testLogicalAnd(24)应返回“否”
+ - text: testLogicalAnd(24)应该返回 "No"。
testString: assert(testLogicalAnd(24) === "No");
- - text: testLogicalAnd(25)应返回“是”
+ - text: testLogicalAnd(25)应该返回 "Yes"。
testString: assert(testLogicalAnd(25) === "Yes");
- - text: testLogicalAnd(30)应该返回“是”
+ - text: testLogicalAnd(30)应该返回 "Yes"。
testString: assert(testLogicalAnd(30) === "Yes");
- - text: testLogicalAnd(50)应该返回“是”
+ - text: testLogicalAnd(50)应该返回 "Yes"。
testString: assert(testLogicalAnd(50) === "Yes");
- - text: testLogicalAnd(51)应返回“否”
+ - text: testLogicalAnd(51)应该返回 "No"。
testString: assert(testLogicalAnd(51) === "No");
- - text: testLogicalAnd(75)应返回“否”
+ - text: testLogicalAnd(75)应该返回 "No"。
testString: assert(testLogicalAnd(75) === "No");
- - text: testLogicalAnd(80)应返回“否”
+ - text: testLogicalAnd(80)应该返回 "No"。
testString: assert(testLogicalAnd(80) === "No");
```
@@ -63,7 +88,6 @@ function testLogicalAnd(val) {
// Change this value to test
testLogicalAnd(10);
-
```
@@ -75,7 +99,14 @@ testLogicalAnd(10);
## Solution
|| ）返回true ，如果任一操作数为true 。否则，它返回false 。 逻辑或运算符由两个管道符号（ | ）组成。这通常可以在Backspace和Enter键之间找到。以下模式应该从以前的方法点看起来很熟悉： if（num> 10）{仅当
返回“否”;
}
if（num <5）{
返回“否”;
}
返回“是”;
num介于5和10之间（包括5和10）时，才会返回“Yes”。相同的逻辑可以写成： if（num> 10 || num <5）{
返回“否”;
}
返回“是”;
||两边任何一个为true，那么它就返回true；否则返回false。
+逻辑或运算符由两个管道符号（|）组成。这个按键位于退格键和回车键之间。
+下面这样的语句你应该很熟悉：
+
+```js
+if (num > 10) {
+ return "No";
+}
+if (num < 5) {
+ return "No";
+}
+return "Yes";
+```
+
+只有当num大于等于 5 或小于等于 10 时，函数返回"Yes"。相同的逻辑可以简写成：
+
+```js
+if (num > 10 || num < 5) {
+ return "No";
+}
+return "Yes";
+```
+
+if语句组合成一个语句，如果val不在10和20之间（包括10和20 ，则返回"Outside" 。否则，返回"Inside" 。 val不在 10 和 20 之间(包括 10 和 20)，返回"Outside"。反之，返回"Inside"。
+||操作员一次
+ - text: 你应该使用一次||操作符。
testString: assert(code.match(/\|\|/g).length === 1);
- - text: 你应该只有一个if语句
+ - text: 你应该只有一个if表达式。
testString: assert(code.match(/if/g).length === 1);
- - text: testLogicalOr(0)应返回“Outside”
+ - text: testLogicalOr(0)应该返回 "Outside"。
testString: assert(testLogicalOr(0) === "Outside");
- - text: testLogicalOr(9)应返回“Outside”
+ - text: testLogicalOr(9)应该返回 "Outside"。
testString: assert(testLogicalOr(9) === "Outside");
- - text: testLogicalOr(10)应返回“Inside”
+ - text: testLogicalOr(10)应该返回 "Inside"。
testString: assert(testLogicalOr(10) === "Inside");
- - text: testLogicalOr(15)应返回“Inside”
+ - text: testLogicalOr(15)应该返回 "Inside"。
testString: assert(testLogicalOr(15) === "Inside");
- - text: testLogicalOr(19)应该返回“Inside”
+ - text: testLogicalOr(19)应该返回 "Inside"。
testString: assert(testLogicalOr(19) === "Inside");
- - text: testLogicalOr(20)应该返回“Inside”
+ - text: testLogicalOr(20)应该返回 "Inside"。
testString: assert(testLogicalOr(20) === "Inside");
- - text: testLogicalOr(21)应该返回“Outside”
+ - text: testLogicalOr(21)应该返回 "Outside"。
testString: assert(testLogicalOr(21) === "Outside");
- - text: testLogicalOr(25)应返回“Outside”
+ - text: testLogicalOr(25)应该返回 "Outside"。
testString: assert(testLogicalOr(25) === "Outside");
```
@@ -65,7 +92,6 @@ function testLogicalOr(val) {
// Change this value to test
testLogicalOr(15);
-
```
@@ -77,7 +103,14 @@ testLogicalOr(15);
## Solution
myVar = myVar + 5;添加5到myVar 。由于这是一种常见的模式，因此存在一步完成数学运算和赋值的运算符。一个这样的运算符是+=运算符。 var myVar = 1;
myVar + = 5;
的console.log（myVar的）; //返回6
=右边的内容，所以我们可以写这样的语句：
+myVar = myVar + 5;
+以上是最常见的运算赋值语句，即先运算、再赋值。还有一类操作符是一步到位既做运算也赋值的。
+其中一种就是+=运算符。
+
+```js
+var myVar = 1;
+myVar += 5;
+console.log(myVar); // Returns 6
+```
+
+a ， b和c的赋值以使用+=运算符。 +=操作符实现同样的效果。
+a应该等于15
+ - text: a应该等于15。
testString: assert(a === 15);
- - text: b应该等于26
+ - text: b应该等于26。
testString: assert(b === 26);
- - text: c应该等于19
+ - text: c应该等于19。
testString: assert(c === 19);
- - text: 您应该为每个变量使用+=运算符
+ - text: 你应该对每个变量使用+=操作符。
testString: assert(code.match(/\+=/g).length === 3);
- - text: 不要修改行上方的代码
+ - text: 不要修改注释上面的代码。
testString: assert(/var a = 3;/.test(code) && /var b = 17;/.test(code) && /var c = 12;/.test(code));
```
@@ -57,7 +72,7 @@ c = c + 7;
/=运算符将变量除以另一个数字。 myVar = myVar / 5;将myVar除以5 。这可以改写为： myVar /= 5; /=操作符是让变量与另一个数相除并赋值。
+myVar = myVar / 5;
+变量myVar等于自身除以5的值。等价于:
+myVar /= 5;
+a ， b和c的赋值以使用/=运算符。 /=操作符实现同样的效果。
+a应该等于4
+ - text: a应该等于4。
testString: assert(a === 4);
- - text: b应该等于27
+ - text: b应该等于27。
testString: assert(b === 27);
- - text: c应该等于3
+ - text: c应该等于3。
testString: assert(c === 3);
- - text: 您应该为每个变量使用/=运算符
+ - text: 应该对每个变量使用/=操作符。
testString: assert(code.match(/\/=/g).length === 3);
- - text: 不要修改行上方的代码
+ - text: 不要修改注释上面的代码。
testString: assert(/var a = 48;/.test(code) && /var b = 108;/.test(code) && /var c = 33;/.test(code));
```
@@ -57,7 +65,7 @@ c = c / 11;
*=运算符将变量乘以数字。 myVar = myVar * 5;将myVar乘以5 。这可以改写为： myVar *= 5; *=操作符是让变量与一个数相乘并赋值。
+myVar = myVar * 5;
+变量myVar等于自身与数值5相乘的值。也可以写作这样的形式:
+myVar *= 5;
+a ， b和c的赋值以使用*=运算符。 *=操作符实现同样的效果。
+a应该等于25
+ - text: a应该等于25。
testString: assert(a === 25);
- - text: b应该等于36
+ - text: b应该等于36。
testString: assert(b === 36);
- - text: c应该等于46
+ - text: c应该等于46。
testString: assert(c === 46);
- - text: 您应该为每个变量使用*=运算符
+ - text: 应该对每个变量使用*=操作符。
testString: assert(code.match(/\*=/g).length === 3);
- - text: 不要修改行上方的代码
+ - text: 不要修改注释上面的代码。
testString: assert(/var a = 5;/.test(code) && /var b = 12;/.test(code) && /var c = 4\.6;/.test(code));
```
@@ -48,6 +56,7 @@ a = a * 5;
b = 3 * b;
c = c * 10;
+
```
@@ -57,7 +66,7 @@ c = c * 10;
+=运算符一样， -=从变量中减去一个数字。 myVar = myVar - 5;将从myVar减去5 。这可以改写为： myVar -= 5; +=操作符类似，-=操作符用来对一个变量进行减法赋值操作。
+myVar = myVar - 5;
+变量myVar等于自身减去5的值。也可以写成这种形式：
+myVar -= 5;
+a ， b和c的赋值以使用-=运算符。 -=操作符实现同样的效果。
+a应该等于5
+ - text: a应该等于5。
testString: assert(a === 5);
- - text: b应该等于-6
+ - text: b应该等于-6。
testString: assert(b === -6);
- - text: c应该等于2
+ - text: c应该等于2。
testString: assert(c === 2);
- - text: 您应该为每个变量使用-=运算符
+ - text: 应该对每个变量使用-=操作符。
testString: assert(code.match(/-=/g).length === 3);
- - text: 不要修改行上方的代码
+ - text: 不要修改注释上面的代码。
testString: assert(/var a = 11;/.test(code) && /var b = 9;/.test(code) && /var c = 3;/.test(code));
```
@@ -48,6 +56,7 @@ a = a - 6;
b = b - 15;
c = c - 1;
+
```
@@ -57,7 +66,7 @@ c = c - 1;
+运算符与String值一起使用时，它被称为连接运算符。您可以通过将它们连接在一起来构建其他字符串中的新字符串。 例 “我叫艾伦，'+'我连接起来。”注意
String类型的值使用+操作符的时候，它被称作 拼接操作符。你可以通过拼接其他字符串来创建一个新的字符串。
+示例
+
+```js
+'My name is Alan,' + ' I concatenate.'
+```
+
+提示myStr "This is the start. "和"This is the end."使用+运算符。 +操作符，把字符串"This is the start. "和"This is the end."连接起来并赋值给变量myStr。
+myStr应该有一个值This is the start. This is the end.
+ - text: myStr的值应该是This is the start. This is the end.。
testString: assert(myStr === "This is the start. This is the end.");
- - text: 使用+运算符构建myStr
+ - text: 使用+操作符构建myStr。
testString: assert(code.match(/(["']).*(["'])\s*\+\s*(["']).*(["'])/g).length > 1);
- - text: 应使用var关键字创建myStr 。
+ - text: myStr应该被var关键字声明。
testString: assert(/var\s+myStr/.test(code));
- - text: 确保将结果分配给myStr变量。
+ - text: 确保有给myStr赋值。
testString: assert(/myStr\s*=/.test(code));
```
@@ -43,6 +55,7 @@ var ourStr = "I come first. " + "I come second.";
var myStr;
+
```
@@ -52,7 +65,13 @@ var myStr;
+=运算符将字符串连接到现有字符串变量的末尾。这对于在多行上打破长字符串非常有帮助。 注意 +=运算符来concatenate（拼接）字符串到现有字符串的结尾。对于那些被分割成几段的长的字符串来说，这一操作是非常有用的。
+提示myStr几行： "This is the first sentence. "和"This is the second sentence."使用+=运算符。使用+=运算符，类似于它在编辑器中的显示方式。首先将第一个字符串分配给myStr ，然后添加第二个字符串。 +=操作符来连接这两个字符串："This is the first sentence. "和"This is the second sentence."并赋给变量myStr。
+myStr应该有一个值This is the first sentence. This is the second sentence.
+ - text: myStr的值应该是This is the first sentence. This is the second sentence.。
testString: assert(myStr === "This is the first sentence. This is the second sentence.");
- - text: 使用+=运算符构建myStr
+ - text: 使用+=操作符创建myStr变量。
testString: assert(code.match(/\w\s*\+=\s*["']/g).length > 1 && code.match(/\w\s*\=\s*["']/g).length > 1);
```
@@ -40,6 +46,7 @@ ourStr += "I come second.";
var myStr;
+
```
@@ -49,7 +56,13 @@ var myStr;
+ ），您可以将一个或多个变量插入到正在构建的字符串中。 + ，你可以插入一个或多个变量来组成一个字符串。
+myName设置为等于您的名字的字符串，并在字符串"My name is "和" and I am well!"之间用myName构建myStr " and I am well!" myName，然后把变量myName插入到字符串"My name is "和" and I am well!"之间，并把连接后的结果赋值给变量myStr。
+myName应设置为至少3个字符长的字符串
+ - text: myName至少要包含三个字符。
testString: assert(typeof myName !== 'undefined' && myName.length > 2);
- - text: 使用两个+运算符在其中构建myStr with myName
+ - text: 使用两个+操作符创建包含myName的myStr变量。
testString: assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
```
@@ -40,6 +45,7 @@ var ourStr = "Hello, our name is " + ourName + ", how are you?";
var myName;
var myStr;
+
```
@@ -49,7 +55,20 @@ var myStr;
initialization ， condition和final-expression 。我们将从i = 10开始并在i > 0循环。我们将递减i 2每个回路与i -= 2 。 var ourArray = [];
for（var i = 10; i> 0; i- = 2）{
ourArray.push（ⅰ）;
}
ourArray现在包含[10,8,6,4,2] 。让我们改变initialization和final-expression这样我们就可以向后计数两位奇数。 初始化，条件判断和计数器。
+我们让i = 10，并且当i > 0的时候才继续循环。我们使用i -= 2来让i每次循环递减 2。
+
+```js
+var ourArray = [];
+for (var i=10; i > 0; i-=2) {
+ ourArray.push(i);
+}
+```
+
+循环结束后，ourArray的值为[10,8,6,4,2]。
+让我们改变初始化和计数器，这样我们就可以按照奇数从后往前两两倒着数。
+for循环将奇数从9到1推送到myArray 。 for循环，把 9 到 1 的奇数添加进myArray。
+for循环。
+ - text: 你应该使用for循环。
testString: assert(code.match(/for\s*\(/g).length > 1);
- - text: 你应该使用数组方法push 。
+ - text: 你应该使用数组方法push。
testString: assert(code.match(/myArray.push/));
- - text: 'myArray应该等于[9,7,5,3,1] 。'
+ - text: myArray应该等于[9,7,5,3,1]。
testString: assert.deepEqual(myArray, [9,7,5,3,1]);
```
@@ -46,6 +63,7 @@ var myArray = [];
// Only change code below this line.
+
```
@@ -55,7 +73,7 @@ var myArray = [];
| 计数变化 | 牌 |
|---|---|
| +1 | 2,3,4,5,6 |
| 0 | 7,8,9 |
| -1 | 10，'J'，'Q'，'K'，'A' |
card参数，可以是数字或字符串，并根据卡的值递增或递减全局count变量（参见表格）。然后，该函数将返回一个包含当前计数的字符串，如果计数为正则返回字符串Bet ，如果计数为零或为负，则返回Hold 。当前计数和玩家的决定（ Bet或Hold ）应该由一个空格分隔。 示例输出 -3 Hold 5 Bet 提示 count重置为0。 | Count Change | Cards |
|---|---|
| +1 | 2, 3, 4, 5, 6 |
| 0 | 7, 8, 9 |
| -1 | 10, 'J', 'Q', 'K', 'A' |
card的值来递增或递减变量count，函数返回一个由当前count和Bet（count>0）或Hold（count<=0）拼接的字符串。注意count和"Bet"或Hold应该用空格分开。
+
+例如：-3 Hold
5 Bet
+
+提示5 Bet应该返回5 Bet
+ - text: Cards Sequence 2, 3, 4, 5, 6 应该返回5 Bet。
testString: assert((function(){ count = 0; cc(2);cc(3);cc(4);cc(5);var out = cc(6); if(out === "5 Bet") {return true;} return false; })());
- - text: '卡片序列7,8,9应返回0 Hold'
+ - text: Cards Sequence 7, 8, 9 应该返回 0 Hold。
testString: assert((function(){ count = 0; cc(7);cc(8);var out = cc(9); if(out === "0 Hold") {return true;} return false; })());
- - text: 卡序列10，J，Q，K，A应返回-5 Hold
+ - text: Cards Sequence 10, J, Q, K, A 应该返回 -5 Hold。
testString: assert((function(){ count = 0; cc(10);cc('J');cc('Q');cc('K');var out = cc('A'); if(out === "-5 Hold") {return true;} return false; })());
- - text: '卡序列3,7，Q，8，A应返回-1 Hold'
+ - text: Cards Sequence 3, 7, Q, 8, A 应该返回 -1 Hold。
testString: assert((function(){ count = 0; cc(3);cc(7);cc('Q');cc(8);var out = cc('A'); if(out === "-1 Hold") {return true;} return false; })());
- - text: 牌序列2，J， 1 Bet应该返回1 Bet
+ - text: Cards Sequence 2, J, 9, 2, 7 应该返回 1 Bet。
testString: assert((function(){ count = 0; cc(2);cc('J');cc(9);cc(2);var out = cc(7); if(out === "1 Bet") {return true;} return false; })());
- - text: 牌序列1 Bet应该返回1 Bet
+ - text: Cards Sequence 2, 2, 10 应该返回 1 Bet。
testString: assert((function(){ count = 0; cc(2);cc(2);var out = cc(10); if(out === "1 Bet") {return true;} return false; })());
- - text: '卡序列3,2，A，10，K应返回-1 Hold'
+ - text: Cards Sequence 3, 2, A, 10, K 应该返回 -1 Hold。
testString: assert((function(){ count = 0; cc(3);cc(2);cc('A');cc(10);var out = cc('K'); if(out === "-1 Hold") {return true;} return false; })());
```
@@ -56,7 +67,6 @@ function cc(card) {
// Add/remove calls to test your function.
// Note: Only the last will display
cc(2); cc(3); cc(7); cc('K'); cc('A');
-
```
@@ -68,7 +78,31 @@ cc(2); cc(3); cc(7); cc('K'); cc('A');
## Solution
myDecimal并给它一个带小数部分的十进制值（例如5.7 ）。 myDecimal并给它赋值一个浮点数。(例如5.21)。
+myDecimal应该是一个数字。
testString: assert(typeof myDecimal === "number");
- - text: myDecimal应该有一个小数点
- testString: assert(myDecimal % 1 != 0);
+ - text: myDecimal应该包含小数点。
+ testString: assert(myDecimal % 1 != 0);
```
@@ -36,6 +42,7 @@ var ourDecimal = 5.7;
// Only change code below this line
+
```
@@ -45,7 +52,7 @@ var ourDecimal = 5.7;
undefined ， null ， boolean ， string ， symbol ， number和object 。例如，计算机区分数字（例如数字12 ）和strings （例如"12" ， "dog"或"123 cats" ，它们是字符集合。计算机可以对数字执行数学运算，但不能对字符串执行数学运算。 变量允许计算机以动态方式存储和操作数据。他们通过使用“标签”指向数据而不是使用数据本身来做到这一点。七种数据类型中的任何一种都可以存储在变量中。 Variables类似于您在数学中使用的x和y变量，这意味着它们是表示我们想要引用的数据的简单名称。计算机variables与数学variables不同之处在于它们可以在不同时间存储不同的值。我们告诉JavaScript通过将关键字var放在它前面来创建或声明变量，如下所示： var ourName;创建一个名为
ourName的variable 。在JavaScript中，我们以分号结束语句。 Variable名可以由数字，字母和$或_ ，但不能包含空格或以数字开头。 undefined（未定义）， null（空），boolean（布尔型），string（字符串），symbol(符号)，number（数字），和object（对象）。
+例如，计算机区分数字和字符集合的字符串，例如数字12和字符串"12"，"dog"或"123 cats"。计算机可以对数字执行数学运算，但不能对字符串执行数学运算。
+变量允许计算机以一种动态的形式来存储和操作数据，通过操作指向数据的指针而不是数据本身来避免了内存泄露，以上的七种数据类型都可以存储到一个变量中。
+变量非常类似于你在数学中使用的 x，y 变量，都是以一个简单命名的名称来代替我们赋值给它的数据。计算机中的变量与数学中的变量不同的是，计算机可以在不同的时间存储不同类型的变量。
+通过在变量的前面使用关键字var，声明一个变量，例如：
+
+```js
+var ourName;
+```
+
+上面代码的意思是创建一个名为ourName的变量，在 JavaScript 中我们以分号结束语句。
+变量名称可以由数字、字母、美元符号$ 或者 下划线_组成，但是不能包含空格或者以数字为开头。
+var关键字创建名为myName的变量。 暗示 ourName查看我们的ourName示例。 var 关键字来创建一个名为myName的变量。
+提示ourName的例子是怎么写的。
+var关键字声明myName ，以分号结尾
- testString: assert(/var\s+myName\s*;/.test(code));
+ - text: 你需要使用var关键字定义一个变量myName，并使用分号结尾。
+ testString: assert(/var\s+myName\s*;/.test(code), '你需要使用var关键字定义一个变量myName。并使用分号结尾。');
```
@@ -44,7 +61,7 @@ var ourName;
var myName = "your name"; "your name"被称为字符串 文字 。它是一个字符串，因为它是用单引号或双引号括起来的一系列零个或多个字符。 var myName = "your name";
+"your name"被称作字符串变量。字符串是用单引号或双引号包裹起来的一连串的零个或多个字符。
+string变量： myFirstName和myLastName并分别为它们分配myFirstName和myLastName的值。 字符串变量：myFirstName和myLastName，并用你的姓和名分别为它们赋值。
+myFirstName应该是一个至少包含一个字符的字符串。
+ - text: myFirstName应该是一个字符串,并且至少包含一个字符。
testString: assert((function(){if(typeof myFirstName !== "undefined" && typeof myFirstName === "string" && myFirstName.length > 0){return true;}else{return false;}})());
- - text: myLastName应该是一个至少包含一个字符的字符串。
+ - text: myLastName应该是一个字符串,并且至少包含一个字符。
testString: assert((function(){if(typeof myLastName !== "undefined" && typeof myLastName === "string" && myLastName.length > 0){return true;}else{return false;}})());
```
@@ -38,6 +45,7 @@ var lastName = "Turing";
// Only change code below this line
+
```
@@ -47,7 +55,7 @@ var lastName = "Turing";
--运算符轻松地将变量减1或减1。 i--;相当于i = i - 1; 注意 i--; ，消除了对等号的需要。 --，你可以很方便地对一个变量执行自减或者-1运算。
+i--;
+等效于
+i = i - 1;
+提示i--;这种写法，省去了书写=符号的必要。
+myVar上使用--运算符。 --符号对myVar执行自减操作。
+myVar应该等于10
+ - text: myVar应该等于10。
testString: assert(myVar === 10);
- - text: myVar = myVar - 1;应该改变
+ - text: myVar = myVar - 1;语句应该被修改。
testString: assert(/var\s*myVar\s*=\s*11;\s*\/*.*\s*([-]{2}\s*myVar|myVar\s*[-]{2});/.test(code));
- - text: 在myVar上使用--运算符
+ - text: 对myVar使用--运算符。
testString: assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
- - text: 不要更改行上方的代码
+ - text: 不要修改注释上面的代码。
testString: assert(/var myVar = 11;/.test(code));
```
@@ -50,7 +59,7 @@ myVar = myVar - 1;
delete ourDog.bark; delete ourDog.bark;
+myDog删除"tails"属性。您可以使用点或括号表示法。 myDog对象的"tails"属性。
+myDog删除属性"tails" 。
+ - text: 从myDog中删除"tails"属性。
testString: assert(typeof myDog === "object" && myDog.tails === undefined);
- - text: 不要修改myDog设置
+ - text: 不要修改myDog的初始化。
testString: 'assert(code.match(/"tails": 1/g).length > 1);'
```
@@ -54,6 +60,7 @@ var myDog = {
// Only change code below this line.
+
```
@@ -63,7 +70,7 @@ var myDog = {
0.0使quotient等于2.2 。 0.0的值让变量quotient的值等于2.2.
+quotient应该等于2.2
+ - text: quotient的值应该等于2.2。
testString: assert(quotient === 2.2);
- - text: 您应该使用/运算符将4.4除以2
+ - text: 使用/运算符将 4.4 除以 2。
testString: assert(/4\.40*\s*\/\s*2\.*0*/.test(code));
- - text: 商数变量只应分配一次
+ - text: quotient 变量应该只被赋值一次。
testString: assert(code.match(/quotient/g).length === 1);
```
@@ -35,7 +40,6 @@ tests:
```js
var quotient = 0.0 / 2.0; // Fix this line
-
```
@@ -45,7 +49,7 @@ var quotient = 0.0 / 2.0; // Fix this line
/符号进行除法。 例
myVar = 16/2; //分配8
/符号做除法运算。
+
+示例
+
+```js
+myVar = 16 / 2; // assigned 8
+```
+
+
+0 ，使quotient等于2 。 0来让变量quotient的值等于2。
+quotient等于2。
+ - text: 要使quotient的值等于 2。
testString: assert(quotient === 2);
- - text: 使用/运算符
+ - text: 使用/运算符。
testString: assert(/\d+\s*\/\s*\d+/.test(code));
```
@@ -34,6 +48,7 @@ tests:
```js
var quotient = 66 / 0;
+
```
@@ -43,7 +58,7 @@ var quotient = 66 / 0;
| 码 | 产量 |
|---|---|
\' | 单引号 |
\" | 双引号 |
\\ | 反斜线 |
\n | 新队 |
\r | 回车 |
\t | 标签 |
\b | 退格 |
\f | 形式饲料 |
| 代码 | 输出 |
|---|---|
\' | 单引号 |
\" | 双引号 |
\\ | 反斜杠 |
\n | 换行符 |
\r | 回车符 |
\t | 制表符 |
\b | 退格 |
\f | 换页符 |
myStr 。 第一行您将需要使用转义序列正确插入特殊字符。您还需要按照上面的间距来跟踪，在转义序列或单词之间没有空格。这是写出转义序列的文本。
\第二行
ThirdLine
FirstLinenewlinetabbackslashSecondLinenewlineThirdLine
myStr。
+FirstLine+你需要使用转义字符正确地插入特殊字符，确保间距与上面文本一致并且单词或转义字符之间没有空格。 +像这样用转义字符写出来： +
\SecondLine
ThirdLine
FirstLine+换行符制表符反斜杠SecondLine换行符ThirdLine
myStr不应包含任何空格
- testString: 'assert(!/ /.test(myStr), "myStr should not contain any spaces");'
- - text: myStr应包含的字符串FirstLine ， SecondLine和ThirdLine （记住区分大小写）
- testString: 'assert(/FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr), "myStr should contain the strings FirstLine, SecondLine and ThirdLine (remember case sensitivity)");'
- - text: FirstLine后面应跟换行符\n
- testString: 'assert(/FirstLine\n/.test(myStr), "FirstLine should be followed by the newline character \n");'
- - text: myStr应该包含一个制表字符\t ，它跟在换行符后面
- testString: 'assert(/\n\t/.test(myStr), "myStr should contain a tab character \t which follows a newline character");'
- - text: SecondLine应该以反斜杠字符\\开头
- testString: 'assert(/\SecondLine/.test(myStr), "SecondLine should be preceded by the backslash character \\");'
- - text: SecondLine和ThirdLine之间应该有换行符
- testString: 'assert(/SecondLine\nThirdLine/.test(myStr), "There should be a newline character between SecondLine and ThirdLine");'
+ - text: myStr不能包含空格。
+ testString: assert(!/ /.test(myStr));
+ - text: myStr应该包含字符串FirstLine, SecondLine and ThirdLine （记得区分大小写）。
+ testString: assert(/FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr));
+ - text: FirstLine后面应该是一个新行\n。
+ testString: assert(/FirstLine\n/.test(myStr));
+ - text: myStr应该包含制表符\t并且制表符要在换行符后面。
+ testString: assert(/\n\t/.test(myStr));
+ - text: SecondLine前面应该是反斜杠\\。
+ testString: assert(/\SecondLine/.test(myStr));
+ - text: SecondLine和ThirdLine之间应该是换行符。
+ testString: assert(/SecondLine\nThirdLine/.test(myStr));
+ - text: myStr 应该只包含介绍里面展示的字符串。
+ testString: assert(myStr === 'FirstLine\n\t\\SecondLine\nThirdLine');
```
@@ -42,6 +55,7 @@ tests:
```js
var myStr; // Change this line
+
```
@@ -51,7 +65,9 @@ var myStr; // Change this line
"还是' ？你的字符串里面在JavaScript中，你可以放置一个反斜杠 （从考虑到它作为字符串报价的最终逃脱报价\在引号前）。 var sampleStr = "Alan said, \"Peter is learning JavaScript\".";这告诉JavaScript，以下引用不是字符串的结尾，而是应该出现在字符串中。所以如果要将它打印到控制台，你会得到： Alan said, "Peter is learning JavaScript". "或者'时该怎么办呢?
+在 JavaScript 中，你可以通过在引号前面使用反斜杠（\）来转义引号。
+var sampleStr = "Alan said, \"Peter is learning JavaScript\".";
+有了转义符号，JavaScript 就知道这个单引号或双引号并不是字符串的结尾，而是字符串内的字符。所以，上面的字符串打印到控制台的结果为：
+Alan said, "Peter is learning JavaScript".
+myStr变量，这样如果要将其打印到控制台，您会看到： I am a "double quoted" string inside "double quotes". myStr，打印到控制台，输出为：
+I am a "double quoted" string inside "double quotes".
+" ）和四个转义双引号（ \" ）。
+ - text: 你的代码中应该包含两个双引号 (") 以及四个转义的双引 (\")。
testString: assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
- - text: 变量myStr应该包含字符串： I am a "double quoted" string inside "double quotes".
- testString: 'assert(myStr === "I am a \"double quoted\" string inside \"double quotes\".");'
+ - text: 变量 myStr 应该包含字符串I am a "double quoted" string inside "double quotes".。
+ testString: assert(myStr === "I am a \"double quoted\" string inside \"double quotes\".");
```
@@ -34,6 +44,7 @@ tests:
```js
var myStr = ""; // Change this line
+
```
@@ -43,7 +54,13 @@ var myStr = ""; // Change this line
.length来查找String值的长度。 "Alan Peter".length; // 10例如，如果我们创建了一个变量var firstName = "Charles" ，我们可以通过使用firstName.length属性找出字符串"Charles"长度。 .length来获得字符串变量值的长度。
+"Alan Peter".length; // 10
+例如，我们创建了一个变量var firstName = "Charles"，我们就可以通过使用firstName.length来获得"Charles"字符串的长度。
+.length属性计算lastName变量中的字符数，并将其分配给lastNameLength 。 .length属性来获得变量lastName的长度，并把它赋值给变量lastNameLength。
+lastNameLength应该等于8。
- testString: 'assert((function(){if(typeof lastNameLength !== "undefined" && typeof lastNameLength === "number" && lastNameLength === 8){return true;}else{return false;}})(), "lastNameLength should be equal to eight.");'
- - text: 您应该使用.length来获取lastName的长度，如下所示： lastName.length 。
- testString: 'assert((function(){if(code.match(/\.length/gi) && code.match(/\.length/gi).length >= 2 && code.match(/var lastNameLength \= 0;/gi) && code.match(/var lastNameLength \= 0;/gi).length >= 1){return true;}else{return false;}})(), "You should be getting the length of lastName by using .length like this: lastName.length.");'
+ - text: 不能改变 // Setup 部分声明的变量。
+ testString: assert(code.match(/var lastNameLength = 0;/) && code.match(/var lastName = "Lovelace";/));
+ - text: lastNameLength应该等于 8。
+ testString: assert(typeof lastNameLength !== 'undefined' && lastNameLength === 8);
+ - text: 你应该使用 .length 获取 lastName 的长度，像这样 lastName.length。
+ testString: assert(code.match(/=\s*lastName\.length/g) && !code.match(/lastName\s*=\s*8/));
```
@@ -46,16 +55,7 @@ var lastName = "Lovelace";
lastNameLength = lastName;
-```
-
-
-
-### After Test
-%给出了两个数的除法的余数。 例 5％2 = 1因为用法
Math.floor（5/2）= 2（商数）
2 * 2 = 4
5 - 4 = 1（剩余）
2的余数，可以检查数字是偶数还是奇数。 17％2 = 1（17为奇数）注意
48％2 = 0（48为偶数）
%返回两个数相除得到的余数
+示例
+5 % 2 = 1 因为+用法
Math.floor(5 / 2) = 2 （商）
2 * 2 = 4
5 - 4 = 1 （余数）
17 % 2 = 1（17 是奇数）+提示
48 % 2 = 0（48 是偶数）
% ）运算符将remainder设置为等于11的余数除以3 。 %运算符，计算 11 除以 3 的余数，并把余数赋给变量 remainder。
+remainder
+ - text: 变量remainder应该被初始化。
testString: assert(/var\s+?remainder/.test(code));
- - text: remainder的值应为2
+ - text: remainder的值应该等于2。
testString: assert(remainder === 2);
- - text: 您应该使用%运算符
+ - text: 你应该使用%运算符。
testString: assert(/\s+?remainder\s*?=\s*?.*%.*;/.test(code));
```
@@ -47,7 +57,7 @@ var remainder;
Math.random()函数，它生成一个介于0 （含）和不高达1 （独占）之间的随机十进制数。因此Math.random()可以返回0但永远不会返回1 Note return执行之前解析，因此我们可以return Math.random()函数的值。 Math.random()用来生成一个在0（包括 0）到1（不包括 1）之间的随机小数，因此Math.random()可能返回 0 但绝不会返回 1。
+提示return执行之前解析，因此我们可以返回Math.random()函数的值。
+randomFraction以返回随机数而不是返回0 。 randomFraction使其返回一个随机数而不是0。
+randomFraction应该返回一个随机数。
testString: assert(typeof randomFraction() === "number");
- - text: randomFraction返回的randomFraction应该是小数。
+ - text: randomFraction应该返回一个小数。
testString: assert((randomFraction()+''). match(/\./g));
- - text: 您应该使用Math.random来生成随机十进制数。
+ - text: 需要使用Math.random生成随机的小数。
testString: assert(code.match(/Math\.random/g).length >= 0);
```
@@ -42,7 +49,6 @@ function randomFraction() {
// Only change code above this line.
}
-
```
@@ -52,7 +58,7 @@ function randomFraction() {
Math.random()生成随机小数。 20 。 Math.floor()将数字向下舍入到最接近的整数。 Math.random()永远不会返回1 ，因为我们正在向下舍入，实际上不可能得到20 。这项技术将给我们一个0到19之间的整数。将所有内容放在一起，这就是我们的代码： Math.floor(Math.random() * 20);我们调用Math.random() ，将结果乘以20，然后将值传递给Math.floor()函数，将值向下舍入到最接近的整数。 Math.random()生成一个随机小数。20。Math.floor()向下取整 获得它最近的整数。Math.random()永远不会返回1。同时因为我们是在用Math.floor()向下取整，所以最终我们获得的结果不可能有20。这确保了我们获得了一个在0到19之间的整数。
+把操作连缀起来，代码类似于下面：
+Math.floor(Math.random() * 20);
+我们先调用Math.random()，把它的结果乘以20，然后把上一步的结果传给Math.floor()，最终通过向下取整获得最近的整数。
+0到9之间的随机整数。 0到9之间的随机整数。
+randomWholeNum的结果应该是整数。
+ - text: myFunction的结果应该是一个整数。
testString: assert(typeof randomWholeNum() === "number" && (function(){var r = randomWholeNum();return Math.floor(r) === r;})());
- - text: 您应该使用Math.random来生成随机数。
+ - text: 需要使用Math.random生成随机数字。
testString: assert(code.match(/Math.random/g).length > 1);
- - text: 您应该将Math.random的结果乘以10，使其成为介于0和9之间的数字。
+ - text: 你应该将Math.random的结果乘以 10 来生成 0 到 9 之间的随机数。
testString: assert(code.match(/\s*?Math.random\s*?\(\s*?\)\s*?\*\s*?10[\D]\s*?/g) || code.match(/\s*?10\s*?\*\s*?Math.random\s*?\(\s*?\)\s*?/g));
- - text: 您应该使用Math.floor删除数字的小数部分。
+ - text: 你需要使用Math.floor移除数字中的小数部分。
testString: assert(code.match(/Math.floor/g).length > 1);
```
@@ -44,7 +54,6 @@ function randomWholeNum() {
return Math.random();
}
-
```
@@ -54,7 +63,7 @@ function randomWholeNum() {
min和最大数量max 。这是我们将使用的公式。花一点时间阅读它并尝试理解这段代码在做什么： Math.floor(Math.random() * (max - min + 1)) + min Math.floor(Math.random() * (max - min + 1)) + min
+randomRange的函数，它接受一个范围myMin和myMax并返回一个大于或等于myMin的随机数，并且小于或等于myMax （包括myMax ）。 randomRange的函数，参数为 myMin 和 myMax，返回一个在myMin（包括 myMin）和myMax（包括 myMax）之间的随机数。
+randomRange可以生成的最低随机数应该等于你的最小数量myMin 。
+ - text: randomRange返回的随机数应该大于或等于myMin。
testString: assert(calcMin === 5);
- - text: randomRange可以生成的最高随机数应该等于最大数量myMax 。
+ - text: randomRange返回的随机数应该小于或等于myMax。
testString: assert(calcMax === 15);
- - text: randomRange生成的随机数应该是整数，而不是小数。
+ - text: randomRange应该返回一个随机整数, 而不是小数。
testString: assert(randomRange(0,1) % 1 === 0 );
- - text: randomRange应该同时使用myMax和myMin ，并在你的范围内返回一个随机数。
+ - text: randomRange应该使用myMax和myMin, 并且返回两者之间的随机数。
testString: assert((function(){if(code.match(/myMax/g).length > 1 && code.match(/myMin/g).length > 2 && code.match(/Math.floor/g) && code.match(/Math.random/g)){return true;}else{return false;}})());
```
@@ -54,7 +62,6 @@ function randomRange(myMin, myMax) {
// Change these values to test your function
var myRandom = randomRange(5, 15);
-
```
@@ -64,7 +71,20 @@ var myRandom = randomRange(5, 15);
var关键字的情况下使用的变量将在global范围内自动创建。这可能会在代码中的其他位置或再次运行函数时产生意外后果。您应该始终使用var声明变量。 var关键字定义的变量，会被自动创建在全局作用域中，形成全局变量。当在代码其他地方无意间定义了一个变量，刚好变量名与全局变量相同，这时会产生意想不到的后果。因此你应该总是使用var关键字来声明你的变量。
+var ，在任何函数之外声明一个global变量myGlobal 。使用值10初始化它。在函数fun1内部，在不使用var关键字的情况下为oopsGlobal分配5 。 全局变量myGlobal，并给它一个初始值10
+在函数fun1的内部，不使用var关键字来声明oopsGlobal，并赋值为5。
+myGlobal
+ - text: 应定义myGlobal。
testString: assert(typeof myGlobal != "undefined");
- - text: myGlobal的值应为10
+ - text: myGlobal的值应为10。
testString: assert(myGlobal === 10);
- - text: 应使用var关键字声明myGlobal
+ - text: 应使用var关键字定义myGlobal。
testString: assert(/var\s+myGlobal/.test(code));
- - text: oopsGlobal应该是一个全局变量，其值为5
+ - text: oopsGlobal应为全局变量且值为5。
testString: assert(typeof oopsGlobal != "undefined" && oopsGlobal === 5);
```
@@ -55,7 +62,6 @@ function fun2() {
}
console.log(output);
}
-
```
@@ -84,7 +90,6 @@ function uncapture() {
}
var oopsGlobal;
capture();
-
```
@@ -93,7 +98,10 @@ capture();
local变量优先于global变量。在这个例子中： var someVar =“帽子”;函数
function myFun（）{
var someVar =“Head”;
返回someVar;
}
myFun将返回"Head"因为存在变量的local版本。 局部变量将会优先于全局变量。
+下面为例：
+
+```js
+var someVar = "Hat";
+function myFun() {
+ var someVar = "Head";
+ return someVar;
+}
+```
+
+函数myFun将会返回"Head"，因为局部变量优先级更高。
+myOutfit函数，以使用"sweater"覆盖outerWear的值。 myOutfit添加一个局部变量来覆盖outerWear的值为"sweater"。
+outerWear的值
+ - text: 不要修改全局变量outerWear的值。
testString: assert(outerWear === "T-Shirt");
- - text: myOutfit应该返回"sweater"
+ - text: myOutfit应该返回"sweater"。
testString: assert(myOutfit() === "sweater");
- - text: 不要更改return语句
+ - text: 不要修改return语句。
testString: assert(/return outerWear/.test(code));
```
@@ -47,7 +63,6 @@ function myOutfit() {
}
myOutfit();
-
```
@@ -59,7 +74,13 @@ myOutfit();
## Solution
par意义，即高尔夫球手为了将球沉入洞中以完成比赛所期望的平均strokes次数。根据你的strokes高出或低于par的距离，有一个不同的昵称。您的函数将通过par和strokes参数。根据此表返回正确的字符串，该表按优先级顺序列出笔划;顶部（最高）到底部（最低）： | 笔画 | 返回 |
|---|---|
| 1 | “一杆进洞！” |
| <= par - 2 | “鹰” |
| par - 1 | “小鸟” |
| 平价 | “相提并论” |
| par + 1 | “柏忌” |
| par + 2 | “双柏忌” |
| > = par + 3 | “回家！” |
par和strokes将始终为数字和正数。为方便起见，我们添加了所有名称的数组。 par，代表着距离。根据你把球打进洞所挥杆的次数strokes，可以计算出你的高尔夫水平。
+函数将会传送 2 个参数，分别是标准杆数par和挥杆次数strokes，根据下面的表格返回正确的水平段位。
+| Strokes | Return |
|---|---|
| 1 | "Hole-in-one!" |
| <= par - 2 | "Eagle" |
| par - 1 | "Birdie" |
| par | "Par" |
| par + 1 | "Bogey" |
| par + 2 | "Double Bogey" |
| >= par + 3 | "Go Home!" |
par和strokes必须是数字而且是正数。
+golfScore(4, 1)应该返回“Hole-in-one！”'
+ - text: golfScore(4, 1)应该返回 "Hole-in-one!"。
testString: assert(golfScore(4, 1) === "Hole-in-one!");
- - text: 'golfScore(4, 2)应该返回“Eagle”'
+ - text: golfScore(4, 2)应该返回 "Eagle"。
testString: assert(golfScore(4, 2) === "Eagle");
- - text: 'golfScore(5, 2)应该返回“Eagle”'
+ - text: golfScore(5, 2)应该返回 "Eagle"。
testString: assert(golfScore(5, 2) === "Eagle");
- - text: 'golfScore(4, 3)应该返回“Birdie”'
+ - text: golfScore(4, 3)应该返回 "Birdie"。
testString: assert(golfScore(4, 3) === "Birdie");
- - text: 'golfScore(4, 4)应该返回“Par”'
+ - text: golfScore(4, 4)应该返回 "Par"。
testString: assert(golfScore(4, 4) === "Par");
- - text: 'golfScore(1, 1)应该返回“Hole-in-one！”'
+ - text: golfScore(1, 1)应该返回 "Hole-in-one!"。
testString: assert(golfScore(1, 1) === "Hole-in-one!");
- - text: 'golfScore(5, 5)应该返回“Par”'
+ - text: golfScore(5, 5)应该返回 "Par"。
testString: assert(golfScore(5, 5) === "Par");
- - text: 'golfScore(4, 5)应该返回“Bogey”'
+ - text: golfScore(4, 5)应该返回 "Bogey"。
testString: assert(golfScore(4, 5) === "Bogey");
- - text: 'golfScore(4, 6)应该返回“Double Bogey”'
+ - text: golfScore(4, 6)应该返回 "Double Bogey"。
testString: assert(golfScore(4, 6) === "Double Bogey");
- - text: 'golfScore(4, 7)应该返回“Go Home！”'
+ - text: golfScore(4, 7)应该返回 "Go Home!"。
testString: assert(golfScore(4, 7) === "Go Home!");
- - text: 'golfScore(5, 9)应该返回“Go Home！”'
+ - text: golfScore(5, 9)应该返回 "Go Home!"。
testString: assert(golfScore(5, 9) === "Go Home!");
```
@@ -62,7 +69,6 @@ function golfScore(par, strokes) {
// Change these values to test
golfScore(5, 4);
-
```
@@ -74,7 +80,35 @@ golfScore(5, 4);
## Solution
++运算符。 i++;相当于i = i + 1; 注意 i++; ，消除了对等号的需要。 ++，我们可以很容易地对变量进行自增或者+1运算。
+i++;
+等效于
+i = i + 1;
+注意i++;这种写法，省去了书写=符号的必要。
+myVar上使用++运算符。 暗示 ++来对变量myVar进行自增操作。
+提示++运算符Arithmetic operators - Increment (++).
+myVar应该等于88
+ - text: myVar应该等于88。
testString: assert(myVar === 88);
- - text: myVar = myVar + 1;应该改变
- testString: assert(/var\s*myVar\s*=\s*87;\s*\/*.*\s*([+]{2}\s*myVar|myVar\s*[+]{2});/.test(code));
- - text: 使用++运算符
+ - text: myVar = myVar + 1;语句应该被修改。
+ testString: assert(/var\s*myVar\s*=\s*87;\s*\/*.*\s*myVar\+\+;/.test(code));
+ - text: 使用++运算符。
testString: assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
- - text: 不要更改行上方的代码
+ - text: 不要修改注释上方的代码。
testString: assert(/var myVar = 87;/.test(code));
```
@@ -50,7 +60,7 @@ myVar = myVar + 1;
var myVar = 0;创建一个名为myVar的新变量，并为其指定初始值0 。 var myVar = 0;
+创建一个名为myVar的变量并指定一个初始值0。
+var定义变量a并将其初始化为值9 。 var定义一个变量a并且给它一个初始值9。
+a初始化为值9
+ - text: 你需要初始化a的值为9。
testString: assert(/var\s+a\s*=\s*9\s*/.test(code));
```
@@ -44,7 +51,7 @@ var ourVar = 19;
if语句与else if语句链接在一起。 if（num> 15）{
返回“大于15”;
} else if（num <5）{
返回“小于5”;
} else {
返回“5到15之间”;
}
else if语句把if语句链起来。
+
+```js
+if (num > 15) {
+ return "Bigger than 15";
+} else if (num < 5) {
+ return "Smaller than 5";
+} else {
+ return "Between 5 and 15";
+}
+```
+
+else if语句。 if else实现同样的效果。
+else语句
+ - text: 你应该至少有两个else表达式。
testString: assert(code.match(/else/g).length > 1);
- - text: 你应该至少有两个if语句
+ - text: 你应该至少有两个if表达式。
testString: assert(code.match(/if/g).length > 1);
- - text: 您应该为每个条件关闭并打开花括号
- testString: assert(code.match(/if\s*\((.+)\)\s*\{[\s\S]+\}\s*else if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s*\{[\s\S]+\s*\}/));
- - text: testElseIf(0)应返回“小于5”
+ - text: testElseIf(0)应该返回 "Smaller than 5"。
testString: assert(testElseIf(0) === "Smaller than 5");
- - text: testElseIf(5)应该返回“5到10之间”
+ - text: testElseIf(5)应该返回 "Between 5 and 10"。
testString: assert(testElseIf(5) === "Between 5 and 10");
- - text: testElseIf(7)应返回“5到10之间”
+ - text: testElseIf(7)应该返回 "Between 5 and 10"。
testString: assert(testElseIf(7) === "Between 5 and 10");
- - text: testElseIf(10)应返回“5到10之间”
+ - text: testElseIf(10)应该返回 "Between 5 and 10"。
testString: assert(testElseIf(10) === "Between 5 and 10");
- - text: testElseIf(12)应返回“大于10”
+ - text: testElseIf(12)应该返回 "Greater than 10"。
+ testString: assert(testElseIf(12) === "Greater than 10");
+ - text: testElseIf(12) 应该返回 "Greater than 10"。
testString: assert(testElseIf(12) === "Greater than 10");
```
@@ -70,7 +86,17 @@ testElseIf(7);
## Solution
if语句的条件为真时，将执行其后面的代码块。当那个条件是假的时候怎么办？通常什么都不会发生。使用else语句，可以执行备用代码块。 if（num> 10）{
返回“大于10”;
} else {
返回“10或更少”;
}
if语句的条件为真，大括号里的代码执行，那如果条件为假呢？正常情况下什么也不会发生。使用else语句，可以执行当条件为假时相应的代码。
+
+```js
+if (num > 10) {
+ return "Bigger than 10";
+} else {
+ return "10 or Less";
+}
+```
+
+if语句组合到单个if/else语句中。 if语句合并为一个if/else语句。
+if语句
+ - text: 你应该只有一个if表达式。
testString: assert(code.match(/if/g).length === 1);
- - text: 你应该使用else语句
+ - text: 你应该使用一个else表达式。
testString: assert(/else/g.test(code));
- - text: testElse(4)应返回“5或更小”
+ - text: testElse(4)应该返回 "5 or Smaller"。
testString: assert(testElse(4) === "5 or Smaller");
- - text: testElse(5)应返回“5或更小”
+ - text: testElse(5)应该返回 "5 or Smaller"。
testString: assert(testElse(5) === "5 or Smaller");
- - text: testElse(6)应该返回“大于5”
+ - text: testElse(6)应该返回 "Bigger than 5"。
testString: assert(testElse(6) === "Bigger than 5");
- - text: testElse(10)应该返回“大于5”
+ - text: testElse(10)应该返回 "Bigger than 5"。
testString: assert(testElse(10) === "Bigger than 5");
- - text: 请勿更改行上方或下方的代码。
+ - text: 不要修改上面和下面的代码。
testString: assert(/var result = "";/.test(code) && /return result;/.test(code));
```
@@ -72,7 +86,17 @@ testElse(4);
## Solution
final-expression ，我们可以计算偶数。我们将从i = 0开始并在i < 10循环。我们会增加i的2每个回路与i += 2 。 var ourArray = [];
for（var i = 0; i <10; i + = 2）{
ourArray.push（ⅰ）;
}
ourArray现在包含[0,2,4,6,8] 。让我们改变initialization这样我们就可以用奇数来计算。 计数器，我们可以按照偶数顺序来迭代。
+初始化i = 0，当i < 10的时候继续循环。
+i += 2让i每次循环之后增加2。
+
+```js
+var ourArray = [];
+for (var i = 0; i < 10; i += 2) {
+ ourArray.push(i);
+}
+```
+
+循环结束后，ourArray的值为[0,2,4,6,8]。
+改变计数器，这样我们可以用奇数来数。
+for循环将奇数从1到9推送到myArray 。 for循环，把从 1 到 9 的奇数添加到myArray。
+for循环。
+ - text: 你应该使用for循环。
testString: assert(code.match(/for\s*\(/g).length > 1);
- - text: 'myArray应该等于[1,3,5,7,9] 。'
+ - text: myArray应该等于[1,3,5,7,9]。
testString: assert.deepEqual(myArray, [1,3,5,7,9]);
```
@@ -44,6 +61,7 @@ var myArray = [];
// Only change code below this line.
+
```
@@ -53,7 +71,7 @@ var myArray = [];
for循环。此代码将数组arr每个元素输出到控制台： var arr = [10,9,8,7,6];请记住，数组具有从零开始的编号，这意味着数组的最后一个索引是长度 - 1.我们对此循环的条件是
for（var i = 0; i <arr.length; i ++）{
（ARR [I]）的console.log;
}
i < arr.length ，当i长度为1时停止。 for循环可以做到这一点。下面的代码将输出数组 arr的每个元素到控制台：
+
+```js
+var arr = [10, 9, 8, 7, 6];
+for (var i = 0; i < arr.length; i++) {
+ console.log(arr[i]);
+}
+```
+
+记住数组的索引从零开始的，这意味着数组的最后一个元素的下标是：数组的长度 -1。我们这个循环的 条件是i < arr.length，当i的值为 长度 -1 的时候循环就停止了。在这个例子中，最后一个循环是 i === 4，也就是说，当i的值等于arr.length时，结果输出 6。
+total初始化为0 。使用for循环将myArr数组的每个元素的值添加到total 。 total为0。使用for循环，使得total的值为myArr的数组中的每个元素的值的总和。
+total并初始化为0
- testString: assert(code.match(/(var|let|const)\s*?total\s*=\s*0.*?;?/));
- - text: total应该等于20
+ - text: total应该被声明, 并且初始化值为 0。
+ testString: assert(code.match(/var.*?total\s*=\s*0.*?;/));
+ - text: total应该等于 20。
testString: assert(total === 20);
- - text: 您应该使用for循环来遍历myArr
+ - text: 你应该使用for循环在myArr中遍历。
testString: assert(code.match(/for\s*\(/g).length > 1 && code.match(/myArr\s*\[/));
- - text: 不要直接将total设置为20
- testString: assert(!code.replace(/\s/g, '').match(/total[=+-]0*[1-9]+/gm));
-
+ - text: 不能直接把total设置成 20。
+ testString: assert(!code.match(/total[\s\+\-]*=\s*(\d(?!\s*[;,])|[1-9])/g));
```
do...while ”循环，因为它首先将“ do ”循环内部代码的一次传递，无论如何，然后它运行“ while ”指定条件为真一旦这种情况不再真实就停止。我们来看一个例子。 var ourArray = [];这与任何其他类型的循环一样正常，结果数组看起来像
var i = 0;
做{
ourArray.push（ⅰ）;
我++;
} while（i <5）;
[0, 1, 2, 3, 4] 。然而，什么使得do...while与其他循环不同，但是当条件在第一次检查时失败时它的行为如何。让我们看看这个在行动。这是一个常规的while循环，只要i < 5 ，它就会在循环中运行代码。 var ourArray = [];请注意，我们将
var i = 5;
而（i <5）{
ourArray.push（ⅰ）;
我++;
}
i的值初始化为5.当我们执行下一行时，我们注意到i不小于5.所以我们不执行循环内的代码。结果是ourArray最终没有添加任何内容，因此当上面示例中的所有代码完成运行时，它仍然看起来像这个[] 。现在，看一下do...while循环。 var ourArray = [];在这种情况下，我们将
var i = 5;
做{
ourArray.push（ⅰ）;
我++;
} while（i <5）;
i的值初始化为5，就像我们使用while循环一样。当我们到达下一行时，没有检查i的值，所以我们转到花括号内的代码并执行它。我们将在数组中添加一个元素并在进行条件检查之前递增i 。然后，当我们检查i < 5看到i现在是6，这不符合条件检查。所以我们退出循环并完成。在上面的例子的末尾， ourArray的值是[5] 。本质上， do...while循环确保循环内的代码至少运行一次。让我们尝试通过将值推送到数组来实现do...while循环。 do...while循环，它会先执行do里面的代码，如果while表达式为真则重复执行，反之则停止执行。我们来看一个例子。
+
+```js
+var ourArray = [];
+var i = 0;
+do {
+ ourArray.push(i);
+ i++;
+} while (i < 5);
+```
+
+这看起来和其他循环语句差不多，返回的结果是[0, 1, 2, 3, 4]，do...while与其他循环不同点在于，初始条件为假时的表现，让我们通过实际的例子来看看。
+这是一个普通的 while 循环，只要i < 5，它就会在循环中运行代码。
+
+```js
+var ourArray = [];
+var i = 5;
+while (i < 5) {
+ ourArray.push(i);
+ i++;
+}
+```
+
+注意，我们首先将i的值初始化为 5。执行下一行时，注意到i不小于 5，循环内的代码将不会执行。所以ourArray最终没有添加任何内容，因此示例中的所有代码执行完时，ourArray仍然是[]。
+现在，看一下do...while循环。
+
+```js
+var ourArray = [];
+var i = 5;
+do {
+ ourArray.push(i);
+ i++;
+} while (i < 5);
+```
+
+在这里，和使用 while 循环时一样，我们将i的值初始化为 5。执行下一行时，没有检查i的值，直接执行花括号内的代码。数组会添加一个元素，并在进行条件检查之前递增i。然后，在条件检查时因为i等于 6 不符合条件i < 5，所以退出循环。最终ourArray的值是[5]。
+本质上，do...while循环确保循环内的代码至少运行一次。
+让我们通过do...while循环将值添加到数组中。
+while循环更改为do...while循环，以便循环将数字10推送到myArray ，当代码完成运行时， i将等于11 。 while循环更改为do...while循环，实现数字 10 添加到myArray中，代码执行完时，i等于11。
+do...while循环。
testString: assert(code.match(/do/g));
- - text: 'myArray应该等于[10] 。'
+ - text: myArray应该等于[10]。
testString: assert.deepEqual(myArray, [10]);
- - text: i应该等于11
- testString: assert.equal(i, 11);
-
+ - text: i应该等于11。
+ testString: assert.deepEqual(i, 11);
```
for loop ”，因为它“运行”特定次数。 For循环用三个可选表达式声明，用分号分隔： for ([initialization]; [condition]; [final-expression]) initialization语句仅在循环开始之前执行一次。它通常用于定义和设置循环变量。 condition语句在每次循环迭代开始时进行计算，并且只要计算结果为true就会继续。当迭代开始时condition为false时，循环将停止执行。这意味着如果condition以false开头，则循环将永远不会执行。 final-expression在每次循环迭代结束时执行，在下一次condition检查之前执行，通常用于递增或递减循环计数器。在下面的示例中，我们使用i = 0初始化并迭代，而条件i < 5为真。我们将在每个循环迭代中将i递增1 ，并使用i++作为final-expression 。 var ourArray = [];
for（var i = 0; i <5; i ++）{
ourArray.push（ⅰ）;
}
ourArray现在包含[0,1,2,3,4] 。 for循环”。
+for循环中的三个表达式用分号隔开：
+for ([初始化]; [条件判断]; [计数器])
+初始化语句只会在执行循环开始之前执行一次。它通常用于定义和设置你的循环变量。
+条件判断语句会在每一轮循环的开始执行，只要条件判断为true就会继续执行循环。当条件为false的时候，循环将停止执行。这意味着，如果条件在一开始就为false，这个循环将不会执行。
+计数器是在每一轮循环结束时执行，通常用于递增或递减。
+在下面的例子中，先初始化i = 0，条件i < 5为真，进入第一次循环，执行大括号里的代码，第一次循环结束。递增i的值，条件判断，就这样依次执行下去，直到条件判断为假，整个循环结束。
+
+```js
+var ourArray = [];
+for (var i = 0; i < 5; i++) {
+ ourArray.push(i);
+}
+```
+
+最终ourArray的值为[0,1,2,3,4].
+for循环将值1到5推送到myArray 。 for循环把从 1 到 5 添加进myArray中。
+for循环。
+ - text: 你应该使用for循环。
testString: assert(code.match(/for\s*\(/g).length > 1);
- - text: 'myArray应该等于[1,2,3,4,5] 。'
+ - text: myArray应该等于[1,2,3,4,5]。
testString: assert.deepEqual(myArray, [1,2,3,4,5]);
```
@@ -44,6 +65,7 @@ var myArray = [];
// Only change code below this line.
+
```
@@ -53,7 +75,7 @@ var myArray = [];
while ”循环，因为它在“while”运行时指定的条件为true，并且一旦该条件不再为真就停止。 var ourArray = [];让我们尝试通过将值推送到数组来实现while循环。
var i = 0;
而（i <5）{
ourArray.push（ⅰ）;
我++;
}
while" 循环，因为它规定，当 "while" 条件为真，循环才会执行，反之不执行。
+
+```js
+var ourArray = [];
+var i = 0;
+while(i < 5) {
+ ourArray.push(i);
+ i++;
+}
+```
+
+在上面的代码里，while 循环执行 5 次把 0 到 4 的数字添加到 ourArray 数组里。
+
+让我们通过 while 循环将值添加到数组中。
+while循环将数字0到4推送到myArray 。 while循环，把从 0 到 4 的值添加到myArray中。
+while循环。
testString: assert(code.match(/while/g));
- - text: 'myArray应该等于[0,1,2,3,4] 。'
- testString: assert.deepEqual(myArray, [5,4,3,2,1,0]);
+ - text: myArray应该等于[0,1,2,3,4]。
+ testString: assert.deepEqual(myArray, [0,1,2,3,4]);
```
@@ -37,6 +56,7 @@ var myArray = [];
// Only change code below this line.
+
```
@@ -46,7 +66,7 @@ var myArray = [];
myTest带有一个名为loc的局部变量。 function myTest（）{
var loc =“foo”;
的console.log（LOC）;
}
MYTEST（）; //记录“foo”
的console.log（LOC）; // loc未定义
loc未在函数外定义。 myTest内声明局部变量loc的例子：
+
+```js
+function myTest() {
+ var loc = "foo";
+ console.log(loc);
+}
+myTest(); // logs "foo"
+console.log(loc); // loc is not defined
+```
+
+在函数外，loc是未定义的。
+myLocalScope声明一个局部变量myVar 。运行测试，然后按照编辑器中注释的说明进行操作。 暗示 myFunction内部声明一个局部变量myVar，并删除外部的 console.log。
+提示：myVar变量
+ - text: 未找到全局的myVar变量。
testString: assert(typeof myVar === 'undefined');
- - text: 添加本地myVar变量
- testString: assert(/function\s+myLocalScope\s*\(\s*\)\s*\{\s[\s\S]+\s*var\s*myVar\s*(\s*|=[\s\S]+)\s*;[\s\S]+}/.test(code));
+ - text: 需要定义局部的myVar变量。
+ testString: assert(/var\s+myVar/.test(code));
+
```
@@ -80,7 +99,8 @@ function uncapture() {
if ， else if语句中很重要。该函数从上到下执行，因此您需要注意首先出现的语句。以这两个函数为例。这是第一个： function foo（x）{第二个只是切换语句的顺序：
if（x <1）{
返回“少于一个”;
} else if（x <2）{
返回“少于两个”;
} else {
返回“大于或等于2”;
}
}
功能栏（x）{虽然如果我们将数字传递给两者，这两个函数看起来几乎相同但我们得到不同的输出。
if（x <2）{
返回“少于两个”;
} else if（x <1）{
返回“少于一个”;
} else {
返回“大于或等于2”;
}
}
foo（0）//“不到一个”
bar（0）//“少于两个”
if、else if语句中代码的执行顺序是很重要的。
+在条件判断语句中，代码的执行顺序是从上到下，所以你需要考虑清楚先执行哪一句，后执行哪一句。
+这有两个例子。
+第一个例子：
+
+```js
+function foo(x) {
+ if (x < 1) {
+ return "Less than one";
+ } else if (x < 2) {
+ return "Less than two";
+ } else {
+ return "Greater than or equal to two";
+ }
+}
+```
+
+第二个例子更改了代码的执行顺序：
+
+```js
+function bar(x) {
+ if (x < 2) {
+ return "Less than two";
+ } else if (x < 1) {
+ return "Less than one";
+ } else {
+ return "Greater than or equal to two";
+ }
+}
+```
+
+这两个函数看起来几乎一模一样，我们传一个值进去看看它们有什么区别。
+
+```js
+foo(0) // "Less than one"
+bar(0) // "Less than two"
+```
+
+orderMyLogic(4)应返回“小于5”
+ - text: orderMyLogic(4)应该返回 "Less than 5"。
testString: assert(orderMyLogic(4) === "Less than 5");
- - text: orderMyLogic(6)应该返回“少于10”
+ - text: orderMyLogic(6)应该返回 "Less than 10"。
testString: assert(orderMyLogic(6) === "Less than 10");
- - text: orderMyLogic(11)应该返回“大于或等于10”
+ - text: orderMyLogic(11)应该返回 "Greater than or equal to 10"。
testString: assert(orderMyLogic(11) === "Greater than or equal to 10");
```
@@ -46,7 +88,6 @@ function orderMyLogic(val) {
// Change this value to test
orderMyLogic(7);
-
```
@@ -58,7 +99,17 @@ orderMyLogic(7);
## Solution
.pop()函数。 .pop()用于“弹出”数组末尾的值。我们可以通过将其赋值给变量来存储这个“弹出”值。换句话说， .pop()从数组中删除最后一个元素并返回该元素。任何类型的条目都可以从数组“弹出” - 数字，字符串，甚至嵌套数组。 var threeArr = [1, 4, 6];
var oneDown = threeArr.pop();
console.log(oneDown); // Returns 6
console.log(threeArr); // Returns [1, 4] .pop()函数。
+.pop()函数用来“抛出”一个数组末尾的值。我们可以把这个“抛出”的值赋给一个变量存储起来。换句话说就是.pop()函数移除数组末尾的元素并返回这个元素。
+数组中任何类型的元素（数值，字符串，甚至是数组）可以被“抛出来” 。
+
+```js
+var threeArr = [1, 4, 6];
+var oneDown = threeArr.pop();
+console.log(oneDown); // Returns 6
+console.log(threeArr); // Returns [1, 4]
+```
+
+.pop()函数从myArray删除最后一项，将“弹出”值分配给removedFromMyArray 。 .pop()函数移除myArray中的最后一个元素，并且把“抛出”的值赋给removedFromMyArray。
+myArray应该只包含[["John", 23]] 。'
+ - text: myArray应该只包含[["John", 23]]。
testString: assert((function(d){if(d[0][0] == 'John' && d[0][1] === 23 && d[1] == undefined){return true;}else{return false;}})(myArray));
- - text: 在myArray上使用pop()
+ - text: 对myArray使用pop()函数。
testString: assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code));
- - text: 'removedFromMyArray应该只包含["cat", 2] 。'
+ - text: removedFromMyArray应该只包含["cat", 2]。
testString: assert((function(d){if(d[0] == 'cat' && d[1] === 2 && d[2] == undefined){return true;}else{return false;}})(removedFromMyArray));
```
@@ -45,6 +60,7 @@ var myArray = [["John", 23], ["cat", 2]];
// Only change code below this line.
var removedFromMyArray;
+
```
@@ -54,7 +70,7 @@ var removedFromMyArray;
push()函数。 .push()接受一个或多个参数并将它们“推”到数组的末尾。 var arr = [1,2,3];
arr.push（4）;
// arr现在是[1,2,3,4]
push()函数。
+.push()接受一个或多个参数，并把它“推”入到数组的末尾。
+
+```js
+var arr = [1,2,3];
+arr.push(4);
+// arr is now [1,2,3,4]
+```
+
+["dog", 3]推到myArray变量的末尾。 ["dog", 3]“推”入到myArray变量的末尾。
+myArray现在应该等于[["John", 23], ["cat", 2], ["dog", 3]] 。'
+ - text: myArray应该等于[["John", 23], ["cat", 2], ["dog", 3]]。
testString: assert((function(d){if(d[2] != undefined && d[0][0] == 'John' && d[0][1] === 23 && d[2][0] == 'dog' && d[2][1] === 3 && d[2].length == 2){return true;}else{return false;}})(myArray));
```
@@ -40,6 +53,7 @@ var myArray = [["John", 23], ["cat", 2]];
// Only change code below this line.
+
```
@@ -49,7 +63,7 @@ var myArray = [["John", 23], ["cat", 2]];
pop()总是删除数组的最后一个元素。如果你想删除第一个怎么办？这就是.shift()用武之地。它就像.pop()一样工作，除了它删除了第一个元素而不是最后一个元素。 pop()函数用来移出数组中最后一个元素。如果想要移出第一个元素要怎么办呢？
+这就是.shift()的用武之地。它的工作原理就像.pop()，但它移除的是第一个元素，而不是最后一个。
+.shift()函数从myArray删除第一项，将“shift off”值分配给removedFromMyArray 。 .shift()函数移出myArray中的第一项，并把“移出”的值赋给removedFromMyArray。
+myArray现在应该等于[["dog", 3]] 。'
+ - text: myArray应该等于[["dog", 3]]。
testString: assert((function(d){if(d[0][0] == 'dog' && d[0][1] === 3 && d[1] == undefined){return true;}else{return false;}})(myArray));
- - text: 'removedFromMyArray应该包含["John", 23] 。'
+ - text: removedFromMyArray应该包含["John", 23]。
testString: assert((function(d){if(d[0] == 'John' && d[1] === 23 && typeof removedFromMyArray === 'object'){return true;}else{return false;}})(removedFromMyArray));
```
@@ -43,6 +49,7 @@ var myArray = [["John", 23], ["dog", 3]];
// Only change code below this line.
var removedFromMyArray;
+
```
@@ -52,7 +59,7 @@ var removedFromMyArray;
shift元件关闭的阵列的开头的，也可以unshift元素添加到数组的开始，即在阵列的前添加元素。 .unshift()工作方式与.push()完全相同，但是不是在数组的末尾添加元素， unshift()会在数组的开头添加元素。 shift（移出）数组中的第一个元素，你也可以unshift（移入）一个元素到数组的头部。
+.unshift()函数用起来就像.push()函数一样, 但不是在数组的末尾添加元素，而是在数组的头部添加元素。
+unshift()将["Paul",35]添加到myArray变量的开头。 unshift()函数把["Paul",35]加入到myArray的头部。
+myArray现在应该有[[“Paul”，35]，[“dog”，3]]。'
+ - text: myArray应该包含[["Paul", 35], ["dog", 3]]。
testString: assert((function(d){if(typeof d[0] === "object" && d[0][0] == 'Paul' && d[0][1] === 35 && d[1][0] != undefined && d[1][0] == 'dog' && d[1][1] != undefined && d[1][1] == 3){return true;}else{return false;}})(myArray));
```
@@ -42,6 +48,7 @@ myArray.shift();
// Only change code below this line.
+
```
@@ -51,7 +58,7 @@ myArray.shift();
var ourMusic = [这是一个包含一个对象的数组。该对象具有关于专辑的各种元数据 。它还有一个嵌套的
{
“艺术家”：“Daft Punk”，
“标题”：“家庭作业”，
“release_year”：1997年，
“格式”：[
“光盘”，
“盒式”
“LP”
]
“黄金”：是的
}
]。
"formats"数组。如果要添加更多专辑记录，可以通过向顶级数组添加记录来完成此操作。对象将数据保存在属性中，该属性具有键值格式。在上面的示例中， "artist": "Daft Punk"是具有"artist"键和"Daft Punk"值的属性。 JavaScript Object Notation或JSON是用于存储数据的相关数据交换格式。 {注意
“艺术家”：“Daft Punk”，
“标题”：“家庭作业”，
“release_year”：1997年，
“格式”：[
“光盘”，
“盒式”
“LP”
]
“黄金”：是的
}
formats的数组。附加专辑记录可以被添加到数组的最上层。
+对象将数据以一种键-值对的形式保存。在上面的示例中，"artist": "Daft Punk"是一个具有"artist"键和"Daft Punk"值的属性。
+JavaScript Object Notation 简称JSON是用于存储数据的相关数据交换格式。
+
+```json
+{
+ "artist": "Daft Punk",
+ "title": "Homework",
+ "release_year": 1997,
+ "formats": [
+ "CD",
+ "Cassette",
+ "LP"
+ ],
+ "gold": true
+}
+```
+
+提示myMusic阵列。添加artist和title字符串， release_year数字和formats字符串数组。 myMusic的JSON对象。添加artist和title字符串，release_year数字和formats字符串数组。
+myMusic应该是一个数组
+ - text: myMusic应该是一个数组。
testString: assert(Array.isArray(myMusic));
- - text: myMusic应该至少有两个元素
+ - text: myMusic应该至少包含两个元素。
testString: assert(myMusic.length > 1);
- - text: 'myMusic[1]应该是一个对象'
+ - text: myMusic[1]应该是一个对象。
testString: assert(typeof myMusic[1] === 'object');
- - text: 'myMusic[1]应该至少有4个属性'
+ - text: myMusic[1]至少要包含四个属性。
testString: assert(Object.keys(myMusic[1]).length > 3);
- - text: 'myMusic[1]应该包含一个artist属性，它是一个字符串'
+ - text: myMusic[1]应该包含一个类型为字符串的artist的属性。
testString: assert(myMusic[1].hasOwnProperty('artist') && typeof myMusic[1].artist === 'string');
- - text: 'myMusic[1]应该包含一个title属性，它是一个字符串'
+ - text: myMusic[1]应该包含一个类型为字符串的title的属性。
testString: assert(myMusic[1].hasOwnProperty('title') && typeof myMusic[1].title === 'string');
- - text: 'myMusic[1]应该包含一个release_year属性，它是一个数字'
+ - text: myMusic[1]应该包含一个类型为数字的release_year 应该包含一个类型为数字的属性。
testString: assert(myMusic[1].hasOwnProperty('release_year') && typeof myMusic[1].release_year === 'number');
- - text: 'myMusic[1]应该包含一个formats属性，它是一个数组'
+ - text: myMusic[1]应该包含一个类型为数组的formats属性。
testString: assert(myMusic[1].hasOwnProperty('formats') && Array.isArray(myMusic[1].formats));
- - text: formats应该是一个至少包含两个元素的字符串数组
+ - text: formats应该是一个至少包含两个字符串元素的数组。
testString: assert(myMusic[1].formats.every(function(item) { return (typeof item === "string")}) && myMusic[1].formats.length > 1);
```
@@ -70,7 +112,7 @@ var myMusic = [
var ourArray = [50,40,30];注意
ourArray [0] = 15; //等于[15,40,30]
array [0] 。尽管JavaScript能够正确处理，但这可能会让其他程序员在阅读代码时感到困惑。 array [0]尽管 JavaScript 能够正确处理，但可能会让看你代码的其他程序员感到困惑。
+myArray索引0处的数据修改为值45 。 myArray中索引0上的值为45。
+myArray现在应该是[45,64,99]。'
+ - text: myArray的值应该 [45,64,99]。
testString: assert((function(){if(typeof myArray != 'undefined' && myArray[0] == 45 && myArray[1] == 64 && myArray[2] == 99){return true;}else{return false;}})());
- - text: 您应该使用正确的索引来修改myArray的值。
+ - text: 你应该使用正确的索引修改myArray的值。
testString: assert((function(){if(code.match(/myArray\[0\]\s*=\s*/g)){return true;}else{return false;}})());
```
@@ -41,6 +54,7 @@ var myArray = [18,64,99];
// Only change code below this line.
+
```
@@ -50,7 +64,7 @@ var myArray = [18,64,99];
switch语句的case省略了break语句，则会执行以下case语句，直到遇到break 。如果您有多个具有相同输出的输入，则可以在switch语句中表示它们，如下所示： switch（val）{1,2和3的情况都会产生相同的结果。
情况1：
案例2：
案例3：
result =“1,2或3”;
打破;
案例4：
result =“4 alone”;
}
switch的每一条case添加break，那么直到遇见break为止，后续的case会一直执行。如果你想为多个不同的输入设置相同的结果，可以这样写：
+
+```js
+switch(val) {
+ case 1:
+ case 2:
+ case 3:
+ result = "1, 2, or 3";
+ break;
+ case 4:
+ result = "4 alone";
+}
+```
+
+这样，1、2、3 都会有相同的结果。
+answer ： 1-3 - “低” 4-6 - “中” 7-9 - “高” 注 case语句。 switch语句，根据输入的val的范围得出对应的answer：1-3 - "Low"4-6 - "Mid"7-9 - "High"
+提示：case应基于范围中的每一个数字编写。
+sequentialSizes(1)应返回“Low”
+ - text: sequentialSizes(1)应该返回 "Low"。
testString: assert(sequentialSizes(1) === "Low");
- - text: sequentialSizes(2)应该返回“Low”
+ - text: sequentialSizes(2)应该返回 "Low"。
testString: assert(sequentialSizes(2) === "Low");
- - text: sequentialSizes(3)应返回“Low”
+ - text: sequentialSizes(3)应该返回 "Low"。
testString: assert(sequentialSizes(3) === "Low");
- - text: sequentialSizes(4)应返回“Mid”
+ - text: sequentialSizes(4)应该返回 "Mid"。
testString: assert(sequentialSizes(4) === "Mid");
- - text: sequentialSizes(5)应返回“Mid”
+ - text: sequentialSizes(5)应该返回 "Mid"。
testString: assert(sequentialSizes(5) === "Mid");
- - text: sequentialSizes(6)应返回“Mid”
+ - text: sequentialSizes(6)应该返回 "Mid"。
testString: assert(sequentialSizes(6) === "Mid");
- - text: sequentialSizes(7)应该返回“High”
+ - text: sequentialSizes(7)应该返回 "High"。
testString: assert(sequentialSizes(7) === "High");
- - text: sequentialSizes(8)应该返回“High”
+ - text: sequentialSizes(8)应该返回 "High"。
testString: assert(sequentialSizes(8) === "High");
- - text: sequentialSizes(9)应该返回“High”
+ - text: sequentialSizes(9)应该返回 "High"。
testString: assert(sequentialSizes(9) === "High");
- - text: 您不应该使用任何if或else语句
+ - text: 你不应使用if或else语句。
testString: assert(!/else/g.test(code) || !/if/g.test(code));
- - text: 你应该有九个case陈述
+ - text: 你应该编写 9 个case语句。
testString: assert(code.match(/case/g).length === 9);
```
@@ -74,7 +94,30 @@ sequentialSizes(1);
## Solution
0.0使产品等于5.0 。 0.0的数值让变量product的值等于5.0。
+product应该等于5.0 。
+ - text: 变量product应该等于5.0。
testString: assert(product === 5.0);
- - text: 你应该使用*运算符
+ - text: 要使用*运算符。
testString: assert(/\*/.test(code));
```
@@ -34,6 +40,7 @@ tests:
```js
var product = 2.0 * 0.0;
+
```
@@ -43,7 +50,7 @@ var product = 2.0 * 0.0;
*符号来乘以两个数字。 例
myVar = 13 * 13; //指定169
*符号表示两数相乘。
+
+示例
+
+```js
+myVar = 13 * 13; // assigned 169
+```
+
+
+0使产品等于80 。 0来让变量 product 的值等于80。
+product等于80
+ - text: 要使product的值等于 80。
testString: assert(product === 80);
- - text: 使用*运算符
+ - text: 使用*运算符。
testString: assert(/\*/.test(code));
```
@@ -34,6 +48,7 @@ tests:
```js
var product = 8 * 0;
+
```
@@ -43,7 +58,7 @@ var product = 8 * 0;
[["Bulls", 23], ["White Sox", 45]] 。这也称为多维数组。 [["Bulls", 23], ["White Sox", 45]]。这被称为一个多维数组。
+myArray的嵌套数组。 myArray的多维数组。
+myArray应至少有一个嵌套在另一个数组中的数组。
+ - text: 应该包含至少一个嵌入的数组。
testString: assert(Array.isArray(myArray) && myArray.some(Array.isArray));
```
@@ -45,7 +50,7 @@ var myArray = [];
var arr = [这个输出在每个子元件
[1,2]，[3,4]，[5,6]
]。
for（var i = 0; i <arr.length; i ++）{
for（var j = 0; j <arr [i] .length; j ++）{
的console.log（ARR [i] [j]）;
}
}
arr一次一个。注意，对于内部循环，我们检查arr[i]的.length ，因为arr[i]本身就是一个数组。 arr中的每个子元素。提示，对于内部循环，我们可以通过arr[i]的.length来获得子数组的长度，因为arr[i]的本身就是一个数组。
+multiplyAll ，使其乘以product变量乘以arr的子数组中的每个数字multiplyAll，获得arr内部数组的每个数字相乘的结果product。
+multiplyAll([[1],[2],[3]])应该返回6'
+ - text: multiplyAll([[1],[2],[3]])应该返回 6。
testString: assert(multiplyAll([[1],[2],[3]]) === 6);
- - text: 'multiplyAll([[1,2],[3,4],[5,6,7]])应返回5040'
+ - text: multiplyAll([[1,2],[3,4],[5,6,7]])应该返回 5040。
testString: assert(multiplyAll([[1,2],[3,4],[5,6,7]]) === 5040);
- - text: 'multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])应该返回54'
+ - text: multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])应该返回 54。
testString: assert(multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]]) === 54);
```
@@ -56,7 +74,19 @@ multiplyAll([[1,2],[3,4],[5,6,7]]);
## Solution
param1和param2 ： function testFun（param1，param2）{然后我们可以调用
console.log（param1，param2）;
}
testFun ： testFun("Hello", "World");我们通过了两个论点， "Hello"和"World" 。在函数内部， param1将等于“Hello”， param2将等于“World”。请注意，您可以使用不同的参数再次调用testFun ，并且参数将采用新参数的值。 parameters在函数中充当占位符(也叫形参)的作用，参数可以为一个或多个。调用一个函数时所传入的参数为实参，实参决定着形参真正的值。简单理解：形参即形式、实参即内容。
+这是带有两个参数的函数，param1和param2：
+
+```js
+function testFun(param1, param2) {
+ console.log(param1, param2);
+}
+```
+
+接着我们调用testFun：
+testFun("Hello", "World");
+我们传递了两个参数，"Hello"和"World"。在函数内部，param1等于“Hello”，param2等于“World”。请注意，testFun函数可以多次调用，每次调用时传递的参数会决定形参的实际值。
+functionWithArgs ，该函数接受两个参数并将其总和输出到开发控制台。 functionWithArgs的函数，它可以接收两个参数，计算参数的和，将结果输出到控制台。functionWithArgs应该是一个函数
+ - text: functionWithArgs应该是一个函数。
testString: assert(typeof functionWithArgs === 'function');
- - text: 'functionWithArgs(1,2)应该输出3'
+ - text: functionWithArgs(1,2)应该输出3。
testString: if(typeof functionWithArgs === "function") { capture(); functionWithArgs(1,2); uncapture(); } assert(logOutput == 3);
- - text: 'functionWithArgs(7,9)应该输出16'
+ - text: functionWithArgs(7,9)应该输出16。
testString: if(typeof functionWithArgs === "function") { capture(); functionWithArgs(7,9); uncapture(); } assert(logOutput == 16);
- - text: 定义后，使用两个数字调用functionWithArgs 。
- testString: assert(/^\s*functionWithArgs\s*\(\s*\d+\s*,\s*\d+\s*\)\s*/m.test(code));
+ - text: 在你定义functionWithArgs之后记得调用它。
+ testString: assert(/^\s*functionWithArgs\s*\(\s*\d+\s*,\s*\d+\s*\)\s*;?/m.test(code));
```
@@ -44,6 +60,7 @@ ourFunctionWithArgs(10, 5); // Outputs 5
// Only change code below this line.
+
```
@@ -72,7 +89,6 @@ function uncapture() {
}
capture();
-
```
@@ -81,7 +97,13 @@ capture();
== ）和严格相等运算符（ === ）。让我们快速回顾一下这些运算符的实践。如果要比较的值不是同一类型，则相等运算符将执行类型转换，然后计算值。但是，严格相等运算符将按原样比较数据类型和值，而不将一种类型转换为另一种类型。 例子 3 =='3'//返回true，因为JavaScript执行从字符串到数字的类型转换注意
3 ==='3'//返回false，因为类型不同并且未执行类型转换
typeof运算符确定变量的类型或值，如下所示： typeof 3 //返回'number'
typeof'3'//返回'string'
==) 和严格相等运算符 (===)。现在让我们快速回顾并实践一下。
+如果要比较的值不是同一类型，相等运算符会先执行数据类型转换，然后比较值。而严格相等运算符只比较值，不会进行数据类型转换。
+由此可见，相等运算符和严格相等运算符的区别是：前者会执行隐式类型转换，后者不会。
+示例
+
+```js
+3 == '3' // returns true because JavaScript performs type conversion from string to number
+3 === '3' // returns false because the types are different and type conversion is not performed
+```
+
+提示typeof运算符确定变量的类型或值，如下所示：
+
+```js
+typeof 3 // returns 'number'
+typeof '3' // returns 'string'
+```
+
+compareEquality函数使用equality operator比较两个值。修改函数，使其仅在值严格相等时返回“Equal”。 compareEquality函数使用相等运算符比较两个值。修改函数，使其仅在值严格相等时返回 "Equal" 。
+compareEquality(10, "10")应返回“Not Equal”'
+ - text: compareEquality(10, "10")应该返回 "Not Equal"。
testString: assert(compareEquality(10, "10") === "Not Equal");
- - text: 'compareEquality("20", 20)应该返回“Not Equal”'
+ - text: compareEquality("20", 20)应该返回 "Not Equal"。
testString: assert(compareEquality("20", 20) === "Not Equal");
- - text: 您应该使用===运算符
+ - text: 你应该使用===运算符。
testString: assert(code.match(/===/g));
```
@@ -44,7 +65,6 @@ function compareEquality(a, b) {
// Change this value to test
compareEquality(10, "10");
-
```
@@ -56,7 +76,14 @@ compareEquality(10, "10");
## Solution
name和属性（ prop ）作为参数的lookUpProfile函数。该函数应检查name是否是实际联系人的firstName ，并且给定属性（ prop ）是该联系人的属性。如果两者都为真，则返回该属性的“值”。如果name与任何联系人不对应，则返回"No such contact"如果prop不符合找到匹配name的联系人的任何有效属性，则返回"No such property" lookUp有两个预定义参数：firstName值和prop属性 。
+函数将会检查通讯录中是否存在一个与传入的firstName相同的联系人。如果存在，那么还需要检查对应的联系人中是否存在prop属性。
+如果它们都存在，函数返回prop属性对应的值。
+如果firstName值不存在，返回"No such contact"。
+如果prop属性不存在，返回"No such property"。
+"Kristian", "lastName"应该返回"Vos"'
+ - text: "Kristian", "lastName"应该返回 "Vos"。
testString: assert(lookUpProfile('Kristian','lastName') === "Vos");
- - text: '"Sherlock", "likes"应该回归["Intriguing Cases", "Violin"]'
+ - text: "Sherlock", "likes"应该返回 ["Intriguing Cases", "Violin"]。
testString: assert.deepEqual(lookUpProfile("Sherlock", "likes"), ["Intriguing Cases", "Violin"]);
- - text: '"Harry","likes"应该返回一个阵列'
+ - text: "Harry","likes"应该返回 an array。
testString: assert(typeof lookUpProfile("Harry", "likes") === "object");
- - text: '"Bob", "number"应该返回“没有这样的联系”'
+ - text: "Bob", "number"应该返回 "No such contact"。
testString: assert(lookUpProfile("Bob", "number") === "No such contact");
- - text: '"Bob", "potato"应该返回“没有这样的联系”'
+ - text: "Bob", "potato"应该返回 "No such contact"。
testString: assert(lookUpProfile("Bob", "potato") === "No such contact");
- - text: '"Akira", "address"应该返回“没有这样的财产”'
+ - text: "Akira", "address"应该返回 "No such property"。
testString: assert(lookUpProfile("Akira", "address") === "No such property");
```
@@ -78,7 +87,6 @@ function lookUpProfile(name, prop){
// Change these values to test your function
lookUpProfile("Akira", "likes");
-
```
@@ -90,7 +98,48 @@ lookUpProfile("Akira", "likes");
## Solution
doubleQuoteStr =“这是一个字符串”;你可能想要使用一种报价而不是另一种报价的原因是你想在字符串中使用这两种报价。如果要将对话保存在字符串中并将对话用引号括起，则可能会发生这种情况。它的另一个用途是在一个字符串中保存带引号中各种属性的
singleQuoteStr ='这也是一个字符串';
<a>标签。 谈话='芬恩向杰克惊呼，“代数！”';但是，如果您需要使用其中的最外层引号，这将成为一个问题。请记住，字符串在开头和结尾都有相同的引用。但是如果你在中间的某个地方有相同的引用，字符串将提前停止并抛出错误。
goodStr ='杰克问芬恩，“嘿，我们去冒险吧？”在上面的goodStr中 ，您可以使用反斜杠
badStr ='芬恩回答，“我们走了！”'; //引发错误
\作为转义字符安全地使用两个引号。 注意 \不应与正斜杠/混淆。他们不做同样的事情。 <a>标签的字符串中，<a>标签的属性值需要用引号包裹。
+
+```js
+conversation = 'Finn exclaims to Jake, "Algebraic!"';
+```
+
+但是，如果你想在字符串中使用与最外层相同的引号，会有一些问题。要知道，字符串在开头和结尾都有相同的引号，如果在中间使用了相同的引号，字符串会提前中止并抛出错误。
+
+```js
+goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"';
+badStr = 'Finn responds, "Let's go!"'; // Throws an error
+```
+
+在上面的goodStr中，通过使用反斜杠\转义字符可以安全地使用两种引号
+提示\和斜杠/搞混，它们不是一回事。
+<a>标签在任何地方都使用双引号。您需要将外引号更改为单引号，以便删除转义字符。 <a>标签里面任何地方都可以使用双引号。你需要将最外层引号更改为单引号，以便删除转义字符。
+backslashes （ \ ）
+ - text: 删除所有反斜杠 (\)。
testString: assert(!/\\/g.test(code) && myStr.match('\\s*\\s*Link\\s*\\s*'));
- - text: '你应该有两个单引号'和四个双引号"'
+ - text: 应该要有两个单引号'和四个双引号"。
testString: assert(code.match(/"/g).length === 4 && code.match(/'/g).length === 2);
```
@@ -34,6 +61,7 @@ tests:
```js
var myStr = "Link";
+
```
@@ -43,7 +71,7 @@ var myStr = "Link";
id （如2548 ），一个属性prop （如"artist"或"tracks" ），以及一个value （如"Addicted to Love" ）来修改此集合中的数据。如果prop不是"tracks"且value不为空（ "" ），则更新或设置该记录专辑属性的value 。您的函数必须始终返回整个集合对象。处理不完整数据有几个规则：如果prop是"tracks"但是相册没有"tracks"属性，则在将新值添加到相册的相应属性之前创建一个空数组。如果prop是"tracks"且value不为空（ "" ），则将value推到专辑现有tracks数组的末尾。如果value为空（ "" ），则从相册中删除给定的prop属性。 提示 bracket notation 。 Push是一种可以在Mozilla Developer Network上阅读的数组方法。您可以参考操作复杂对象介绍JavaScript对象表示法（JSON）进行复习。 id（如2548）、prop（属性，如"artist"或"tracks"）以及value（值，如"Addicted to Love"）来修改音乐专辑收藏的数据。
+如果属性prop不是"tracks"且值value不为空（""），则更新或设置该专辑属性的值value。
+你的函数必须始终返回整个音乐专辑集合对象。
+处理不完整数据有几条规则：
+如果属性prop是"tracks"，但是专辑没有"tracks"属性，则在添加值之前先给"tracks"创建一个空数组。
+如果prop是"tracks"，并且值value不为空（""）， 把值value添加到tracks数组中。
+如果值value为空（""），则删除专辑的这一属性prop
+提示：中括号。
+Push 是一个数组方法，详情请查看Mozilla Developer Network.
+你可以参考操作复杂对象这一节的内容复习相关知识。
+updateRecords(5439, "artist", "ABBA") ， artist应该是"ABBA"'
- testString: collection = collectionCopy; assert(updateRecords(5439, "artist", "ABBA")[5439]["artist"] === "ABBA");
- - text: '在updateRecords(5439, "tracks", "Take a Chance on Me") ， tracks应该以"Take a Chance on Me"作为最后一个元素。'
+ - text: 执行updateRecords(5439, "artist", "ABBA")后，artist属性值应该是"ABBA"。
+ testString: 'assert(code.match(/var collection = {\s*2548: {\s*album: "Slippery When Wet",\s*artist: "Bon Jovi",\s*tracks: \[\s*"Let It Rock",\s*"You Give Love a Bad Name"\s*\]\s*},\s*2468: {\s*album: "1999",\s*artist: "Prince",\s*tracks: \[\s*"1999",\s*"Little Red Corvette"\s*\]\s*},\s*1245: {\s*artist: "Robert Palmer",\s*tracks: \[ \]\s*},\s*5439: {\s*album: "ABBA Gold"\s*}\s*};/g));'
+ - text: 执行updateRecords(5439, "artist", "ABBA")后，artist 最后的元素应该是 "ABBA"。
+ testString: assert(updateRecords(5439, "artist", "ABBA")[5439]["artist"] === "ABBA");
+ - text: 执行 updateRecords(5439, "tracks", "Take a Chance on Me") 后，tracks 最后的元素应该是 "Take a Chance on Me"。
testString: assert(updateRecords(5439, "tracks", "Take a Chance on Me")[5439]["tracks"].pop() === "Take a Chance on Me");
- - text: '在updateRecords(2548, "artist", "") ，不应该设置artist'
+ - text: 执行updateRecords(2548, "artist", "")后，artist不应被创建。
testString: updateRecords(2548, "artist", ""); assert(!collection[2548].hasOwnProperty("artist"));
- - text: '在updateRecords(1245, "tracks", "Addicted to Love") ， tracks应该将"Addicted to Love"作为最后一个元素。'
+ - text: 执行updateRecords(1245, "tracks", "Addicted to Love")后，tracks最后的元素应该是"Addicted to Love"。
testString: assert(updateRecords(1245, "tracks", "Addicted to Love")[1245]["tracks"].pop() === "Addicted to Love");
- - text: '在updateRecords(2468, "tracks", "Free") ， tracks应该以"1999"作为第一个元素。'
+ - text: 执行updateRecords(2468, "tracks", "Free")后，tracks第一个元素应该是"1999"。
testString: assert(updateRecords(2468, "tracks", "Free")[2468]["tracks"][0] === "1999");
- - text: '在updateRecords(2548, "tracks", "") ，不应设置tracks'
+ - text: 执行updateRecords(2548, "tracks", "")后，tracks不应被创建。
testString: updateRecords(2548, "tracks", ""); assert(!collection[2548].hasOwnProperty("tracks"));
- - text: '在updateRecords(1245, "album", "Riptide") ， album应该是"Riptide"'
+ - text: 执行updateRecords(1245, "album", "Riptide")后，album应该是"Riptide"。
testString: assert(updateRecords(1245, "album", "Riptide")[1245]["album"] === "Riptide");
```
@@ -39,38 +55,35 @@ tests:
## Challenge Seed
0 到第 n 的元素乘积，使用 for 循环， 可以这样做：
+
+```js
+ function multiply(arr, n) {
+ var product = arr[0];
+ for (var i = 1; i <= n; i++) {
+ product *= arr[i];
+ }
+ return product;
+ }
+```
+
+下面是递归写法，注意代码里的 multiply(arr, n) == multiply(arr, n - 1) * arr[n]。这意味着可以重写 multiply 以调用自身而无需依赖循环。
+
+```js
+ function multiply(arr, n) {
+ if (n <= 0) {
+ return arr[0];
+ } else {
+ return multiply(arr, n - 1) * arr[n];
+ }
+ }
+```
+
+递归版本的 multiply 详述如下。在 base case 里，也就是 n <= 0 时，返回结果，也就是 arr[0]。在 n 比 0 大的情况里，函数会调用自身，参数 n 的值为 n - 1。函数以相同的方式持续调用 multiply，直到 n = 0 为止。所以，所有函数都可以返回，原始的 multiply 返回结果。
+
+注意： 递归函数在没有函数调用时（在这个例子是，是当 n <= 0 时）必需有一个跳出结构，否则永远不会执行完毕。
+
+sum(arr, n)，返回递归调用数组 arr 从第 0 个到第 n 个元素和。
+
+sum([1], 0) 应该返回 1 。
+ testString: assert.equal(sum([1], 0), 1);
+ - text: sum([2, 3, 4], 1) 应该返回 5 。
+ testString: assert.equal(sum([2, 3, 4], 1), 5);
+ - text: 代码不应该包含任何形式的循环（for 或者 while 或者高阶函数比如 forEach，map，filter，或者 reduce)。
+ testString: assert(!removeJSComments(code).match(/for|while|forEach|map|filter|reduce/g));
+ - text: 应该使用递归来解决这个问题。
+ testString: assert(removeJSComments(sum.toString()).match(/sum\(.*\)/g).length > 1);
+```
+
+switch语句比许多链接的if / else if语句更容易编写。下列： if（val === 1）{可以替换为：
answer =“a”;
} else if（val === 2）{
answer =“b”;
} else {
answer =“c”;
}
switch（val）{
情况1：
answer =“a”;
打破;
案例2：
answer =“b”;
打破;
默认：
answer =“c”;
}
switch语句写起来会比多个串联的if/if else语句容易些，譬如:
+
+```js
+if (val === 1) {
+ answer = "a";
+} else if (val === 2) {
+ answer = "b";
+} else {
+ answer = "c";
+}
+```
+
+可以被下面替代：
+
+```js
+switch(val) {
+ case 1:
+ answer = "a";
+ break;
+ case 2:
+ answer = "b";
+ break;
+ default:
+ answer = "c";
+}
+```
+
+if / else if语句更改为switch语句。 if/if else语句改成switch语句。
+else语句
+ - text: 不要使用else表达式。
testString: assert(!/else/g.test(code));
- - text: 您不应在编辑器中的任何位置使用任何if语句
+ - text: 不要使用if表达式。
testString: assert(!/if/g.test(code));
- - text: 你应该至少有四个break语句
+ - text: 你应该有至少 4 个break表达式。
testString: assert(code.match(/break/g).length >= 4);
- - text: chainToSwitch("bob")应该是“Marley”
+ - text: chainToSwitch("bob")应该为 "Marley"。
testString: assert(chainToSwitch("bob") === "Marley");
- - text: chainToSwitch(42)应该是“答案”
+ - text: chainToSwitch(42)应该为 "The Answer"。
testString: assert(chainToSwitch(42) === "The Answer");
- - text: chainToSwitch(1)应该是“没有＃1”
+ - text: chainToSwitch(1)应该为 "There is no #1"。
testString: "assert(chainToSwitch(1) === \"There is no #1\");"
- - text: chainToSwitch(99)应该是“错过了我这么多！”
+ - text: chainToSwitch(99)应该为 "Missed me by this much!"。
testString: assert(chainToSwitch(99) === "Missed me by this much!");
- - text: chainToSwitch(7)应该是“Ate Nine”
+ - text: chainToSwitch(7)应该为 "Ate Nine"。
testString: assert(chainToSwitch(7) === "Ate Nine");
- - text: chainToSwitch("John")应为“”（空字符串）
+ - text: chainToSwitch("John")应该为 "" (empty string)。
testString: assert(chainToSwitch("John") === "");
- - text: chainToSwitch(156)应为“”（空字符串）
+ - text: chainToSwitch(156)应该为 "" (empty string)。
testString: assert(chainToSwitch(156) === "");
```
@@ -82,7 +113,29 @@ chainToSwitch(7);
## Solution
return语句从函数中发回一个值。 例 function plusThree（num）{
返回num + 3;
}
var answer = plusThree（5）; // 8
plusThree接受num的参数并返回一个等于num + 3的值。 return语句把数据从一个函数中传出来。
+示例
+
+```js
+function plusThree(num) {
+ return num + 3;
+}
+var answer = plusThree(5); // 8
+```
+
+plusThree带有一个num的参数并且返回（returns）一个等于num + 3的值。
+timesFive ，将其乘以5 ，然后返回新值。有关如何测试timesFive函数的示例，请参阅编辑器中的最后一行。 timesFive接收一个参数, 把它乘以5之后返回，关于如何测试timesFive 函数，可以参考编辑器中最后一行的示例。
+timesFive应该是一个功能
+ - text: timesFive应是一个函数。
testString: assert(typeof timesFive === 'function');
- - text: timesFive(5)应该返回25
+ - text: timesFive(5)应该返回25。
testString: assert(timesFive(5) === 25);
- - text: timesFive(2)应该返回10
+ - text: timesFive(2)应该返回10。
testString: assert(timesFive(2) === 10);
- - text: timesFive(0)应该返回0
+ - text: timesFive(0)应该返回0。
testString: assert(timesFive(0) === 0);
```
@@ -46,7 +61,6 @@ function minusSeven(num) {
console.log(minusSeven(10));
-
```
@@ -58,7 +72,12 @@ console.log(minusSeven(10));
## Solution
return语句时，当前函数的执行停止，控制返回到调用位置。 例 function myFun（）{上面输出“Hello”到控制台，返回“World”，但是
的console.log（ “你好”）;
回归“世界”;
的console.log（ “BYEBYE”）
}
myFun（）;
"byebye"永远不输出，因为函数退出return语句。 "byebye"，因为函数遇到 return 语句就退出了。
+abTest以便如果a或b小于0 ，函数将立即以undefined值退出。 暗示 undefined是一个关键字 ，而不是一个字符串。 abTest当a或b小于0时，函数立即返回一个undefined并退出。
+提示undefined 是一个关键字，而不是一个字符串。
+abTest(2,2)应返回一个数字'
+ - text: abTest(2,2) 应该返回一个数字。
testString: assert(typeof abTest(2,2) === 'number' );
- - text: 'abTest(2,2)应该返回8'
+ - text: abTest(2,2) 应该返回 8。
testString: assert(abTest(2,2) === 8 );
- - text: 'abTest(-2,2)应返回undefined'
+ - text: abTest(-2,2) 应该返回 undefined。
testString: assert(abTest(-2,2) === undefined );
- - text: 'abTest(2,-2)应返回undefined'
+ - text: abTest(2,-2) 应该返回 undefined。
testString: assert(abTest(2,-2) === undefined );
- - text: 'abTest(2,8)应该返回18'
+ - text: abTest(2,8) 应该返回 18。
testString: assert(abTest(2,8) === 18 );
- - text: 'abTest(3,3)应该返回12'
+ - text: abTest(3,3) 应该返回 12。
testString: assert(abTest(3,3) === 12 );
```
@@ -53,7 +71,6 @@ function abTest(a, b) {
// Change values below to test your code
abTest(2,2);
-
```
@@ -65,7 +82,14 @@ abTest(2,2);
## Solution
true或false值。有时人们使用if / else语句进行比较，如下所示： function isEqual（a，b）{但是有一种更好的方法可以做到这一点。由于
if（a === b）{
返回true;
} else {
返回虚假;
}
}
===返回true或false ，我们可以返回比较结果： function isEqual（a，b）{
返回a === b;
}
true要么是false。
+有时人们通过 if/else 语句来做比较然后返回true或false。
+
+```js
+function isEqual(a,b) {
+ if (a === b) {
+ return true;
+ } else {
+ return false;
+ }
+}
+```
+
+有一个更好的方法，因为===总是返回true或false，所以我们可以直接返回比较的结果：
+
+```js
+function isEqual(a,b) {
+ return a === b;
+}
+```
+
+isLess以删除if/else语句。 isLess函数的if/else语句但不影响函数的功能。
+isLess(10,15)应该返回true'
+ - text: isLess(10,15)应该返回 true。
testString: assert(isLess(10,15) === true);
- - text: 'isLess(15,10)应该返回false'
+ - text: isLess(15,10)应该返回 false。
testString: assert(isLess(15, 10) === false);
- - text: 您不应该使用任何if或else语句
+ - text: 不应该使用 if 或者 else 语句。
testString: assert(!/if|else/g.test(code));
```
@@ -45,7 +70,6 @@ function isLess(a, b) {
// Change these values to test
isLess(10, 15);
-
```
@@ -57,7 +81,11 @@ isLess(10, 15);
## Solution
switch 语句测试一个值，并且可以包含许多定义各种可能值的 case 语句。 从第一个匹配的 case 值开始执行语句，直到遇到 break 。
-这是 switch 语句的示例：
+ case 值以严格相等性（ === ）进行测试。 break 告诉JavaScript停止执行语句。 如果省略 break ，将执行下一条语句。
-
+测试case值使用严格相等运算符进行比较，break 关键字告诉 JavaScript 停止执行语句。如果没有 break 关键字，下一个语句会继续执行。
val并设置以下条件的answer ： 1 - “alpha” 2 - “beta” 3 - “伽玛” 4 - “三角洲” val的 switch 语句，并且根据下面的条件来设置不同的answer：1- "alpha"2 - "beta"3- "gamma"4 - "delta"
+caseInSwitch(1)的值应为“alpha”
+ - text: caseInSwitch(1) 应该有一个值为 "alpha"。
testString: assert(caseInSwitch(1) === "alpha");
- - text: caseInSwitch(2)的值应为“beta”
+ - text: caseInSwitch(2) 应该有一个值为 "beta"。
testString: assert(caseInSwitch(2) === "beta");
- - text: caseInSwitch(3)的值应为“gamma”
+ - text: caseInSwitch(3) 应该有一个值为 "gamma"。
testString: assert(caseInSwitch(3) === "gamma");
- - text: caseInSwitch(4)的值应为“delta”
+ - text: caseInSwitch(4) 应该有一个值为 "delta"。
testString: assert(caseInSwitch(4) === "delta");
- - text: 您不应该使用任何if或else语句
+ - text: 不能使用任何if或else表达式。
testString: assert(!/else/g.test(code) || !/if/g.test(code));
- - text: 你应该至少有3个break语句
+ - text: 你应该有至少 3 个break表达式。
testString: assert(code.match(/break/g).length > 2);
```
@@ -82,7 +83,26 @@ caseInSwitch(1);
## Solution
myList创建购物清单。该列表应该是包含多个子阵列的多维数组。每个子数组中的第一个元素应包含一个带有项目名称的字符串。第二个元素应该是一个代表数量的数字，即["Chocolate Bar", 15]列表中应该至少有5个子数组。 myList的购物清单，清单的数据格式就是多维数组。
+每个子数组中的第一个元素应该是购买的物品名称，第二个元素应该是物品的数量，类似于：
+["Chocolate Bar", 15]
+任务：你的购物清单至少应该有 5 个子数组。
+myList应该是一个数组
+ - text: myList应该一个数组。
testString: assert(isArray);
- - text: 每个子数组中的第一个元素都必须是字符串
+ - text: 你的每个子数组的第一个元素的类型都应该是字符串。
testString: assert(hasString);
- - text: 每个子数组中的第二个元素都必须是数字
+ - text: 你的每个子数组的第二个元素的类型都应该是数字。
testString: assert(hasNumber);
- - text: 您的列表中必须至少有5个项目
+ - text: 你的列表中至少要包含 5 个元素。
testString: assert(count > 4);
```
@@ -39,6 +46,7 @@ tests:
```js
var myList = [];
+
```
@@ -48,7 +56,32 @@ var myList = [];
queue的后面添加新项目，并从queue的前面取出旧项目。编写一个函数nextInLine ，它接受一个数组（ arr ）和一个数字（ item ）作为参数。将数字添加到数组的末尾，然后删除数组的第一个元素。然后， nextInLine函数应返回已删除的元素。 队列的末尾，旧的条目会从队列的头部被移出。
+写一个函数nextInLine，用一个数组(arr)和一个数字(item)作为参数。
+把数字添加到数组的结尾，然后移出数组的第一个元素。
+最后nextInLine函数应该返回被删除的元素。
+nextInLine([], 5)应返回一个数字。'
+ - text: nextInLine([], 5)应该返回一个数字。
testString: assert.isNumber(nextInLine([],5));
- - text: 'nextInLine([], 1)应该返回1'
+ - text: nextInLine([], 1)应该返回1。
testString: assert(nextInLine([],1) === 1);
- - text: 'nextInLine([2], 1)应返回2'
+ - text: nextInLine([2], 1)应该返回2。
testString: assert(nextInLine([2],1) === 2);
- - text: 'nextInLine([5,6,7,8,9], 1)应该返回5'
+ - text: nextInLine([5,6,7,8,9], 1)应该返回5。
testString: assert(nextInLine([5,6,7,8,9],1) === 5);
- - text: '在nextInLine(testArr, 10) ， testArr[4]应为10'
+ - text: 在nextInLine(testArr, 10)执行后testArr[4]应该是10。
testString: nextInLine(testArr, 10); assert(testArr[4] === 10);
```
@@ -52,7 +59,6 @@ var testArr = [1,2,3,4,5];
console.log("Before: " + JSON.stringify(testArr));
console.log(nextInLine(testArr, 6)); // Modify this line to test
console.log("After: " + JSON.stringify(testArr));
-
```
@@ -81,7 +87,6 @@ function uncapture() {
}
capture();
-
```
@@ -90,7 +95,9 @@ capture();
array变量，我们可以在一个地方存储多个数据。你开始一个带有开口方括号的数组声明，用一个结束的方括号结束，并在每个条目之间加一个逗号，如下所示： var sandwich = ["peanut butter", "jelly", "bread"] 。 数组，我们可以在一个地方存储多个数据。
+以左方括号[开始定义一个数组，以右方括号]结束，里面每个元素之间用逗号隔开，例如：
+var sandwich = ["peanut butter", "jelly", "bread"].
+myArray ，使其包含string和number （ myArray顺序）。 暗示 字符串和数字的数组myArray。
+提示myArray应该是一个array 。
+ - text: myArray应该是一个数组。
testString: assert(typeof myArray == 'object');
- - text: myArray的第一项应该是一个string 。
+ - text: myArray数组的第一个元素应该是一个字符串。
testString: assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
- - text: myArray的第二项应该是一个number 。
+ - text: myArray数组的第二个元素应该是一个数字。
testString: assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
```
@@ -49,7 +57,7 @@ var myArray = [];
myVariable = 5;这将Number值5分配给myVariable 。作业总是从右到左。在将值分配给运算符左侧的变量之前，将解析=运算符右侧的所有内容。 myVar = 5;这将为
myNum = myVar;
myVar分配5 ，然后再次将myVar解析为5并将其分配给myNum 。 myVariable = 5;
+这条语句把Number类型的值5赋给变量myVariable。
+赋值过程是从右到左进行的。在将值分配给运算符左侧的变量之前，将解析=运算符右侧的所有内容。
+
+```js
+myVar = 5;
+myNum = myVar;
+```
+
+数值5被赋给变量myVar中，然后再次将变量myVar解析为5并将其赋给myNum变量。
+7分配给变量a 。分配的内容a变量b 。 7赋给变量 a。
+把变量a中的内容赋给变量b。
+a的值应为7
+ - text: a的值应该是 7。
testString: assert(typeof a === 'number' && a === 7);
- - text: b的值应为7
+ - text: b的值应该是 7。
testString: assert(typeof b === 'number' && b === 7);
- - text: a应分配给b =
+ - text: 你需要用=把a的值赋给b。
testString: assert(/b\s*=\s*a\s*;/g.test(code));
```
@@ -56,7 +72,6 @@ if (typeof a != 'undefined') {
if (typeof b != 'undefined') {
b = undefined;
}
-
```
@@ -65,7 +80,7 @@ if (typeof b != 'undefined') {
-符号进行减法。 例
myVar = 12 - 6; //分配6
-来做减法运算。
+
+示例
+
+```js
+myVar = 12 - 6; // assigned 6
+```
+
+
+0因此差异为12 。 0让变量 difference 的值为12。
+difference等于12。
+ - text: 要使difference的值等于 12。
testString: assert(difference === 12);
- - text: 只从45中减去一个数字。
- testString: assert(/difference=45-33;?/.test(code.replace(/\s/g, '')));
+ - text: 只用 45 减去一个数。
+ testString: assert(/var\s*difference\s*=\s*45\s*-\s*[0-9]*;(?!\s*[a-zA-Z0-9]+)/.test(code));
```
@@ -34,6 +48,7 @@ tests:
```js
var difference = 45 - 0;
+
```
@@ -43,7 +58,7 @@ var difference = 45 - 0;
.hasOwnProperty(propname)方法来确定该对象是否具有给定的属性名称。 .hasOwnProperty()如果找到属性则返回true或false 。 例 var myObj = {
顶部：“帽子”，
底部：“裤子”
};
myObj.hasOwnProperty（ “顶部”）; //真的
myObj.hasOwnProperty（ “中间”）; //假
.hasOwnProperty(propname)方法来检查对象是否有该属性。如果有返回true，反之返回false。
+示例
+
+```js
+var myObj = {
+ top: "hat",
+ bottom: "pants"
+};
+myObj.hasOwnProperty("top"); // true
+myObj.hasOwnProperty("middle"); // false
+```
+
+checkObj以测试myObj的checkProp 。如果找到该属性，则返回该属性的值。如果没有，请返回"Not Found" 。 checkObj检查myObj是否有checkProp属性，如果属性存在，返回属性对应的值，如果不存在，返回"Not Found"。
+checkObj("gift")应该返回"pony" 。
+ - text: checkObj("gift")应该返回"pony"。
testString: assert(checkObj("gift") === "pony");
- - text: checkObj("pet")应该返回"kitten" 。
+ - text: checkObj("pet")应该返回"kitten"。
testString: assert(checkObj("pet") === "kitten");
- - text: checkObj("house")应该返回"Not Found" 。
+ - text: checkObj("house")应该返回"Not Found"。
testString: assert(checkObj("house") === "Not Found");
```
@@ -49,7 +65,6 @@ function checkObj(checkProp) {
// Test your code by modifying these values
checkObj("gift");
-
```
@@ -61,7 +76,20 @@ checkObj("gift");
## Solution
String值是不可变的 ，这意味着一旦创建它们就不能被更改。例如，以下代码： var myStr =“Bob”;无法将
myStr [0] =“J”;
myStr的值更改为“Job”，因为myStr的内容无法更改。请注意，这并不意味着myStr不能改变的，只是一个字符串的单个字符不能改变。更改myStr的唯一方法是为其分配一个新字符串，如下所示： var myStr =“Bob”;
myStr =“工作”;
字符串的值是 不可变的，这意味着一旦字符串被创建就不能被改变。
+例如，下面的代码：
+
+```js
+var myStr = "Bob";
+myStr[0] = "J";
+```
+
+是不会把变量myStr的值改变成 "Job" 的，因为变量myStr是不可变的。注意，这并不意味着myStr永远不能被改变，只是字符串字面量 string literal 的各个字符不能被改变。改变myStr中的唯一方法是重新给它赋一个值，例如：
+
+```js
+var myStr = "Bob";
+myStr = "Job";
+```
+
+myStr的赋值，使其包含Hello World的字符串值，使用上面示例中显示的方法。 myStr的值改为Hello World。
+myStr应该具有Hello World的值
+ - text: message:myStr的值应该是Hello World。
testString: assert(myStr === "Hello World");
- - text: 不要更改行上方的代码
+ - text: 不要修改注释上面的代码。
testString: assert(/myStr = "Jello World"/.test(code));
```
@@ -39,6 +58,7 @@ var myStr = "Jello World";
myStr[0] = "H"; // Fix Me
+
```
@@ -48,7 +68,7 @@ myStr[0] = "H"; // Fix Me
Booleans可能只是两个值中的一个： true或false 。它们基本上是很少的开关，其中true为“on”而false为“off”。这两个国家是相互排斥的。 注意 Boolean值永远不会用引号写。 strings "true"和"false"不是Boolean ，在JavaScript中没有特殊含义。 布尔值要么是true要么是false。它非常像电路开关，true是 “开”，false是 “关”。这两种状态是互斥的。
+注意布尔值是不带引号的，"true"和"false"是字符串而不是布尔值，在 JavaScript 中也没有特殊含义。
+welcomeToBooleans函数，以便在单击运行按钮时返回true而不是false 。 welcomeToBooleans函数，让它返回true而不是false。
+welcomeToBooleans()函数应该返回一个布尔值（true / false）。
+ - text: welcomeToBooleans()函数应该返回一个布尔值 (true/false)。
testString: assert(typeof welcomeToBooleans() === 'boolean');
- - text: welcomeToBooleans()应该返回true。
+ - text: welcomeToBooleans()应该返回 true。
testString: assert(welcomeToBooleans() === true);
```
@@ -34,13 +40,12 @@ tests:
```js
function welcomeToBooleans() {
-// Only change code below this line.
+ // Only change code below this line.
-return false; // Change this line
+ return false; // Change this line
-// Only change code above this line.
+ // Only change code above this line.
}
-
```
@@ -50,7 +55,7 @@ return false; // Change this line
MYVAR与MyVar和myvar 。可以有多个具有相同名称但不同外壳的不同变量。强烈建议您为清晰起见， 不要使用此语言功能。 var someVariable;
var anotherVariableName;
var thisVariableNameIsSoLong;
MYVAR与MyVar和myvar是截然不同的变量。这有可能导致出现多个相似名字的的变量。所以强烈地建议你，为了保持代码清晰不要使用这一特性。
+studlyCapVar已定义且值为10
+ - text: studlyCapVar应该被定义并且值为10。
testString: assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
- - text: properCamelCase已定义且值为"A String"
+ - text: properCamelCase应该被定义并且值为"A String"。
testString: assert(typeof properCamelCase !== 'undefined' && properCamelCase === "A String");
- - text: titleCaseOver已定义，其值为9000
+ - text: titleCaseOver应该被定义并且值为9000。
testString: assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
- - text: studlyCapVar应该在声明和赋值部分使用camelCase。
+ - text: studlyCapVar在声明和赋值时都应该使用驼峰命名法。
testString: assert(code.match(/studlyCapVar/g).length === 2);
- - text: properCamelCase应该在声明和赋值部分使用camelCase。
+ - text: properCamelCase 在声明和赋值时都应该使用驼峰命名法。
testString: assert(code.match(/properCamelCase/g).length === 2);
- - text: titleCaseOver应该在声明和赋值部分使用camelCase。
+ - text: titleCaseOver 在声明和赋值时都应该使用驼峰命名法。
testString: assert(code.match(/titleCaseOver/g).length === 2);
```
@@ -49,7 +65,6 @@ var TitleCaseOver;
STUDLYCAPVAR = 10;
PRoperCAmelCAse = "A String";
tITLEcASEoVER = 9000;
-
```
@@ -61,7 +76,15 @@ tITLEcASEoVER = 9000;
## Solution
return语句但不必包含。在函数没有return语句的情况下，当您调用它时，该函数处理内部代码但返回的值是undefined 。 例 var sum = 0;
function addSum（num）{
sum = sum + num;
}
var returnedValue = addSum（3）; //将修改sum，但返回值未定义
addSum是一个没有return语句的函数。该函数将更改全局sum变量，但函数的返回值undefined return语句来返回值，但这不是必须的。在函数没有return语句的情况下，当你调用它时，该函数会执行内部代码，返回的值是undefined。
+示例
+
+```js
+var sum = 0;
+function addSum(num) {
+ sum = sum + num;
+}
+addSum(3); // sum will be modified but returned value is undefined
+```
+
+addSum是一个没有return语句的函数。该函数将更改全局变量sum，函数的返回值为undefined。
+addFive 。此函数向sum变量添加5，但其返回值undefined 。 addFive。此函数使sum变量加 5，但其返回值是undefined。
+addFive应该是一个函数
+ - text: addFive应该是一个函数。
testString: assert(typeof addFive === 'function');
- - text: sum应该等于8
+ - text: sum应该等于 8。
testString: assert(sum === 8);
- - text: addFive返回值应该是undefined
+ - text: addFive的返回值应该是undefined。
testString: assert(addFive() === undefined);
- - text: 在函数内部，向sum变量添加5
+ - text: 函数给变量 sum 加 5。
testString: assert(addFive.toString().replace(/\s/g, '').match(/sum=sum\+5|sum\+=5/));
```
@@ -44,31 +60,34 @@ function addThree() {
// Only change code below this line
-
-
// Only change code above this line
-var returnedValue = addFive();
-
+addThree();
+addFive();
```
-### After Test
-undefined 。如果对undefined变量进行数学运算，则结果将为NaN ，表示“非数字” 。如果将字符串与undefined变量连接起来，您将得到一个"undefined"的文字字符串 。 undefined。当你对一个值为undefined的变量进行运算操作的时候，算出来的结果将会是NaN，NaN的意思是"Not a Number"。当你用一个值是undefined的变量来做字符串拼接操作的时候，它会输出字符串"undefined"。
+a ， b和c与5 ， 10 ，和"I am a"分别让他们不会undefined 。 a、b、c，并且分别给他们赋值：5、10、"I am a"，这样它们值就不会是undefined了。
+a应定义并评估其值为6
+ - text: a应该被定义，并且值为6。
testString: assert(typeof a === 'number' && a === 6);
- - text: 应定义和评估b的值为15
+ - text: b应该被定义，并且值为15。
testString: assert(typeof b === 'number' && b === 15);
- - text: c不应该包含undefined并且值应为“我是一个字符串！”
+ - text: c的值不能包含undefined，应该为 "I am a String!"。
testString: assert(!/undefined/.test(c) && c === "I am a String!");
- - text: 不要更改行下方的代码
+ - text: 不要修改第二条注释下的代码。
testString: assert(/a = a \+ 1;/.test(code) && /b = b \+ 5;/.test(code) && /c = c \+ " String!";/.test(code));
```
@@ -56,7 +61,7 @@ c = c + " String!";
ourDog ： var ourDog = {由于他是一只特别开心的狗，让我们改名为“快乐露营者”。以下是我们更新对象名称属性的方法：
“名字”：“露营者”，
“腿”：4，
“尾巴”：1，
“朋友们”：[“一切！”]
};
ourDog.name = "Happy Camper";或者我们的ourDog["name"] = "Happy Camper";现在，当我们评估我们的ourDog.name ，而不是获得“Camper”时，我们将获得他的新名字“Happy Camper”。 ourDog:
+
+```js
+var ourDog = {
+ "name": "Camper",
+ "legs": 4,
+ "tails": 1,
+ "friends": ["everything!"]
+};
+```
+
+让我们更改它的名称为 "Happy Camper"，这有两种方式来更新对象的name属性：
+ourDog.name = "Happy Camper"; 或
+ourDog["name"] = "Happy Camper";
+现在，ourDog.name的值就不再是 "Camper"，而是 "Happy Camper"。
+myDog对象的name属性。让我们将她的名字从“Coder”改为“Happy Coder”。您可以使用点或括号表示法。 myDog对象的name属性，让它的名字从 "Coder" 变成 "Happy Coder"。
+myDog的"name"属性更新为“Happy Coder”。
+ - text: 更新myDog的"name"属性, 使其等于 "Happy Coder"。
testString: assert(/happy coder/gi.test(myDog.name));
- - text: 不要编辑myDog定义
+ - text: 不要修改myDog的定义。
testString: 'assert(/"name": "Coder"/.test(code));'
```
@@ -52,6 +72,7 @@ var myDog = {
// Only change code below this line.
+
```
@@ -61,7 +82,7 @@ var myDog = {
Bracket notation是一种在字符串中的特定index处获取字符的方法。大多数现代编程语言，如JavaScript，都不像人类那样开始计算。它们从0开始。这称为基于零的索引。例如，单词“Charles”中索引0处的字符是“C”。因此，如果var firstName = "Charles" ，则可以使用firstName[0]获取字符串第一个字母的值。 index（索引）处获取字符的方法。
+大多数现代编程语言，如JavaScript，不同于人类从 1 开始计数。它们是从 0 开始计数，这被称为 基于零 的索引。
+例如, 在单词 "Charles" 中索引 0 上的字符为 "C"，所以在var firstName = "Charles"中，你可以使用firstName[0]来获得第一个位置上的字符。
+lastName变量中的第一个字符并将其分配给firstLetterOfLastName 。 暗示 firstLetterOfFirstName变量声明。 lastName中的第一个字符，并赋给变量firstLetterOfLastName。
+提示firstLetterOfFirstName是如何赋值的。
+firstLetterOfLastName变量的值应为L
+ - text: firstLetterOfLastName的值应该是L。
testString: assert(firstLetterOfLastName === 'L');
- - text: 您应该使用括号表示法。
+ - text: 你应该使用中括号。
testString: assert(code.match(/firstLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
```
@@ -45,6 +53,7 @@ var lastName = "Lovelace";
// Only change code below this line
firstLetterOfLastName = lastName;
+
```
@@ -54,7 +63,7 @@ firstLetterOfLastName = lastName;
var firstName = "Charles" ，则可以使用firstName[firstName.length - 1]获取字符串最后一个字母的值。 var firstName = "Charles"中，你可以这样操作firstName[firstName.length - 1]来得到字符串的最后的一个字符。
+lastName变量中的最后一个字符。 暗示 lastLetterOfFirstName变量声明。 lastLetterOfFirstName变量上是怎么做的。
+lastLetterOfLastName应为“e”。
+ - text: lastLetterOfLastName应该是"e"。
testString: assert(lastLetterOfLastName === "e");
- - text: 你必须使用.length来获取最后一个字母。
+ - text: 你需要使用.length获取最后一个字符。
testString: assert(code.match(/\.length/g).length === 2);
```
@@ -42,6 +49,7 @@ var lastName = "Lovelace";
// Only change code below this line.
var lastLetterOfLastName = lastName;
+
```
@@ -51,7 +59,7 @@ var lastLetterOfLastName = lastName;
0开始计数，因此第一个字符实际上是第0个字符。 0开始计数，所以获取第一个字符实际上是[0]。
+thirdLetterOfLastName设置为等于lastName变量的第三个字母。 暗示 secondLetterOfFirstName变量声明。 lastName变量的第三个字符赋值给thirdLetterOfLastName。
+提示secondLetterOfFirstName变量是如何做的。
+thirdLetterOfLastName变量的值应为v 。
+ - text: thirdLetterOfLastName的值应该是v。
testString: assert(thirdLetterOfLastName === 'v');
- - text: 您应该使用括号表示法。
+ - text: 你应该使用方括号。
testString: assert(code.match(/thirdLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
```
@@ -42,6 +49,7 @@ var lastName = "Lovelace";
// Only change code below this line.
var thirdLetterOfLastName = lastName;
+
```
@@ -51,7 +59,7 @@ var thirdLetterOfLastName = lastName;
firstName[firstName.length - 3]获取var firstName = "Charles"字符串的倒数第三个字母的值firstName[firstName.length - 3]操作来获得var firstName = "Charles"字符串中的倒数第三个字符。
+lastName字符串中倒数第二个字符。 暗示 thirdToLastLetterOfFirstName变量声明。 lastName字符串中的倒数第二个字符。
+提示thirdToLastLetterOfFirstName变量是如何做到的。
+secondToLastLetterOfLastName应为“c”。
+ - text: secondToLastLetterOfLastName应该是"c"。
testString: assert(secondToLastLetterOfLastName === 'c');
- - text: 你必须使用.length来获得倒数第二个字母。
+ - text: 你需要使用.length获取倒数第二个字符。
testString: assert(code.match(/\.length/g).length === 2);
```
@@ -42,6 +49,7 @@ var lastName = "Lovelace";
// Only change code below this line
var secondToLastLetterOfLastName = lastName;
+
```
@@ -51,7 +59,7 @@ var secondToLastLetterOfLastName = lastName;
If语句用于在代码中做出决定。关键字if告诉JavaScript在括号中定义的特定条件下执行花括号中的代码。这些条件称为Boolean条件，它们可能只是true或false 。当条件计算结果为true ，程序将执行花括号内的语句。当布尔条件的计算结果为false ，大括号内的语句将不会执行。 伪代码 if（ condition为true ）{例
声明被执行
}
功能测试（myCondition）{当使用值
if（myCondition）{
回归“这是真的”;
}
返回“这是假的”;
}
测试（真）; //返回“这是真的”
测试（假）; //返回“这是假的”
true调用test ， if语句将评估myCondition以查看它是否为true 。因为它是true ，函数返回"It was true" 。当我们使用false值调用test时， myCondition 不为 true并且不执行花括号中的语句，函数返回"It was false" 。 If语句用于在代码中做条件判断。关键字if告诉 JavaScript 在小括号中的条件为真的情况下去执行定义在大括号里面的代码。这种条件被称为Boolean条件，因为他们只可能是true（真）或false（假）。
+当条件的计算结果为true，程序执行大括号内的语句。当布尔条件的计算结果为false，大括号内的代码将不会执行。
+伪代码
+if(条件为真){+示例 + +```js +function test (myCondition) { + if (myCondition) { + return "It was true"; + } + return "It was false"; +} +test(true); // returns "It was true" +test(false); // returns "It was false" +``` + +当
语句被执行
}
test被调用，并且传递进来的参数值为true，if语句会计算myCondition的结果，看它是真还是假。如果条件为true，函数会返回"It was true"。当test被调用，并且传递进来的参数值为false，myCondition不 为true，并且不执行大括号后面的语句，函数返回"It was false"。
+if语句"Yes, that was true"如果参数wasThatTrue为true则返回"Yes, that was true" "No, that was false"否则返回"No, that was false" 。 if语句，如果该参数wasThatTrue值为true，返回"Yes, that was true"，否则，并返回"No, that was false"。
+trueOrFalse应该是一个函数
+ - text: trueOrFalse应该是一个函数。
testString: assert(typeof trueOrFalse === "function");
- - text: trueOrFalse(true)应该返回一个字符串
+ - text: trueOrFalse(true)应该返回一个字符串。
testString: assert(typeof trueOrFalse(true) === "string");
- - text: trueOrFalse(false)应该返回一个字符串
+ - text: trueOrFalse(false)应该返回一个字符串。
testString: assert(typeof trueOrFalse(false) === "string");
- - text: trueOrFalse(true)应该返回“是的，那是真的”
+ - text: trueOrFalse(true)应该返回 "Yes, that was true"。
testString: assert(trueOrFalse(true) === "Yes, that was true");
- - text: trueOrFalse(false)应该返回“No，that was false”
+ - text: trueOrFalse(false)应该返回 "No, that was false"。
testString: assert(trueOrFalse(false) === "No, that was false");
```
@@ -59,7 +81,6 @@ function trueOrFalse(wasThatTrue) {
// Change this value to test
trueOrFalse(true);
-
```
@@ -71,7 +92,14 @@ trueOrFalse(true);
## Solution
conditional operator 。您也可以将它们链接在一起以检查多种条件。以下函数使用if，else if和else语句来检查多个条件： function findGreaterOrEqual（a，b）{可以使用多个
if（a === b）{
返回“a和b相等”;
}
否则如果（a> b）{
返回“a更大”;
}
其他{
返回“b更大”;
}
}
conditional operators重写上述函数： function findGreaterOrEqual（a，b）{
返回（a === b）？ “a和b相等”：（a> b）？ “a更大”：“b更大”;
}
checkSign函数中使用多个conditional operators来检查数字是正数，负数还是零。 checkSign应该使用多个conditional operators
- testString: assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?\s*?\?\s*?.+?\s*?:\s*?.+?/gi.test(code));
- - text: checkSign(10)应该返回“positive”。请注意，资本化很重要
+ - text: checkSign应该使用多个条件运算符。
+ testString: 'assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?\s*?\?\s*?.+?\s*?:\s*?.+?/gi.test(code));'
+ - text: checkSign(10)应该返回 "positive" 注意，结果对大小写敏感。
testString: assert(checkSign(10) === 'positive');
- - text: checkSign(-12)应返回“否定”。请注意，资本化很重要
+ - text: checkSign(-12)应该返回 "negative" 注意，结果对大小写敏感。
testString: assert(checkSign(-12) === 'negative');
- - text: checkSign(0)应返回“零”。请注意，资本化很重要
+ - text: checkSign(0)应该返回 "zero" 注意，结果对大小写敏感。
testString: assert(checkSign(0) === 'zero');
```
@@ -41,7 +80,6 @@ function checkSign(num) {
}
checkSign(10);
-
```
@@ -54,6 +92,9 @@ checkSign(10);
1 到传递给函数的指定数字的连续数字数组。
+
+正如上一个挑战提到的，会有一个 base case。base case 告诉递归函数什么时候不在需要调用其自身。这是简单 情况，返回得到的值。还有 recursive call，继续用不同的参数调用自身。如果函数无误，一直执行直到 base case 为止。
+
+比如，如果想写一个递归函数，返回一个数字 1 到 n 的连续数组。这个函数需要接收一个参数n 代表起始数字。然后会持续的调用自身，传入一个比 n 更小的值一直到传入的值是 1 为止。函数如下：
+
+```javascript
+function countup(n) {
+ if (n < 1) {
+ return [];
+ } else {
+ const countArray = countup(n - 1);
+ countArray.push(n);
+ return countArray;
+ }
+}
+console.log(countup(5)); // [ 1, 2, 3, 4, 5 ]
+```
+
+起初，这似乎是违反直觉的，因为 n 的值递减，但是最终数组中的值却递增。 之所以发生这种情况，是因为在递归调用返回之后，才调用 push。 在将 `n` pushed 进数组时，`count(n - 1)` 已经调用赋值成功并返回了 `[1, 2, ..., n - 1]`。
+
+countdown，函数有一个参数（n）。函数应该基于参数 n 递归调用返回 n 到 1 的连续数字的数组。如果函数以小于 1 的参数调用，函数应该返回空数组。
+比如，用 n = 5 调用函数应该返回数组 [5, 4, 3, 2, 1]。
+函数必需使用递归函数调用自身，不能使用任何形式的循环。
+
+countdown(-1) 应该返回一个空数组。
+ testString: assert.isEmpty(countdown(-1));
+ - text: countdown(10) 应该返回 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]。
+ testString: assert.deepStrictEqual(countdown(10), [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
+ - text: countdown(5) 应该返回 [5, 4, 3, 2, 1]。
+ testString: assert.deepStrictEqual(countdown(5), [5, 4, 3, 2, 1]);
+ - text: 代码不能包含任意形式的循环（for、while 或者高阶函数如：forEach、map、filter 以及 reduce）。
+ testString: assert(!removeJSComments(code).match(/for|while|forEach|map|filter|reduce/g));
+ - text: 应该用递归解决这个问题。
+ testString: assert(removeJSComments(countdown.toString()).match(/countdown\s*\(.+\)\;/));
+```
+
+rangeOfNumbers 函数，包含两个参数。函数应该返回一个连续数字数组，startNum 参数开始 endNum 参数截止。开始的数字小于或等于截止数字。函数必需递归调用自身，不能使用任意形式的循环。要考虑到 startNum 和 endNum 相同的情况。
+for 或者 while 或者高阶函数比如 forEach、map、filter 或者 reduce）。
+ testString: assert(!removeJSComments(code).match(/for|while|forEach|map|filter|reduce/g));
+ - text: rangeOfNumbers 应该使用递归函数（调用自身）来完成这个挑战。
+ testString: assert(removeJSComments(rangeOfNumbers.toString()).match(/rangeOfNumbers\s*\(.+\)/));
+ - text: rangeOfNumbers(1, 5) 应该返回 [1, 2, 3, 4, 5]。
+ testString: assert.deepStrictEqual(rangeOfNumbers(1, 5), [1, 2, 3, 4, 5]);
+ - text: rangeOfNumbers(6, 9) 应该返回 [6, 7, 8, 9]。
+ testString: assert.deepStrictEqual(rangeOfNumbers(6, 9), [6, 7, 8, 9]);
+ - text: rangeOfNumbers(4, 4) 应该返回 [4]。
+ testString: assert.deepStrictEqual(rangeOfNumbers(4, 4), [4]);
+```
+
+condition ? statement-if-true : statement-if-false;以下函数使用if-else语句来检查条件： function findGreater（a，b）{这可以使用
if（a> b）{
返回“a更大”;
}
其他{
返回“b更大”;
}
}
conditional operator重写： function findGreater（a，b）{
返回a> b？ “a更大”：“b更大”;
}
condition ? statement-if-true : statement-if-false;
+以下函数使用 if-else 语句来检查条件：
+
+```js
+function findGreater(a, b) {
+ if(a > b) {
+ return "a is greater";
+ }
+ else {
+ return "b is greater";
+ }
+}
+```
+
+上面的函数使用条件运算符写法如下：
+
+```js
+function findGreater(a, b) {
+ return a > b ? "a is greater" : "b is greater";
+}
+```
+
+checkEqual函数中使用conditional operator来检查两个数字是否相等。该函数应返回true或false。 checkEqual函数中使用条件运算符检查两个数字是否相等，函数应该返回 "Equal" 或 "Not Equal"
+checkEqual应该使用conditional operator
+ - text: checkEqual应该使用条件运算符。
testString: assert(/.+?\s*?\?\s*?.+?\s*?:\s*?.+?/.test(code));
- - text: 'checkEqual(1, 2)应该返回false'
+ - text: checkEqual(1, 2)应该返回 "Not Equal"。
testString: assert(checkEqual(1, 2) === "Not Equal");
- - text: 'checkEqual(1, 1)应该返回true'
+ - text: checkEqual(1, 1)应该返回 "Equal"。
testString: assert(checkEqual(1, 1) === "Equal");
- - text: 'checkEqual(1, -1)应该返回false'
+ - text: checkEqual(1, -1)应该返回 "Not Equal"。
testString: assert(checkEqual(1, -1) === "Not Equal");
-
```
parseInt()函数解析字符串并返回一个整数。它需要一个基数的第二个参数，它指定字符串中数字的基数。基数可以是2到36之间的整数。函数调用如下： parseInt(string, radix);这是一个例子： var a = parseInt("11", 2);基数变量表示“11”在二进制系统或基数2中。此示例将字符串“11”转换为整数3。 parseInt()函数解析一个字符串并返回一个整数。它同时可接受第二个参数，一个介于2和36之间的整数，表示字符串的基数。
+函数调用如下所示：
+parseInt(string, radix);
+示例：
+var a = parseInt("11", 2);
+参数 2 表示 "11" 使用二进制数值系统。此示例将字符串 "11" 转换为整数 3。
+convertToInteger函数中使用parseInt() ，以便将二进制数转换为整数并返回它。 convertToIntegerparseInt()函数把二进制数转换成十进制并返回。
+convertToInteger应该使用parseInt()函数
+ - text: convertToInteger中应该使用parseInt()函数。
testString: assert(/parseInt/g.test(code));
- - text: convertToInteger("10011")应该返回一个数字
+ - text: convertToInteger("10011")应该返回一个数字。
testString: assert(typeof(convertToInteger("10011")) === "number");
- - text: convertToInteger("10011")应该返回19
+ - text: convertToInteger("10011")应该返回 19。
testString: assert(convertToInteger("10011") === 19);
- - text: convertToInteger("111001")应该返回57
+ - text: convertToInteger("111001")应该返回 57。
testString: assert(convertToInteger("111001") === 57);
- - text: convertToInteger("JamesBond")应该返回NaN
+ - text: convertToInteger("JamesBond")应该返回 NaN。
testString: assert.isNaN(convertToInteger("JamesBond"));
```
@@ -43,7 +53,6 @@ function convertToInteger(str) {
}
convertToInteger("10011");
-
```
@@ -56,6 +65,9 @@ convertToInteger("10011");
parseInt()函数解析字符串并返回一个整数。这是一个例子： var a = parseInt("007");上面的函数将字符串“007”转换为整数7.如果字符串中的第一个字符无法转换为数字，则返回NaN 。 parseInt()函数解析一个字符串返回一个整数下面是一个示例：
+var a = parseInt("007");
+上面的函数把字符串 "007" 转换成数字 7。 如果字符串参数的第一个字符是字符串类型的，结果将不会转换成数字，而是返回NaN.
+convertToInteger函数中使用parseInt() ，以便将输入字符串str转换为整数，然后返回它。 convertToInteger函数中使用parseInt()将字符串str转换为正数并返回。
+convertToInteger应该使用parseInt()函数
+ - text: convertToInteger应该使用parseInt()函数。
testString: assert(/parseInt/g.test(code));
- - text: convertToInteger("56")应该返回一个数字
+ - text: convertToInteger("56")应该返回一个数字。
testString: assert(typeof(convertToInteger("56")) === "number");
- - text: convertToInteger("56")应该返回56
+ - text: convertToInteger("56")应该返回 56。
testString: assert(convertToInteger("56") === 56);
- - text: convertToInteger("77")应该返回77
+ - text: convertToInteger("77")应该返回 77。
testString: assert(convertToInteger("77") === 77);
- - text: convertToInteger("JamesBond")应该返回NaN
+ - text: convertToInteger("JamesBond")应该返回 NaN。
testString: assert.isNaN(convertToInteger("JamesBond"));
```
@@ -43,7 +50,6 @@ function convertToInteger(str) {
}
convertToInteger("56");
-
```
@@ -56,6 +62,9 @@ convertToInteger("56");
switch语句或if/else链。当您知道输入数据限制在特定范围内时，这非常有用。以下是简单反向字母查找的示例： var alpha = {
1： “Z”，
2： “Y”，
3： “X”，
4： “W”，
...
24： “C”，
25： “B”，
26： “A”
};
阿尔法[2]; //“Y”
阿尔法[24]; // “C”
var value = 2;
阿尔法[值]。 //“Y”
lookup的对象。使用它来查找val并将关联的字符串分配给result变量。 lookup对象。使用它来查找val属性的值，并赋值给result变量。
+phoneticLookup("alpha")应该等于"Adams"
+ - text: phoneticLookup("alpha")应该等于"Adams"。
testString: assert(phoneticLookup("alpha") === 'Adams');
- - text: phoneticLookup("bravo")应该等于"Boston"
+ - text: phoneticLookup("bravo")应该等于"Boston"。
testString: assert(phoneticLookup("bravo") === 'Boston');
- - text: phoneticLookup("charlie")应该等于"Chicago"
+ - text: phoneticLookup("charlie")应该等于"Chicago"。
testString: assert(phoneticLookup("charlie") === 'Chicago');
- - text: phoneticLookup("delta")应该等于"Denver"
+ - text: phoneticLookup("delta")应该等于"Denver"。
testString: assert(phoneticLookup("delta") === 'Denver');
- - text: phoneticLookup("echo")应该等于"Easy"
+ - text: phoneticLookup("echo")应该等于"Easy"。
testString: assert(phoneticLookup("echo") === 'Easy');
- - text: phoneticLookup("foxtrot")应该等于"Frank"
+ - text: phoneticLookup("foxtrot")应该等于"Frank"。
testString: assert(phoneticLookup("foxtrot") === 'Frank');
- - text: phoneticLookup("")应该等于undefined
+ - text: phoneticLookup("")应该等于undefined。
testString: assert(typeof phoneticLookup("") === 'undefined');
- - text: 您不应该修改return语句
+ - text: 请不要修改return语句。
testString: assert(code.match(/return\sresult;/));
- - text: 您不应该使用case ， switch或if语句
+ - text: 请不要使用case，switch，或if语句。
testString: assert(!/case|switch|if/g.test(code.replace(/([/]{2}.*)|([/][*][^/*]*[*][/])/g,'')));
```
@@ -77,7 +102,6 @@ function phoneticLookup(val) {
// Change this value to test
phoneticLookup("charlie");
-
```
@@ -89,7 +113,24 @@ phoneticLookup("charlie");
## Solution
var sentence =“它真的是”+“热”+“，我们”+“笑”+“自己”+“傻。”;
+来使用提供的变量构建新字符串： myNoun ， myAdjective ， myVerb和myAdverb 。然后，您将形成的字符串分配给result变量。您还需要考虑字符串中的空格，以便最后一句话在所有单词之间有空格。结果应该是一个完整的句子。 +来拼接字符串变量：myNoun，myAdjective，myVerb，和myAdverb来构建一个新字符串。然后，将新字符串赋给result变量。
+你还需要考虑字符串中的空格，确保句子的所有单词之间有空格。结果应该是一个完整的句子。
+wordBlanks("","","","")应该返回一个字符串。'
- testString: assert(typeof wordBlanks("","","","") === "string");
- - text: 'wordBlanks("dog", "big", "ran", "quickly")应包含由非单词字符（以及madlib中的任何其他单词）分隔的所有传入单词。'
- testString: assert(/\bdog\b/.test(test1) && /\bbig\b/.test(test1) && /\bran\b/.test(test1) && /\bquickly\b/.test(test1));
- - text: 'wordBlanks("cat", "little", "hit", "slowly")应包含由非单词字符（以及madlib中的任何其他单词）分隔的所有传入单词。'
- testString: assert(/\bcat\b/.test(test2) && /\blittle\b/.test(test2) && /\bhit\b/.test(test2) && /\bslowly\b/.test(test2));
+ - text: wordBlanks("","","","")应该返回一个字符串。
+ testString: assert(typeof wordBlanks === 'string');
+ - text: 不能改变 myNoun、myVerb、myAdjective 或者 myAdverb 的值。
+ testString: assert(myNoun === "dog" && myVerb === "ran" && myAdjective === "big" && myAdverb === "quickly");
+ - text: 不能直接使用 "dog"、"ran"、"big" 或者 "quickly" 来创建 wordBlanks。
+ testString: const newCode = removeAssignments(code); assert(!/dog/.test(newCode) && !/ran/.test(newCode) && !/big/.test(newCode) && !/quickly/.test(newCode));
+ - text: wordBlanks 应包含分配给变量 myNoun、myVerb、myAdjective 和 myAdverb 的所有单词，并用非单词字符（以及 madlib 中的其它单词）分隔。
+ testString: assert(/\bdog\b/.test(wordBlanks) && /\bbig\b/.test(wordBlanks) && /\bran\b/.test(wordBlanks) && /\bquickly\b/.test(wordBlanks));
```
@@ -34,27 +50,25 @@ tests:
function functionName（）{您可以使用其名称后跟括号来调用或调用此函数，如下所示：
console.log（“Hello World”）;
}
functionName();每次调用该函数时，它都会在开发控制台上打印出"Hello World"消息。每次调用函数时，都会执行大括号之间的所有代码。 functionName加上后面的小括号来调用这个函数，就像这样：
+functionName();
+每次调用函数时，它都会在控制台上打印消息"Hello World"。每次调用函数时，大括号之间的所有代码都将被执行。
+reusableFunction的函数，它将"Hi World"打印到开发控制台。 reusableFunction的函数，这个函数可以打印"Hi World"到控制台上。reusableFunction应该是一个函数
+ - text: reusableFunction应该是一个函数。
testString: assert(typeof reusableFunction === 'function');
- - text: reusableFunction应该将“Hi World”输出到开发控制台
+ - text: reusableFunction应该在控制台中输出 "Hi World"。
testString: assert(hiWorldWasLogged);
- - text: 定义后调用reusableFunction
+ - text: 在你定义reusableFunction之后记得调用它。
testString: assert(/^\s*reusableFunction\(\)\s*/m.test(code));
```
@@ -52,10 +68,12 @@ ourReusableFunction();
```js
var logOutput = "";
-var originalConsole = console
+var originalConsole = console;
+var nativeLog = console.log;
+var hiWorldWasLogged = false;
function capture() {
- var nativeLog = console.log;
console.log = function (message) {
+ if(message === 'Hi World') hiWorldWasLogged = true;
if(message && message.trim) logOutput = message.trim();
if(nativeLog.apply) {
nativeLog.apply(originalConsole, arguments);
@@ -67,11 +85,10 @@ function capture() {
}
function uncapture() {
- console.log = originalConsole.log;
+ console.log = nativeLog;
}
capture();
-
```
@@ -80,7 +97,13 @@ capture();