chore(learn): Applied MDX format to Chinese curriculum files (#40462)

This commit is contained in:
Randell Dawson
2020-12-16 00:37:30 -07:00
committed by GitHub
parent 873fce02a2
commit 9ce4a02a41
1665 changed files with 58741 additions and 88042 deletions

View File

@ -1,18 +1,17 @@
---
id: 56bbb991ad1ed5201cd392ca
title: 通过索引访问数组中的数据
challengeType: 1
videoUrl: 'https://scrimba.com/c/cBZQbTz'
forumTopicId: 16158
title: 通过索引访问数组中的数据
---
## Description
<section id='description'>
我们可以使用索引 <code>indexes</code> 来访问数组中的数据。
# --description--
数组索引与字符串索引一样使用中括号,但字符串索引得到的是一个字符,而数组索引得到的是一个元素。数组索引与字符串索引一样是从 0 开始的,所以数组中第一个元素的索引编号是 0
<br/>
<strong>示例</strong>
我们可以使用索引 `indexes` 来访问数组中的数据
数组索引与字符串索引一样使用中括号,但字符串索引得到的是一个字符,而数组索引得到的是一个元素。数组索引与字符串索引一样是从 0 开始的,所以数组中第一个元素的索引编号是 0。
**示例**
```js
var array = [50,60,70];
@ -20,66 +19,46 @@ array[0]; // equals 50
var data = array[1]; // equals 60
```
<strong>提示</strong><br>数组名称和方括号之间不应有任何空格,如<code>array [0]</code>尽管 JavaScript 能够正确处理,但可能会让看你代码的其他程序员感到困惑
</section>
**提示**
数组名称和方括号之间不应有任何空格,如`array [0]`尽管 JavaScript 能够正确处理,但可能会让看你代码的其他程序员感到困惑
## Instructions
<section id='instructions'>
创建一个名为<code>myData</code>的变量,并把<code>myArray</code>的第一个索引上的值赋给它。
</section>
# --instructions--
## Tests
<section id='tests'>
创建一个名为`myData`的变量,并把`myArray`的第一个索引上的值赋给它。
```yml
tests:
- text: 变量<code>myData</code>的值应该等于<code>myArray</code>的第一个值。
testString: assert((function(){if(typeof myArray !== 'undefined' && typeof myData !== 'undefined' && myArray[0] === myData){return true;}else{return false;}})());
- text: 应使用方括号访问变量<code>myArray</code>中的数据。
testString: assert((function(){if(code.match(/\s*=\s*myArray\[0\]/g)){return true;}else{return false;}})());
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
变量`myData`的值应该等于`myArray`的第一个值。
```js
// Example
var ourArray = [50,60,70];
var ourData = ourArray[0]; // equals 50
// Setup
var myArray = [50,60,70];
// Only change code below this line.
assert(
(function () {
if (
typeof myArray !== 'undefined' &&
typeof myData !== 'undefined' &&
myArray[0] === myData
) {
return true;
} else {
return false;
}
})()
);
```
</div>
### After Test
<div id='js-teardown'>
应使用方括号访问变量`myArray`中的数据。
```js
if(typeof myArray !== "undefined" && typeof myData !== "undefined"){(function(y,z){return 'myArray = ' + JSON.stringify(y) + ', myData = ' + JSON.stringify(z);})(myArray, myData);}
assert(
(function () {
if (code.match(/\s*=\s*myArray\[0\]/g)) {
return true;
} else {
return false;
}
})()
);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myArray = [50,60,70];
var myData = myArray[0];
```
</section>

View File

@ -1,15 +1,16 @@
---
id: 56592a60ddddeae28f7aa8e1
title: 使用索引访问多维数组
challengeType: 1
videoUrl: 'https://scrimba.com/c/ckND4Cq'
forumTopicId: 16159
title: 使用索引访问多维数组
---
## Description
<section id='description'>
可以把 <dfn>多维</dfn> 数组看作成是一个 <em>数组中的数组</em>。当使用方括号去访问数组的时候,第一个<code>[index]</code>访问的是第 N 个子数组,第二个<code>[index]</code>访问的是第 N 个子数组的第N个元素。
<strong>示例</strong>
# --description--
可以把 <dfn>多维</dfn> 数组看作成是一个 *数组中的数组*。当使用方括号去访问数组的时候,第一个`[index]`访问的是第 N 个子数组,第二个`[index]`访问的是第 N 个子数组的第N个元素。
**示例**
```js
var arr = [
@ -23,63 +24,29 @@ arr[3][0]; // equals [10,11,12]
arr[3][0][1]; // equals 11
```
<strong>提示</strong><br>数组名称和方括号之间不应该有任何空格,如<code>array [0][0]</code>,甚至<code>array [0] [0]</code>,都是不正确的。尽管 JavaScript 能够处理,但可能会让看你代码的其他程序员感到困惑。
</section>
**提示**
数组名称和方括号之间不应该有任何空格,如`array [0][0]`,甚至`array [0][0]`,都是不正确的。尽管 JavaScript 能够处理,但可能会让看你代码的其他程序员感到困惑。
## Instructions
<section id='instructions'>
使用索引从<code>myArray</code>选择一个元素,使得<code>myData</code>的值为<code>8</code>
</section>
# --instructions--
## Tests
<section id='tests'>
使用索引从`myArray`选择一个元素,使得`myData`的值为`8`
```yml
tests:
- text: <code>myData</code>应该等于<code>8</code>。
testString: assert(myData === 8);
- text: 你应该使用方括号从<code>myArray</code>中取值。
testString: 'assert(/myArray\[2\]\[1\]/g.test(code) && !/myData\s*=\s*(?:.*[-+*/%]|\d)/g.test(code));'
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myData`应该等于`8`
```js
// Setup
var myArray = [[1,2,3], [4,5,6], [7,8,9], [[10,11,12], 13, 14]];
// Only change code below this line.
var myData = myArray[0][0];
assert(myData === 8);
```
</div>
### After Test
<div id='js-teardown'>
你应该使用方括号从`myArray`中取值。
```js
if(typeof myArray !== "undefined"){(function(){return "myData: " + myData + " myArray: " + JSON.stringify(myArray);})();}
assert(
/myArray\[2\]\[1\]/g.test(code) &&
!/myData\s*=\s*(?:.*[-+*/%]|\d)/g.test(code)
);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myArray = [[1,2,3],[4,5,6], [7,8,9], [[10,11,12], 13, 14]];
var myData = myArray[2][1];
```
</section>

View File

@ -1,14 +1,15 @@
---
id: 56533eb9ac21ba0edf2244cd
title: 访问嵌套数组
challengeType: 1
videoUrl: 'https://scrimba.com/c/cLeGDtZ'
forumTopicId: 16160
title: 访问嵌套数组
---
## Description
<section id='description'>
# --description--
正如我们在前面的例子所见,对象可以嵌套对象和数组。与访问嵌套对象一样,用中括号操作符同样可以访问嵌套数组。
下面是如何访问嵌套数组的例子:
```js
@ -34,105 +35,23 @@ ourPets[0].names[1]; // "Fluffy"
ourPets[1].names[0]; // "Spot"
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
使用点操作符和中括号操作符来检索变量<code>myPlants</code>的第二棵树。
</section>
使用点操作符和中括号操作符来检索变量`myPlants`的第二棵树。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>secondTree</code>应该等于 "pine"。
testString: assert(secondTree === "pine");
- text: 使用点操作符和中括号操作符来检索变量<code>myPlants</code>。
testString: assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`secondTree`应该等于 "pine"。
```js
// Setup
var myPlants = [
{
type: "flowers",
list: [
"rose",
"tulip",
"dandelion"
]
},
{
type: "trees",
list: [
"fir",
"pine",
"birch"
]
}
];
// Only change code below this line
var secondTree = ""; // Change this line
assert(secondTree === 'pine');
```
</div>
### After Test
<div id='js-teardown'>
使用点操作符和中括号操作符来检索变量`myPlants`
```js
(function(x) {
if(typeof x != 'undefined') {
return "secondTree = " + x;
}
return "secondTree is undefined";
})(secondTree);
assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myPlants = [
{
type: "flowers",
list: [
"rose",
"tulip",
"dandelion"
]
},
{
type: "trees",
list: [
"fir",
"pine",
"birch"
]
}
];
// Only change code below this line
var secondTree = myPlants[1].list[1];
```
</section>

View File

@ -1,14 +1,15 @@
---
id: 56533eb9ac21ba0edf2244cc
title: 访问嵌套对象
challengeType: 1
videoUrl: 'https://scrimba.com/c/cRnRnfa'
forumTopicId: 16161
title: 访问嵌套对象
---
## Description
<section id='description'>
# --description--
通过串联起来的点操作符或中括号操作符来访问对象的嵌套属性。
下面是一个嵌套的对象:
```js
@ -28,86 +29,23 @@ ourStorage.cabinet["top drawer"].folder2; // "secrets"
ourStorage.desk.drawer; // "stapler"
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
读取<code>myStorage</code>对象,将<code>glove box</code>属性的内容赋值给变量<code>gloveBoxContents</code>。在适用的地方使用点操作符来访问属性,否则使用中括号操作符。
</section>
读取`myStorage`对象,将`glove box`属性的内容赋值给变量`gloveBoxContents`。在适用的地方使用点操作符来访问属性,否则使用中括号操作符。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>gloveBoxContents</code>应该等于"maps"。
testString: assert(gloveBoxContents === "maps");
- text: 应使用点操作符和中括号操作符来访问<code>myStorage</code>。
testString: assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`gloveBoxContents`应该等于"maps"。
```js
// Setup
var myStorage = {
"car": {
"inside": {
"glove box": "maps",
"passenger seat": "crumbs"
},
"outside": {
"trunk": "jack"
}
}
};
var gloveBoxContents = undefined; // Change this line
assert(gloveBoxContents === 'maps');
```
</div>
### After Test
<div id='js-teardown'>
应使用点操作符和中括号操作符来访问`myStorage`
```js
(function(x) {
if(typeof x != 'undefined') {
return "gloveBoxContents = " + x;
}
return "gloveBoxContents is undefined";
})(gloveBoxContents);
assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myStorage = {
"car":{
"inside":{
"glove box":"maps",
"passenger seat":"crumbs"
},
"outside":{
"trunk":"jack"
}
}
};
var gloveBoxContents = myStorage.car.inside["glove box"];
```
</section>

View File

@ -1,16 +1,18 @@
---
id: 56533eb9ac21ba0edf2244c8
title: 通过方括号访问对象属性
challengeType: 1
videoUrl: 'https://scrimba.com/c/cBvmEHP'
forumTopicId: 16163
title: 通过方括号访问对象属性
---
## Description
<section id='description'>
第二种访问对象的方式就是中括号操作符(<code>[]</code>),如果你想访问的属性的名称有一个空格,这时你只能使用中括号操作符(<code>[]</code>)。
# --description--
第二种访问对象的方式就是中括号操作符(`[]`),如果你想访问的属性的名称有一个空格,这时你只能使用中括号操作符(`[]`)。
当然,如果属性名不包含空格,也可以使用中括号操作符。
这是一个使用中括号操作符(<code>[]</code>)读取对象属性的例子:
这是一个使用中括号操作符(`[]`)读取对象属性的例子:
```js
var myObj = {
@ -24,78 +26,42 @@ myObj["NoSpace"]; // USS Enterprise
```
提示:属性名称中如果有空格,必须把属性名称用单引号或双引号包裹起来。
</section>
## Instructions
<section id='instructions'>
用中括号操作符读取对象<code>testObj</code><code>an entree</code>属性值和<code>the drink</code>属性值,并分别赋值给<code>entreeValue</code><code>drinkValue</code>
</section>
# --instructions--
## Tests
<section id='tests'>
用中括号操作符读取对象`testObj``an entree`属性值和`the drink`属性值,并分别赋值给`entreeValue``drinkValue`
```yml
tests:
- text: <code>entreeValue</code>应该是一个字符串。
testString: assert(typeof entreeValue === 'string' );
- text: <code>entreeValue</code>的值应该是<code>"hamburger"</code>。
testString: assert(entreeValue === 'hamburger' );
- text: <code>drinkValue</code>应该是一个字符串。
testString: assert(typeof drinkValue === 'string' );
- text: <code>drinkValue</code>的值应该是<code>"water"</code>。
testString: assert(drinkValue === 'water' );
- text: 你应该使用中括号两次。
testString: assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`entreeValue`应该是一个字符串。
```js
// Setup
var testObj = {
"an entree": "hamburger",
"my side": "veggies",
"the drink": "water"
};
// Only change code below this line
var entreeValue = testObj; // Change this line
var drinkValue = testObj; // Change this line
assert(typeof entreeValue === 'string');
```
</div>
### After Test
<div id='js-teardown'>
`entreeValue`的值应该是`"hamburger"`
```js
(function(a,b) { return "entreeValue = '" + a + "', drinkValue = '" + b + "'"; })(entreeValue,drinkValue);
assert(entreeValue === 'hamburger');
```
</div>
</section>
## Solution
<section id='solution'>
`drinkValue`应该是一个字符串。
```js
var testObj = {
"an entree": "hamburger",
"my side": "veggies",
"the drink": "water"
};
var entreeValue = testObj["an entree"];
var drinkValue = testObj['the drink'];
assert(typeof drinkValue === 'string');
```
</section>
`drinkValue`的值应该是`"water"`
```js
assert(drinkValue === 'water');
```
你应该使用中括号两次。
```js
assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
```
# --solutions--

View File

@ -1,15 +1,17 @@
---
id: 56533eb9ac21ba0edf2244c7
title: 通过点符号访问对象属性
challengeType: 1
videoUrl: 'https://scrimba.com/c/cGryJs8'
forumTopicId: 16164
title: 通过点符号访问对象属性
---
## Description
<section id='description'>
有两种方式访问对象属性,一个是点操作符(<code>.</code>),一个是中括号操作符(<code>[]</code>)。
# --description--
有两种方式访问对象属性,一个是点操作符(`.`),一个是中括号操作符(`[]`)。
当你知道所要读取的属性的名称的时候,使用点操作符。
这是一个使用点操作符读取对象属性的例子:
```js
@ -21,79 +23,41 @@ var prop1val = myObj.prop1; // val1
var prop2val = myObj.prop2; // val2
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
通过点操作符读取对象<code>testObj</code>,把<code>hat</code>的属性值赋给变量<code>hatValue</code>,把<code>shirt</code>的属性值赋给<code>shirtValue</code>
</section>
通过点操作符读取对象`testObj`,把`hat`的属性值赋给变量`hatValue`,把`shirt`的属性值赋给`shirtValue`
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>hatValue</code>应该是一个字符串。
testString: assert(typeof hatValue === 'string' );
- text: <code>hatValue</code>的值应该是<code>"ballcap"</code>。
testString: assert(hatValue === 'ballcap' );
- text: <code>shirtValue</code>应该是一个字符串。
testString: assert(typeof shirtValue === 'string' );
- text: <code>shirtValue</code>的值应该是<code>"jersey"</code>。
testString: assert(shirtValue === 'jersey' );
- text: 你应该使用点操作符两次。
testString: assert(code.match(/testObj\.\w+/g).length > 1);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`hatValue`应该是一个字符串。
```js
// Setup
var testObj = {
"hat": "ballcap",
"shirt": "jersey",
"shoes": "cleats"
};
// Only change code below this line
var hatValue = testObj; // Change this line
var shirtValue = testObj; // Change this line
assert(typeof hatValue === 'string');
```
</div>
### After Test
<div id='js-teardown'>
`hatValue`的值应该是`"ballcap"`
```js
(function(a,b) { return "hatValue = '" + a + "', shirtValue = '" + b + "'"; })(hatValue,shirtValue);
assert(hatValue === 'ballcap');
```
</div>
</section>
## Solution
<section id='solution'>
`shirtValue`应该是一个字符串。
```js
var testObj = {
"hat": "ballcap",
"shirt": "jersey",
"shoes": "cleats"
};
var hatValue = testObj.hat;
var shirtValue = testObj.shirt;
assert(typeof shirtValue === 'string');
```
</section>
`shirtValue`的值应该是`"jersey"`
```js
assert(shirtValue === 'jersey');
```
你应该使用点操作符两次。
```js
assert(code.match(/testObj\.\w+/g).length > 1);
```
# --solutions--

View File

@ -1,14 +1,15 @@
---
id: 56533eb9ac21ba0edf2244c9
title: 通过变量访问对象属性
challengeType: 1
videoUrl: 'https://scrimba.com/c/cnQyKur'
forumTopicId: 16165
title: 通过变量访问对象属性
---
## Description
<section id='description'>
# --description--
中括号操作符的另一个使用方式是访问赋值给变量的属性。当你需要遍历对象的属性列表或访问查找表lookup tables这种方式极为有用。
这有一个使用变量来访问属性的例子:
```js
@ -35,80 +36,48 @@ console.log(someObj[someProp]); // "John"
```
提示:当我们通过变量名访问属性的时候,不需要给变量名包裹引号。因为实际上我们使用的是变量的值,而不是变量的名称。
</section>
## Instructions
<section id='instructions'>
使用变量<code>playerNumber</code>,通过中括号操作符找到<code>testObj</code><code>playerNumber</code><code>16</code>的值。然后把名字赋给变量<code>player</code>
</section>
# --instructions--
## Tests
<section id='tests'>
使用变量`playerNumber`,通过中括号操作符找到`testObj``playerNumber``16`的值。然后把名字赋给变量`player`
```yml
tests:
- text: <code>playerNumber</code>应该是一个数字。
testString: assert(typeof playerNumber === 'number');
- text: 变量<code>player</code>应该是一个字符串。
testString: assert(typeof player === 'string');
- text: <code>player</code>点值应该是 "Montana"。
testString: assert(player === 'Montana');
- text: 你应该使用中括号访问<code>testObj</code>。
testString: assert(/testObj\s*?\[.*?\]/.test(code));
- text: 你不应该直接将<code>Montana</code>赋给<code>player</code>。
testString: assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
- text: 你应该在中括号中使用<code>playerNumber</code>变量。
testString: assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`playerNumber`应该是一个数字。
```js
// Setup
var testObj = {
12: "Namath",
16: "Montana",
19: "Unitas"
};
// Only change code below this line;
var playerNumber; // Change this Line
var player = testObj; // Change this Line
assert(typeof playerNumber === 'number');
```
</div>
### After Test
<div id='js-teardown'>
变量`player`应该是一个字符串。
```js
if(typeof player !== "undefined"){(function(v){return v;})(player);}
assert(typeof player === 'string');
```
</div>
</section>
## Solution
<section id='solution'>
`player`点值应该是 "Montana"。
```js
var testObj = {
12: "Namath",
16: "Montana",
19: "Unitas"
};
var playerNumber = 16;
var player = testObj[playerNumber];
assert(player === 'Montana');
```
</section>
你应该使用中括号访问`testObj`
```js
assert(/testObj\s*?\[.*?\]/.test(code));
```
你不应该直接将`Montana`赋给`player`
```js
assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
```
你应该在中括号中使用`playerNumber`变量。
```js
assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));
```
# --solutions--

View File

@ -1,94 +1,42 @@
---
id: 56bbb991ad1ed5201cd392d2
title: 给对象添加新属性
challengeType: 1
videoUrl: 'https://scrimba.com/c/cQe38UD'
forumTopicId: 301169
title: 给对象添加新属性
---
## Description
<section id='description'>
# --description--
你也可以像更改属性一样给对象添加属性。
看看我们是如何给<code>ourDog</code>添加<code>"bark"</code>属性:
<code>ourDog.bark = "bow-wow";</code>
看看我们是如何给`ourDog`添加`"bark"`属性:
`ourDog.bark = "bow-wow";`
或者
<code>ourDog["bark"] = "bow-wow";</code>
现在当我们访问<code>ourDog.bark</code>时会得到 ourDog 的 bark 值 "bow-wow".
</section>
## Instructions
<section id='instructions'>
<code>myDog</code>添加一个<code>"bark"</code>属性,设置它的值为狗的声音,例如:"woof"。你可以使用点或中括号操作符。
</section>
`ourDog["bark"] = "bow-wow";`
## Tests
<section id='tests'>
现在当我们访问`ourDog.bark`时会得到 ourDog 的 bark 值 "bow-wow".
```yml
tests:
- text: 给<code>myDog</code>添加<code>"bark"</code>属性。
testString: assert(myDog.bark !== undefined);
- text: 不能在初始化 myDog 的时候添加<code>"bark"</code>属性。
testString: 'assert(!/bark[^\n]:/.test(code));'
# --instructions--
```
`myDog`添加一个`"bark"`属性,设置它的值为狗的声音,例如:"woof"。你可以使用点或中括号操作符。
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myDog`添加`"bark"`属性。
```js
// Example
var ourDog = {
"name": "Camper",
"legs": 4,
"tails": 1,
"friends": ["everything!"]
};
ourDog.bark = "bow-wow";
// Setup
var myDog = {
"name": "Happy Coder",
"legs": 4,
"tails": 1,
"friends": ["freeCodeCamp Campers"]
};
// Only change code below this line.
assert(myDog.bark !== undefined);
```
</div>
### After Test
<div id='js-teardown'>
不能在初始化 myDog 的时候添加`"bark"`属性。
```js
(function(z){return z;})(myDog);
assert(!/bark[^\n]:/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myDog = {
"name": "Happy Coder",
"legs": 4,
"tails": 1,
"friends": ["freeCodeCamp Campers"]
};
myDog.bark = "Woof Woof";
```
</section>

View File

@ -1,73 +1,42 @@
---
id: cf1111c1c11feddfaeb3bdef
title: 加法运算
challengeType: 1
videoUrl: 'https://scrimba.com/c/cM2KBAG'
forumTopicId: 16650
title: 加法运算
---
## Description
<section id='description'>
<code>Number</code>是 JavaScript 中的一种数据类型,表示数值。
# --description--
`Number`是 JavaScript 中的一种数据类型,表示数值。
现在让我们来尝试在 JavaScript 中做加法运算。
JavaScript 中使用<code>+</code>号进行加法运算。
<strong>示例</strong>
JavaScript 中使用`+`号进行加法运算。
**示例**
```js
myVar = 5 + 10; // assigned 15
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
改变数字<code>0</code>让变量 sum 的值为<code>20</code>
</section>
改变数字`0`让变量 sum 的值为`20`
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>sum</code>应该等于<code>20</code>。
testString: assert(sum === 20);
- text: 要使用<code>+</code>运算符。
testString: assert(/\+/.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`sum`应该等于`20`
```js
var sum = 10 + 0;
assert(sum === 20);
```
</div>
### After Test
<div id='js-teardown'>
要使用`+`运算符。
```js
(function(z){return 'sum = '+z;})(sum);
assert(/\+/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var sum = 10 + 10;
```
</section>

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244de
title: 在 Switch 语句中添加默认选项
challengeType: 1
videoUrl: 'https://scrimba.com/c/c3JvVfg'
forumTopicId: 16653
title: 在 Switch 语句中添加默认选项
---
## Description
<section id='description'>
<code>switch</code>语句中你可能无法用 case 来指定所有情况,这时你可以添加 default 语句。当再也找不到 case 匹配的时候 default 语句会执行,非常类似于 if/else 组合中的 else 语句。
<code>default</code>语句应该是最后一个 case。
# --description--
`switch`语句中你可能无法用 case 来指定所有情况,这时你可以添加 default 语句。当再也找不到 case 匹配的时候 default 语句会执行,非常类似于 if/else 组合中的 else 语句。
`default`语句应该是最后一个 case。
```js
switch (num) {
@ -26,89 +27,63 @@ switch (num) {
}
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
写一个 switch 语句,根据下面的条件来设置<code>answer</code>的switch语句<br><code>"a"</code> - "apple"<br><code>"b"</code> - "bird"<br><code>"c"</code> - "cat"<br><code>default</code> - "stuff"
</section>
写一个 switch 语句,根据下面的条件来设置`answer`的switch语句
`"a"` - "apple"
`"b"` - "bird"
`"c"` - "cat"
`default` - "stuff"
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>switchOfStuff("a")</code>应该有一个值为 "apple"。
testString: assert(switchOfStuff("a") === "apple");
- text: <code>switchOfStuff("b")</code>应该有一个值为 "bird"。
testString: assert(switchOfStuff("b") === "bird");
- text: <code>switchOfStuff("c")</code>应该有一个值为 "cat"。
testString: assert(switchOfStuff("c") === "cat");
- text: <code>switchOfStuff("d")</code>应该有一个值为 "stuff"。
testString: assert(switchOfStuff("d") === "stuff");
- text: <code>switchOfStuff(4)</code>应该有一个值为 "stuff"。
testString: assert(switchOfStuff(4) === "stuff");
- text: 不能使用任何<code>if</code>或<code>else</code>表达式。
testString: assert(!/else/g.test(code) || !/if/g.test(code));
- text: 你应该有一个<code>default</code>表达式。
testString: assert(switchOfStuff("string-to-trigger-default-case") === "stuff");
- text: 你应该有至少 3 个<code>break</code>表达式。
testString: assert(code.match(/break/g).length > 2);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`switchOfStuff("a")`应该有一个值为 "apple"。
```js
function switchOfStuff(val) {
var answer = "";
// Only change code below this line
// Only change code above this line
return answer;
}
// Change this value to test
switchOfStuff(1);
assert(switchOfStuff('a') === 'apple');
```
</div>
</section>
## Solution
<section id='solution'>
`switchOfStuff("b")`应该有一个值为 "bird"。
```js
function switchOfStuff(val) {
var answer = "";
switch(val) {
case "a":
answer = "apple";
break;
case "b":
answer = "bird";
break;
case "c":
answer = "cat";
break;
default:
answer = "stuff";
}
return answer;
}
assert(switchOfStuff('b') === 'bird');
```
</section>
`switchOfStuff("c")`应该有一个值为 "cat"。
```js
assert(switchOfStuff('c') === 'cat');
```
`switchOfStuff("d")`应该有一个值为 "stuff"。
```js
assert(switchOfStuff('d') === 'stuff');
```
`switchOfStuff(4)`应该有一个值为 "stuff"。
```js
assert(switchOfStuff(4) === 'stuff');
```
不能使用任何`if``else`表达式。
```js
assert(!/else/g.test(code) || !/if/g.test(code));
```
你应该有一个`default`表达式。
```js
assert(switchOfStuff('string-to-trigger-default-case') === 'stuff');
```
你应该有至少 3 个`break`表达式。
```js
assert(code.match(/break/g).length > 2);
```
# --solutions--

View File

@ -1,92 +1,32 @@
---
id: 56533eb9ac21ba0edf2244ed
title: 将变量附加到字符串
challengeType: 1
videoUrl: 'https://scrimba.com/c/cbQmZfa'
forumTopicId: 16656
title: 将变量附加到字符串
---
## Description
<section id='description'>
我们不仅可以创建出多行的字符串,还可以使用加等号(<code>+=</code>)运算符来将变量追加到字符串。
</section>
# --description--
## Instructions
<section id='instructions'>
设置变量<code>someAdjective</code>的值,并使用<code>+=</code>运算符把它追加到变量<code>myStr</code>上。
</section>
我们不仅可以创建出多行的字符串,还可以使用加等号(`+=`)运算符来将变量追加到字符串。
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: <code>someAdjective</code>应该是一个至少包含三个字符的字符串。
testString: assert(typeof someAdjective !== 'undefined' && someAdjective.length > 2);
- text: 使用<code>+=</code>操作符把<code>someAdjective</code>追加到<code>myStr</code>的后面。
testString: assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
设置变量`someAdjective`的值,并使用`+=`运算符把它追加到变量`myStr`上。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`someAdjective`应该是一个至少包含三个字符的字符串。
```js
// Example
var anAdjective = "awesome!";
var ourStr = "freeCodeCamp is ";
ourStr += anAdjective;
// Only change code below this line
var someAdjective;
var myStr = "Learning to code is ";
assert(typeof someAdjective !== 'undefined' && someAdjective.length > 2);
```
</div>
### After Test
<div id='js-teardown'>
使用`+=`操作符把`someAdjective`追加到`myStr`的后面。
```js
(function(){
var output = [];
if(typeof someAdjective === 'string') {
output.push('someAdjective = "' + someAdjective + '"');
} else {
output.push('someAdjective is not a string');
}
if(typeof myStr === 'string') {
output.push('myStr = "' + myStr + '"');
} else {
output.push('myStr is not a string');
}
return output.join('\n');
})();
assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var anAdjective = "awesome!";
var ourStr = "freeCodeCamp is ";
ourStr += anAdjective;
var someAdjective = "neat";
var myStr = "Learning to code is ";
myStr += someAdjective;
```
</section>

View File

@ -0,0 +1,85 @@
---
id: 5ee127a03c3b35dd45426493
title: Assigning the Value of One Variable to Another
challengeType: 1
videoUrl: ''
forumTopicId: 418265
---
# --description--
After a value is assigned to a variable using the <dfn>assignment</dfn> operator, you can assign the value of that variable to another variable using the <dfn>assignment</dfn> operator.
```js
var myVar;
myVar = 5;
var myNum;
myNum = myVar;
```
The above declares a `myVar` variable with no value, then assigns it the value `5`. Next, a variable named `myNum` is declared with no value. Then, the contents of `myVar` (which is `5`) is assigned to the variable `myNum`. Now, `myNum` also has the value of `5`.
# --instructions--
Assign the contents of `a` to variable `b`.
# --hints--
You should not change code above the specified comment.
```js
assert(/var a;/.test(code) && /a = 7;/.test(code) && /var b;/.test(code));
```
`b` should have a value of 7.
```js
assert(typeof b === 'number' && b === 7);
```
`a` should be assigned to `b` with `=`.
```js
assert(/b\s*=\s*a\s*/g.test(code));
```
# --seed--
## --before-user-code--
```js
if (typeof a != 'undefined') {
a = undefined;
}
if (typeof b != 'undefined') {
b = undefined;
}
```
## --after-user-code--
```js
(function(a, b) {
return 'a = ' + a + ', b = ' + b;
})(a, b);
```
## --seed-contents--
```js
// Setup
var a;
a = 7;
var b;
// Only change code below this line
```
# --solutions--
```js
var a;
a = 7;
var b;
b = a;
```

View File

@ -1,91 +1,38 @@
---
id: 56533eb9ac21ba0edf2244c3
title: 用返回值来赋值
challengeType: 1
videoUrl: 'https://scrimba.com/c/ce2pEtB'
forumTopicId: 16658
title: 用返回值来赋值
---
## Description
<section id='description'>
如果你还记得我们在这一节<a href="/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank">使用赋值运算符存储值</a>的讨论,赋值之前,先完成等号右边的操作。这意味着我们可把一个函数的返回值,赋值给一个变量。
假设我们预先定义的函数<code>sum</code>其功能就是将两个数字相加,那么:
<code>ourSum = sum(5, 12);</code>
将调用<code>sum</code>函数,返回<code>return</code>了一个数值<code>17</code>,然后把它赋值给了<code>ourSum</code>变量。
</section>
# --description--
## Instructions
<section id='instructions'>
调用<code>processArg</code>函数并给参数一个值<code>7</code>,然后把返回的值赋值给变量<code>processed</code>
</section>
如果你还记得我们在这一节[使用赋值运算符存储值](/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator)的讨论,赋值之前,先完成等号右边的操作。这意味着我们可把一个函数的返回值,赋值给一个变量。
## Tests
<section id='tests'>
假设我们预先定义的函数`sum`其功能就是将两个数字相加,那么:
```yml
tests:
- text: <code>processed</code>的值应该是<code>2</code>。
testString: assert(processed === 2);
- text: 你应该把<code>processArg</code>的返回值赋给<code>processed</code>。
testString: assert(/processed\s*=\s*processArg\(\s*7\s*\)\s*;/.test(code));
`ourSum = sum(5, 12);`
```
将调用`sum`函数,返回`return`了一个数值`17`,然后把它赋值给了`ourSum`变量。
</section>
# --instructions--
## Challenge Seed
<section id='challengeSeed'>
调用`processArg`函数并给参数一个值`7`,然后把返回的值赋值给变量`processed`
<div id='js-seed'>
# --hints--
`processed`的值应该是`2`
```js
// Example
var changed = 0;
function change(num) {
return (num + 5) / 3;
}
changed = change(10);
// Setup
var processed = 0;
function processArg(num) {
return (num + 3) / 5;
}
// Only change code below this line
assert(processed === 2);
```
</div>
### After Test
<div id='js-teardown'>
你应该把`processArg`的返回值赋给`processed`
```js
(function(){return "processed = " + processed})();
assert(/processed\s*=\s*processArg\(\s*7\s*\)\s*;/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var processed = 0;
function processArg(num) {
return (num + 3) / 5;
}
processed = processArg(7);
```
</section>

View File

@ -1,16 +1,19 @@
---
id: 56bbb991ad1ed5201cd392d0
title: 新建 JavaScript 对象
challengeType: 1
videoUrl: 'https://scrimba.com/c/cWGkbtd'
forumTopicId: 16769
title: 新建 JavaScript 对象
---
## Description
<section id='description'>
你之前可能听说过对象<code>object</code>
# --description--
你之前可能听说过对象`object`
对象和数组很相似,数组是通过索引来访问和修改数据,而对象是通过属性来访问和修改数据。
对象适合用来存储结构化数据,就和真实世界的对象一模一样,比如一只猫。
这是一个对象的示例:
```js
@ -22,7 +25,7 @@ var cat = {
};
```
在这个示例中所有的属性以字符串的形式储存,例如,<code>"name"</code><code>"legs"</code><code>"tails"</code>。但是,你也可以使用数字作为属性,你甚至可以省略字符串属性的引号,如下所示:
在这个示例中所有的属性以字符串的形式储存,例如,`"name"``"legs"``"tails"`。但是,你也可以使用数字作为属性,你甚至可以省略字符串属性的引号,如下所示:
```js
var anotherObject = {
@ -33,83 +36,96 @@ var anotherObject = {
```
但是如果你的对象具有任何非字符串属性JavaScript 将自动将它们转换为字符串类型。
</section>
## Instructions
<section id='instructions'>
创建一个叫做<code>myDog</code>的对象,它里面有这些属性:<code>"name"</code><code>"legs"</code><code>"tails"</code><code>"friends"</code>
你可以设置对象属性为任何值,只需要确保<code>"name"</code>是字符串,<code>"legs"</code><code>"tails"</code>是数字,<code>"friends"</code>是数组。
</section>
# --instructions--
## Tests
<section id='tests'>
创建一个叫做`myDog`的对象,它里面有这些属性:`"name"``"legs"``"tails"``"friends"`
```yml
tests:
- text: <code>myDog</code>应该包含<code>name</code>属性,并且是一个字符串<code>string</code>。
testString: assert((function(z){if(z.hasOwnProperty("name") && z.name !== undefined && typeof z.name === "string"){return true;}else{return false;}})(myDog));
- text: <code>myDog</code>应该包含<code>legs</code>属性,并且是一个数字<code>number</code>。
testString: assert((function(z){if(z.hasOwnProperty("legs") && z.legs !== undefined && typeof z.legs === "number"){return true;}else{return false;}})(myDog));
- text: <code>myDog</code>应该包含<code>tails</code>属性,并且是一个数字<code>number</code>。
testString: assert((function(z){if(z.hasOwnProperty("tails") && z.tails !== undefined && typeof z.tails === "number"){return true;}else{return false;}})(myDog));
- text: <code>myDog</code>应该包含<code>friends</code>属性,并且是一个数组<code>array</code>。
testString: assert((function(z){if(z.hasOwnProperty("friends") && z.friends !== undefined && Array.isArray(z.friends)){return true;}else{return false;}})(myDog));
- text: <code>myDog</code>应该只包含给出的属性。
testString: assert((function(z){return Object.keys(z).length === 4;})(myDog));
你可以设置对象属性为任何值,只需要确保`"name"`是字符串,`"legs"``"tails"`是数字,`"friends"`是数组。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myDog`应该包含`name`属性,并且是一个字符串`string`
```js
// Example
var ourDog = {
"name": "Camper",
"legs": 4,
"tails": 1,
"friends": ["everything!"]
};
// Only change code below this line.
var myDog = {
};
assert(
(function (z) {
if (
z.hasOwnProperty('name') &&
z.name !== undefined &&
typeof z.name === 'string'
) {
return true;
} else {
return false;
}
})(myDog)
);
```
</div>
### After Test
<div id='js-teardown'>
`myDog`应该包含`legs`属性,并且是一个数字`number`
```js
(function(z){return z;})(myDog);
assert(
(function (z) {
if (
z.hasOwnProperty('legs') &&
z.legs !== undefined &&
typeof z.legs === 'number'
) {
return true;
} else {
return false;
}
})(myDog)
);
```
</div>
</section>
## Solution
<section id='solution'>
`myDog`应该包含`tails`属性,并且是一个数字`number`
```js
var myDog = {
"name": "Camper",
"legs": 4,
"tails": 1,
"friends": ["everything!"]
};
assert(
(function (z) {
if (
z.hasOwnProperty('tails') &&
z.tails !== undefined &&
typeof z.tails === 'number'
) {
return true;
} else {
return false;
}
})(myDog)
);
```
</section>
`myDog`应该包含`friends`属性,并且是一个数组`array`
```js
assert(
(function (z) {
if (
z.hasOwnProperty('friends') &&
z.friends !== undefined &&
Array.isArray(z.friends)
) {
return true;
} else {
return false;
}
})(myDog)
);
```
`myDog`应该只包含给出的属性。
```js
assert(
(function (z) {
return Object.keys(z).length === 4;
})(myDog)
);
```
# --solutions--

View File

@ -1,14 +1,14 @@
---
id: 56533eb9ac21ba0edf2244dc
title: 多个 if else 语句
challengeType: 1
videoUrl: 'https://scrimba.com/c/caeJgsw'
forumTopicId: 16772
title: 多个 if else 语句
---
## Description
<section id='description'>
<code>if/else</code>语句串联在一起可以实现复杂的逻辑,这是多个<code>if/else if</code>语句串联在一起的伪代码:
# --description--
`if/else`语句串联在一起可以实现复杂的逻辑,这是多个`if/else if`语句串联在一起的伪代码:
```js
if (condition1) {
@ -23,92 +23,95 @@ if (condition1) {
}
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
<code>if</code>/<code>else if</code>语句串联起来实现下面的逻辑:
<code>num &lt; 5</code>- return "Tiny"<br><code>num &lt; 10</code>- return "Small"<br><code>num &lt; 15</code>- return "Medium"<br><code>num &lt; 20</code>- return "Large"<br><code>num >= 20</code> - return "Huge"
</section>
`if`/`else if`语句串联起来实现下面的逻辑:
## Tests
<section id='tests'>
`num < 5`- return "Tiny"
`num < 10`- return "Small"
`num < 15`- return "Medium"
`num < 20`- return "Large"
`num >= 20` - return "Huge"
```yml
tests:
- text: 你应该有至少 4 个<code>else</code>表达式。
testString: assert(code.match(/else/g).length > 3);
- text: 你应该有至少 4 个<code>if</code>表达式。
testString: assert(code.match(/if/g).length > 3);
- text: 你应该有至少 1 个<code>return</code>表达式。
testString: assert(code.match(/return/g).length >= 1);
- text: <code>testSize(0)</code>应该返回 "Tiny"。
testString: assert(testSize(0) === "Tiny");
- text: <code>testSize(4)</code>应该返回 "Tiny"。
testString: assert(testSize(4) === "Tiny");
- text: <code>testSize(5)</code>应该返回 "Small"。
testString: assert(testSize(5) === "Small");
- text: <code>testSize(8)</code>应该返回 "Small"。
testString: assert(testSize(8) === "Small");
- text: <code>testSize(10)</code>应该返回 "Medium"。
testString: assert(testSize(10) === "Medium");
- text: <code>testSize(14)</code>应该返回 "Medium"。
testString: assert(testSize(14) === "Medium");
- text: <code>testSize(15)</code>应该返回 "Large"。
testString: assert(testSize(15) === "Large");
- text: <code>testSize(17)</code>应该返回 "Large"。
testString: assert(testSize(17) === "Large");
- text: <code>testSize(20)</code>应该返回 "Huge"。
testString: assert(testSize(20) === "Huge");
- text: <code>testSize(25)</code>应该返回 "Huge"。
testString: assert(testSize(25) === "Huge");
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该有至少 4 个`else`表达式。
```js
function testSize(num) {
// Only change code below this line
return "Change Me";
// Only change code above this line
}
// Change this value to test
testSize(7);
assert(code.match(/else/g).length > 3);
```
</div>
</section>
## Solution
<section id='solution'>
你应该有至少 4 个`if`表达式。
```js
function testSize(num) {
if (num < 5) {
return "Tiny";
} else if (num < 10) {
return "Small";
} else if (num < 15) {
return "Medium";
} else if (num < 20) {
return "Large";
} else {
return "Huge";
}
}
assert(code.match(/if/g).length > 3);
```
</section>
你应该有至少 1 个`return`表达式。
```js
assert(code.match(/return/g).length >= 1);
```
`testSize(0)`应该返回 "Tiny"。
```js
assert(testSize(0) === 'Tiny');
```
`testSize(4)`应该返回 "Tiny"。
```js
assert(testSize(4) === 'Tiny');
```
`testSize(5)`应该返回 "Small"。
```js
assert(testSize(5) === 'Small');
```
`testSize(8)`应该返回 "Small"。
```js
assert(testSize(8) === 'Small');
```
`testSize(10)`应该返回 "Medium"。
```js
assert(testSize(10) === 'Medium');
```
`testSize(14)`应该返回 "Medium"。
```js
assert(testSize(14) === 'Medium');
```
`testSize(15)`应该返回 "Large"。
```js
assert(testSize(15) === 'Large');
```
`testSize(17)`应该返回 "Large"。
```js
assert(testSize(17) === 'Large');
```
`testSize(20)`应该返回 "Huge"。
```js
assert(testSize(20) === 'Huge');
```
`testSize(25)`应该返回 "Huge"。
```js
assert(testSize(25) === 'Huge');
```
# --solutions--

View File

@ -1,72 +1,50 @@
---
id: bd7123c9c441eddfaeb4bdef
title: 给代码添加注释
challengeType: 1
videoUrl: 'https://scrimba.com/c/c7ynnTp'
forumTopicId: 16783
title: 给代码添加注释
---
## Description
<section id='description'>
# --description--
被注释的代码块在 JavaScript 之中是不会执行的。在代码中写注释是一个非常好的方式让你自己和其他人理解代码。
JavaScript 中的注释方式有以下两种:
使用<code>//</code>注释掉当前行的代码
使用`//`注释掉当前行的代码
```js
// This is an in-line comment.
```
你也可以使用多行注释来注释你的代码,以<code>/*</code>开始,用<code>*/</code>来结束,就像下面这样:
你也可以使用多行注释来注释你的代码,以<code>/<em></em></code>*开始,用\`\`*`/`来结束,就像下面这样:
```js
/* This is a
multi-line comment */
```
<strong>最佳实践</strong><br>写代码的时候,要定期添加注释对部分代码块进行解释。适当的注释能让别人和你自己更容易看懂代码。
</section>
**最佳实践**
写代码的时候,要定期添加注释对部分代码块进行解释。适当的注释能让别人和你自己更容易看懂代码。
# --instructions--
## Instructions
<section id='instructions'>
尝试创建这两种类型的注释。
</section>
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: 创建一个<code>//</code>样式的注释, 被注释的文本至少要包含 5 个字符。
testString: assert(code.match(/(\/\/)...../g));
- text: 创建一个<code>/* */</code>样式的注释, 被注释的文本至少要包含 5 个字符。
testString: assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
创建一个`//`样式的注释, 被注释的文本至少要包含 5 个字符。
```js
assert(code.match(/(\/\/)...../g));
```
</div>
</section>
## Solution
<section id='solution'>
创建一个`/* */`样式的注释, 被注释的文本至少要包含 5 个字符。
```js
// Fake Comment
/* Another Comment */
assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm));
```
</section>
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244d0
title: 相等运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cKyVMAL'
forumTopicId: 16784
title: 相等运算符
---
## Description
<section id='description'>
在 JavaScript 中,有很多<dfn>相互比较的操作</dfn>。所有这些操作符都返回一个<code>true</code><code>false</code>值。
最基本的运算符是相等运算符:<code>==</code>。相等运算符比较两个值,如果它们是同等,返回<code>true</code>,如果它们不等,返回<code>false</code>。值得注意的是相等运算符不同于赋值运算符(<code>=</code>),赋值运算符是把等号右边的值赋给左边的变量。
# --description--
在 JavaScript 中,有很多<dfn>相互比较的操作</dfn>。所有这些操作符都返回一个`true``false`值。
最基本的运算符是相等运算符:`==`。相等运算符比较两个值,如果它们是同等,返回`true`,如果它们不等,返回`false`。值得注意的是相等运算符不同于赋值运算符(`=`),赋值运算符是把等号右边的值赋给左边的变量。
```js
function equalityTest(myVal) {
@ -20,8 +21,7 @@ function equalityTest(myVal) {
}
```
如果<code>myVal</code>等于<code>10</code>,相等运算符会返回<code>true</code>,因此大括号里面的代码会被执行,函数将返回<code>"Equal"</code>。否则,函数返回<code>"Not Equal"</code>
在 JavaScript 中,为了让两个不同的<code>数据类型</code>(例如<code>数字</code><code>字符串</code>)的值可以作比较,它必须把一种类型转换为另一种类型。然而一旦这样做,它可以像下面这样来比较:
如果`myVal`等于`10`,相等运算符会返回`true`,因此大括号里面的代码会被执行,函数将返回`"Equal"`。否则,函数返回`"Not Equal"`。 在 JavaScript 中,为了让两个不同的`数据类型`(例如`数字``字符串`)的值可以作比较,它必须把一种类型转换为另一种类型。然而一旦这样做,它可以像下面这样来比较:
```js
1 == 1 // true
@ -30,66 +30,35 @@ function equalityTest(myVal) {
"3" == 3 // true
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
<code>相等运算符</code>添加到指定的行,这样当<code>val</code>的值为<code>12</code>的时候,函数会返回"Equal"。
</section>
`相等运算符`添加到指定的行,这样当`val`的值为`12`的时候,函数会返回"Equal"。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>testEqual(10)</code>应该返回 "Not Equal"。
testString: assert(testEqual(10) === "Not Equal");
- text: <code>testEqual(12)</code>应该返回 "Equal"。
testString: assert(testEqual(12) === "Equal");
- text: <code>testEqual("12")</code>应该返回 "Equal"。
testString: assert(testEqual("12") === "Equal");
- text: 你应该使用<code>==</code>运算符。
testString: assert(code.match(/==/g) && !code.match(/===/g));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`testEqual(10)`应该返回 "Not Equal"。
```js
// Setup
function testEqual(val) {
if (val) { // Change this line
return "Equal";
}
return "Not Equal";
}
// Change this value to test
testEqual(10);
assert(testEqual(10) === 'Not Equal');
```
</div>
</section>
## Solution
<section id='solution'>
`testEqual(12)`应该返回 "Equal"。
```js
function testEqual(val) {
if (val == 12) {
return "Equal";
}
return "Not Equal";
}
assert(testEqual(12) === 'Equal');
```
</section>
`testEqual("12")`应该返回 "Equal"。
```js
assert(testEqual('12') === 'Equal');
```
你应该使用`==`运算符。
```js
assert(code.match(/==/g) && !code.match(/===/g));
```
# --solutions--

View File

@ -1,16 +1,18 @@
---
id: 56533eb9ac21ba0edf2244d4
title: 大于运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cp6GbH4'
forumTopicId: 16786
title: 大于运算符
---
## Description
<section id='description'>
使用大于运算符(<code>&gt;</code>)来比较两个数字。如果大于运算符左边的数字大于右边的数字,将会返回<code>true</code>。否则,它返回<code>false</code>
# --description--
使用大于运算符(`>`)来比较两个数字。如果大于运算符左边的数字大于右边的数字,将会返回`true`。否则,它返回`false`
与相等运算符一样,大于运算符在比较的时候,会转换值的数据类型。
<strong>例如</strong>
**例如**
```js
5 > 3 // true
@ -19,81 +21,59 @@ title: 大于运算符
'1' > 9 // false
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
添加<code>大于</code>运算符到指定的行,使得返回的语句是有意义的。
</section>
添加`大于`运算符到指定的行,使得返回的语句是有意义的。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>testGreaterThan(0)</code>应该返回 "10 or Under"。
testString: assert(testGreaterThan(0) === "10 or Under");
- text: <code>testGreaterThan(10)</code>应该返回 "10 or Under"。
testString: assert(testGreaterThan(10) === "10 or Under");
- text: <code>testGreaterThan(11)</code>应该返回 "Over 10"。
testString: assert(testGreaterThan(11) === "Over 10");
- text: <code>testGreaterThan(99)</code>应该返回 "Over 10"。
testString: assert(testGreaterThan(99) === "Over 10");
- text: <code>testGreaterThan(100)</code>应该返回 "Over 10"。
testString: assert(testGreaterThan(100) === "Over 10");
- text: <code>testGreaterThan(101)</code>应该返回 "Over 100"。
testString: assert(testGreaterThan(101) === "Over 100");
- text: <code>testGreaterThan(150)</code>应该返回 "Over 100"。
testString: assert(testGreaterThan(150) === "Over 100");
- text: 你应该使用<code>&gt;</code>运算符至少两次。
testString: assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`testGreaterThan(0)`应该返回 "10 or Under"。
```js
function testGreaterThan(val) {
if (val) { // Change this line
return "Over 100";
}
if (val) { // Change this line
return "Over 10";
}
return "10 or Under";
}
// Change this value to test
testGreaterThan(10);
assert(testGreaterThan(0) === '10 or Under');
```
</div>
</section>
## Solution
<section id='solution'>
`testGreaterThan(10)`应该返回 "10 or Under"。
```js
function testGreaterThan(val) {
if (val > 100) { // Change this line
return "Over 100";
}
if (val > 10) { // Change this line
return "Over 10";
}
return "10 or Under";
}
assert(testGreaterThan(10) === '10 or Under');
```
</section>
`testGreaterThan(11)`应该返回 "Over 10"。
```js
assert(testGreaterThan(11) === 'Over 10');
```
`testGreaterThan(99)`应该返回 "Over 10"。
```js
assert(testGreaterThan(99) === 'Over 10');
```
`testGreaterThan(100)`应该返回 "Over 10"。
```js
assert(testGreaterThan(100) === 'Over 10');
```
`testGreaterThan(101)`应该返回 "Over 100"。
```js
assert(testGreaterThan(101) === 'Over 100');
```
`testGreaterThan(150)`应该返回 "Over 100"。
```js
assert(testGreaterThan(150) === 'Over 100');
```
你应该使用`>`运算符至少两次。
```js
assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);
```
# --solutions--

View File

@ -1,16 +1,18 @@
---
id: 56533eb9ac21ba0edf2244d5
title: 大于或等于运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/c6KBqtV'
forumTopicId: 16785
title: 大于或等于运算符
---
## Description
<section id='description'>
使用<code>大于等于</code>运算符(<code>&gt;=</code>)来比较两个数字的大小。如果大于等于运算符左边的数字比右边的数字大或者相等,它会返回<code>true</code>。否则,它会返回<code>false</code>
与相等运算符相似,<code>大于等于</code>运算符在比较的时候会转换值的数据类型。
<strong>例如</strong>
# --description--
使用`大于等于`运算符(`>=`)来比较两个数字的大小。如果大于等于运算符左边的数字比右边的数字大或者相等,它会返回`true`。否则,它会返回`false`
与相等运算符相似,`大于等于`运算符在比较的时候会转换值的数据类型。
**例如**
```js
6 >= 6 // true
@ -19,83 +21,59 @@ title: 大于或等于运算符
'7' >= 9 // false
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
添加<code>大于等于</code>运算符到指定行,使得函数的返回语句有意义。
</section>
添加`大于等于`运算符到指定行,使得函数的返回语句有意义。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>testGreaterOrEqual(0)</code>应该返回 "Less than 10"。
testString: assert(testGreaterOrEqual(0) === "Less than 10");
- text: <code>testGreaterOrEqual(9)</code>应该返回 "Less than 10"。
testString: assert(testGreaterOrEqual(9) === "Less than 10");
- text: <code>testGreaterOrEqual(10)</code>应该返回 "10 or Over"。
testString: assert(testGreaterOrEqual(10) === "10 or Over");
- text: <code>testGreaterOrEqual(11)</code>应该返回 "10 or Over"。
testString: assert(testGreaterOrEqual(11) === "10 or Over");
- text: <code>testGreaterOrEqual(19)</code>应该返回 "10 or Over"。
testString: assert(testGreaterOrEqual(19) === "10 or Over");
- text: <code>testGreaterOrEqual(100)</code>应该返回 "20 or Over"。
testString: assert(testGreaterOrEqual(100) === "20 or Over");
- text: <code>testGreaterOrEqual(21)</code>应该返回 "20 or Over"。
testString: assert(testGreaterOrEqual(21) === "20 or Over");
- text: 你应该使用<code>&gt;=</code>运算符至少两次。
testString: assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`testGreaterOrEqual(0)`应该返回 "Less than 10"。
```js
function testGreaterOrEqual(val) {
if (val) { // Change this line
return "20 or Over";
}
if (val) { // Change this line
return "10 or Over";
}
return "Less than 10";
}
// Change this value to test
testGreaterOrEqual(10);
assert(testGreaterOrEqual(0) === 'Less than 10');
```
</div>
</section>
## Solution
<section id='solution'>
`testGreaterOrEqual(9)`应该返回 "Less than 10"。
```js
function testGreaterOrEqual(val) {
if (val >= 20) { // Change this line
return "20 or Over";
}
if (val >= 10) { // Change this line
return "10 or Over";
}
return "Less than 10";
}
assert(testGreaterOrEqual(9) === 'Less than 10');
```
</section>
`testGreaterOrEqual(10)`应该返回 "10 or Over"。
```js
assert(testGreaterOrEqual(10) === '10 or Over');
```
`testGreaterOrEqual(11)`应该返回 "10 or Over"。
```js
assert(testGreaterOrEqual(11) === '10 or Over');
```
`testGreaterOrEqual(19)`应该返回 "10 or Over"。
```js
assert(testGreaterOrEqual(19) === '10 or Over');
```
`testGreaterOrEqual(100)`应该返回 "20 or Over"。
```js
assert(testGreaterOrEqual(100) === '20 or Over');
```
`testGreaterOrEqual(21)`应该返回 "20 or Over"。
```js
assert(testGreaterOrEqual(21) === '20 or Over');
```
你应该使用`>=`运算符至少两次。
```js
assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244d2
title: 不等运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cdBm9Sr'
forumTopicId: 16787
title: 不等运算符
---
## Description
<section id='description'>
不相等运算符(<code>!=</code>)与相等运算符是相反的。这意味着不相等运算符中,如果“不为真”并且返回<code>false</code>的地方,在相等运算符中会返回<code>true</code><em>反之亦然</em>。与相等运算符类似,不相等运算符在比较的时候也会转换值的数据类型。
<strong>例如</strong>
# --description--
不相等运算符(`!=`)与相等运算符是相反的。这意味着不相等运算符中,如果“不为真”并且返回`false`的地方,在相等运算符中会返回`true`*反之亦然*。与相等运算符类似,不相等运算符在比较的时候也会转换值的数据类型。
**例如**
```js
1 != 2 // true
@ -19,70 +20,47 @@ title: 不等运算符
0 != false // false
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
<code>if</code>语句中,添加不相等运算符<code>!=</code>,这样函数在当<code>val</code>不等于 <code>99</code>的时候,会返回 "Not Equal"。
</section>
`if`语句中,添加不相等运算符`!=`,这样函数在当`val`不等于 `99`的时候,会返回 "Not Equal"。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>testNotEqual(99)</code>应该返回 "Equal"。
testString: assert(testNotEqual(99) === "Equal");
- text: <code>testNotEqual("99")</code>应该返回 "Equal"。
testString: assert(testNotEqual("99") === "Equal");
- text: <code>testNotEqual(12)</code>应该返回 "Not Equal"。
testString: assert(testNotEqual(12) === "Not Equal");
- text: <code>testNotEqual("12")</code>应该返回 "Not Equal"。
testString: assert(testNotEqual("12") === "Not Equal");
- text: <code>testNotEqual("bob")</code>应该返回 "Not Equal"。
testString: assert(testNotEqual("bob") === "Not Equal");
- text: 你应该使用<code>!=</code>运算符。
testString: assert(code.match(/(?!!==)!=/));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`testNotEqual(99)`应该返回 "Equal"。
```js
// Setup
function testNotEqual(val) {
if (val) { // Change this line
return "Not Equal";
}
return "Equal";
}
// Change this value to test
testNotEqual(10);
assert(testNotEqual(99) === 'Equal');
```
</div>
</section>
## Solution
<section id='solution'>
`testNotEqual("99")`应该返回 "Equal"。
```js
function testNotEqual(val) {
if (val != 99) {
return "Not Equal";
}
return "Equal";
}
assert(testNotEqual('99') === 'Equal');
```
</section>
`testNotEqual(12)`应该返回 "Not Equal"。
```js
assert(testNotEqual(12) === 'Not Equal');
```
`testNotEqual("12")`应该返回 "Not Equal"。
```js
assert(testNotEqual('12') === 'Not Equal');
```
`testNotEqual("bob")`应该返回 "Not Equal"。
```js
assert(testNotEqual('bob') === 'Not Equal');
```
你应该使用`!=`运算符。
```js
assert(code.match(/(?!!==)!=/));
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244d6
title: 小于运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cNVRWtB'
forumTopicId: 16789
title: 小于运算符
---
## Description
<section id='description'>
使用<dfn>小于</dfn>运算符(<code>&lt;</code>)比较两个数字的大小。如果小于运算符左边的数字比右边的数字小,它会返回<code>true</code>。否则会返回<code>false</code>。与相等运算符类似,<dfn>小于</dfn> 运算符在做比较的时候会转换值的数据类型。
<strong>例如</strong>
# --description--
使用<dfn>小于</dfn>运算符(`<`)比较两个数字的大小。如果小于运算符左边的数字比右边的数字小,它会返回`true`。否则会返回`false`。与相等运算符类似,<dfn>小于</dfn> 运算符在做比较的时候会转换值的数据类型。
**例如**
```js
2 < 5 // true
@ -19,81 +20,53 @@ title: 小于运算符
'8' < 4 // false
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
添加<code>小于</code>运算符到指定行,使得函数的返回语句有意义。
</section>
添加`小于`运算符到指定行,使得函数的返回语句有意义。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>testLessThan(0)</code>应该返回 "Under 25"。
testString: assert(testLessThan(0) === "Under 25");
- text: <code>testLessThan(24)</code>应该返回 "Under 25"。
testString: assert(testLessThan(24) === "Under 25");
- text: <code>testLessThan(25)</code>应该返回 "Under 55"。
testString: assert(testLessThan(25) === "Under 55");
- text: <code>testLessThan(54)</code>应该返回 "Under 55"。
testString: assert(testLessThan(54) === "Under 55");
- text: <code>testLessThan(55)</code>应该返回 "55 or Over"。
testString: assert(testLessThan(55) === "55 or Over");
- text: <code>testLessThan(99)</code>应该返回 "55 or Over"。
testString: assert(testLessThan(99) === "55 or Over");
- text: 你应该使用<code>&lt;</code>运算符至少两次。
testString: assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`testLessThan(0)`应该返回 "Under 25"。
```js
function testLessThan(val) {
if (val) { // Change this line
return "Under 25";
}
if (val) { // Change this line
return "Under 55";
}
return "55 or Over";
}
// Change this value to test
testLessThan(10);
assert(testLessThan(0) === 'Under 25');
```
</div>
</section>
## Solution
<section id='solution'>
`testLessThan(24)`应该返回 "Under 25"。
```js
function testLessThan(val) {
if (val < 25) { // Change this line
return "Under 25";
}
if (val < 55) { // Change this line
return "Under 55";
}
return "55 or Over";
}
assert(testLessThan(24) === 'Under 25');
```
</section>
`testLessThan(25)`应该返回 "Under 55"。
```js
assert(testLessThan(25) === 'Under 55');
```
`testLessThan(54)`应该返回 "Under 55"。
```js
assert(testLessThan(54) === 'Under 55');
```
`testLessThan(55)`应该返回 "55 or Over"。
```js
assert(testLessThan(55) === '55 or Over');
```
`testLessThan(99)`应该返回 "55 or Over"。
```js
assert(testLessThan(99) === '55 or Over');
```
你应该使用`<`运算符至少两次。
```js
assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244d7
title: 小于或等于运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cNVR7Am'
forumTopicId: 16788
title: 小于或等于运算符
---
## Description
<section id='description'>
使用<code>小于等于</code>运算符(<code>&lt;=</code>)比较两个数字的大小。如果在小于等于运算符左边的数字小于或者等于右边的数字,它会返回<code>true</code>。如果在小于等于运算符左边的数字大于右边的数字,它会返回<code>false</code>。与相等运算符类似,<code>小于等于</code>运算符会转换数据类型。
<strong>例如</strong>
# --description--
使用`小于等于`运算符(`<=`)比较两个数字的大小。如果在小于等于运算符左边的数字小于或者等于右边的数字,它会返回`true`。如果在小于等于运算符左边的数字大于右边的数字,它会返回`false`。与相等运算符类似,`小于等于`运算符会转换数据类型。
**例如**
```js
4 <= 5 // true
@ -19,84 +20,59 @@ title: 小于或等于运算符
'8' <= 4 // false
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
添加<code>小于等于</code>运算符到指定行,使得函数的返回语句有意义。
</section>
添加`小于等于`运算符到指定行,使得函数的返回语句有意义。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>testLessOrEqual(0)</code>应该返回 "Smaller Than or Equal to 12"。
testString: assert(testLessOrEqual(0) === "Smaller Than or Equal to 12");
- text: <code>testLessOrEqual(11)</code>应该返回 "Smaller Than or Equal to 12"。
testString: assert(testLessOrEqual(11) === "Smaller Than or Equal to 12");
- text: <code>testLessOrEqual(12)</code>应该返回 "Smaller Than or Equal to 12"。
testString: assert(testLessOrEqual(12) === "Smaller Than or Equal to 12");
- text: <code>testLessOrEqual(23)</code>应该返回 "Smaller Than or Equal to 24"。
testString: assert(testLessOrEqual(23) === "Smaller Than or Equal to 24");
- text: <code>testLessOrEqual(24)</code>应该返回 "Smaller Than or Equal to 24"。
testString: assert(testLessOrEqual(24) === "Smaller Than or Equal to 24");
- text: <code>testLessOrEqual(25)</code>应该返回 "More Than 24"。
testString: assert(testLessOrEqual(25) === "More Than 24");
- text: <code>testLessOrEqual(55)</code>应该返回 "More Than 24"。
testString: assert(testLessOrEqual(55) === "More Than 24");
- text: 你应该使用<code>&lt;=</code>运算符至少两。
testString: assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`testLessOrEqual(0)`应该返回 "Smaller Than or Equal to 12"。
```js
function testLessOrEqual(val) {
if (val) { // Change this line
return "Smaller Than or Equal to 12";
}
if (val) { // Change this line
return "Smaller Than or Equal to 24";
}
return "More Than 24";
}
// Change this value to test
testLessOrEqual(10);
assert(testLessOrEqual(0) === 'Smaller Than or Equal to 12');
```
</div>
</section>
## Solution
<section id='solution'>
`testLessOrEqual(11)`应该返回 "Smaller Than or Equal to 12"。
```js
function testLessOrEqual(val) {
if (val <= 12) { // Change this line
return "Smaller Than or Equal to 12";
}
if (val <= 24) { // Change this line
return "Smaller Than or Equal to 24";
}
return "More Than 24";
}
assert(testLessOrEqual(11) === 'Smaller Than or Equal to 12');
```
</section>
`testLessOrEqual(12)`应该返回 "Smaller Than or Equal to 12"。
```js
assert(testLessOrEqual(12) === 'Smaller Than or Equal to 12');
```
`testLessOrEqual(23)`应该返回 "Smaller Than or Equal to 24"。
```js
assert(testLessOrEqual(23) === 'Smaller Than or Equal to 24');
```
`testLessOrEqual(24)`应该返回 "Smaller Than or Equal to 24"。
```js
assert(testLessOrEqual(24) === 'Smaller Than or Equal to 24');
```
`testLessOrEqual(25)`应该返回 "More Than 24"。
```js
assert(testLessOrEqual(25) === 'More Than 24');
```
`testLessOrEqual(55)`应该返回 "More Than 24"。
```js
assert(testLessOrEqual(55) === 'More Than 24');
```
你应该使用`<=`运算符至少两。
```js
assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);
```
# --solutions--

View File

@ -1,83 +1,55 @@
---
id: 56533eb9ac21ba0edf2244d1
title: 严格相等运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cy87atr'
forumTopicId: 16790
title: 严格相等运算符
---
## Description
<section id='description'>
严格相等运算符(<code>===</code>)是相对相等操作符(<code>==</code>)的另一种比较操作符。与相等操作符不同的是,它会同时比较元素的值和<code>数据类型</code>
# --description--
严格相等运算符(`===`)是相对相等操作符(`==`)的另一种比较操作符。与相等操作符不同的是,它会同时比较元素的值和`数据类型`
如果比较的值类型不同,那么在严格相等运算符比较下它们是不相等的,会返回 false 。
<strong>示例</strong>
**示例**
```js
3 === 3 // true
3 === '3' // false
```
<code>3</code>是一个<code>数字</code>类型的,而<code>'3'</code>是一个<code>字符串</code>类型的,所以 3 不全等于 '3'。
</section>
`3`是一个`数字`类型的,而`'3'`是一个`字符串`类型的,所以 3 不全等于 '3'。
## Instructions
<section id='instructions'>
<code>if</code>语句值使用严格相等运算符,这样当<code>val</code>严格等于7的时候函数会返回"Equal"。
</section>
# --instructions--
## Tests
<section id='tests'>
`if`语句值使用严格相等运算符,这样当`val`严格等于7的时候函数会返回"Equal"。
```yml
tests:
- text: <code>testStrict(10)</code>应该返回 "Not Equal"。
testString: assert(testStrict(10) === "Not Equal");
- text: <code>testStrict(7)</code>应该返回 "Equal"。
testString: assert(testStrict(7) === "Equal");
- text: <code>testStrict("7")</code>应该返回 "Not Equal"。
testString: assert(testStrict("7") === "Not Equal");
- text: 你应该使用<code>===</code>运算符。
testString: assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`testStrict(10)`应该返回 "Not Equal"。
```js
// Setup
function testStrict(val) {
if (val) { // Change this line
return "Equal";
}
return "Not Equal";
}
// Change this value to test
testStrict(10);
assert(testStrict(10) === 'Not Equal');
```
</div>
</section>
## Solution
<section id='solution'>
`testStrict(7)`应该返回 "Equal"。
```js
function testStrict(val) {
if (val === 7) {
return "Equal";
}
return "Not Equal";
}
assert(testStrict(7) === 'Equal');
```
</section>
`testStrict("7")`应该返回 "Not Equal"。
```js
assert(testStrict('7') === 'Not Equal');
```
你应该使用`===`运算符。
```js
assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244d3
title: 严格不等运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cKekkUy'
forumTopicId: 16791
title: 严格不等运算符
---
## Description
<section id='description'>
严格不相等运算符(<code>!==</code>)与全等运算符是相反的。这意味着严格不相等并返回<code>false</code>的地方,用严格相等运算符会返回<code>true</code><em>反之亦然</em>。严格不相等运算符不会转换值的数据类型。
<strong>示例</strong>
# --description--
严格不相等运算符(`!==`)与全等运算符是相反的。这意味着严格不相等并返回`false`的地方,用严格相等运算符会返回`true`*反之亦然*。严格不相等运算符不会转换值的数据类型。
**示例**
```js
3 !== 3 // false
@ -17,68 +18,41 @@ title: 严格不等运算符
4 !== 3 // true
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
<code>if</code>语句中,添加严格不相等运算符<code>!==</code>,这样如果<code>val</code><code>17</code>严格不相等的时候,函数会返回 "Not Equal"。
</section>
`if`语句中,添加严格不相等运算符`!==`,这样如果`val``17`严格不相等的时候,函数会返回 "Not Equal"。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>testStrictNotEqual(17)</code>应该返回 "Equal"。
testString: assert(testStrictNotEqual(17) === "Equal");
- text: <code>testStrictNotEqual("17")</code>应该返回 "Not Equal"。
testString: assert(testStrictNotEqual("17") === "Not Equal");
- text: <code>testStrictNotEqual(12)</code>应该返回 "Not Equal"。
testString: assert(testStrictNotEqual(12) === "Not Equal");
- text: <code>testStrictNotEqual("bob")</code>应该返回 "Not Equal"。
testString: assert(testStrictNotEqual("bob") === "Not Equal");
- text: 应该使用 <code>!==</code> 运算符。
testString: assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`testStrictNotEqual(17)`应该返回 "Equal"。
```js
// Setup
function testStrictNotEqual(val) {
if (val) { // Change this line
return "Not Equal";
}
return "Equal";
}
// Change this value to test
testStrictNotEqual(10);
assert(testStrictNotEqual(17) === 'Equal');
```
</div>
</section>
## Solution
<section id='solution'>
`testStrictNotEqual("17")`应该返回 "Not Equal"。
```js
function testStrictNotEqual(val) {
if (val !== 17) {
return "Not Equal";
}
return "Equal";
}
assert(testStrictNotEqual('17') === 'Not Equal');
```
</section>
`testStrictNotEqual(12)`应该返回 "Not Equal"。
```js
assert(testStrictNotEqual(12) === 'Not Equal');
```
`testStrictNotEqual("bob")`应该返回 "Not Equal"。
```js
assert(testStrictNotEqual('bob') === 'Not Equal');
```
应该使用 `!==` 运算符。
```js
assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);
```
# --solutions--

View File

@ -1,14 +1,15 @@
---
id: 56533eb9ac21ba0edf2244d8
title: 逻辑与运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cvbRVtr'
forumTopicId: 16799
title: 逻辑与运算符
---
## Description
<section id='description'>
有时你需要在一次判断中做多个操作。当且仅当运算符的左边和右边都是<code>true</code><dfn>逻辑与</dfn> 运算符(<code>&&</code>)才会返回<code>true</code>
# --description--
有时你需要在一次判断中做多个操作。当且仅当运算符的左边和右边都是`true`<dfn>逻辑与</dfn> 运算符(`&&`)才会返回`true`
同样的效果可以通过 if 语句的嵌套来实现:
```js
@ -20,7 +21,7 @@ if (num > 5) {
return "No";
```
只有当<code>num</code>的值在 6 和 9 之间(包括 6 和 9才会返回 "Yes"。相同的逻辑可被写为:
只有当`num`的值在 6 和 9 之间(包括 6 和 9才会返回 "Yes"。相同的逻辑可被写为:
```js
if (num > 5 && num < 10) {
@ -29,83 +30,71 @@ if (num > 5 && num < 10) {
return "No";
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
请使用逻辑与运算符把两个 if 语句合并为一个 if 语句,如果<code>val</code>小于或等于<code>50</code>并且大于或等于<code>25</code>,返回<code>"Yes"</code>。否则,将返回<code>"No"</code>
</section>
请使用逻辑与运算符把两个 if 语句合并为一个 if 语句,如果`val`小于或等于`50`并且大于或等于`25`,返回`"Yes"`。否则,将返回`"No"`
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: 你应该使用<code>&&</code>运算符一次。
testString: assert(code.match(/&&/g).length === 1,);
- text: 你应该只有一个<code>if</code>表达式。
testString: assert(code.match(/if/g).length === 1);
- text: <code>testLogicalAnd(0)</code>应该返回 "No"。
testString: assert(testLogicalAnd(0) === "No");
- text: <code>testLogicalAnd(24)</code>应该返回 "No"。
testString: assert(testLogicalAnd(24) === "No");
- text: <code>testLogicalAnd(25)</code>应该返回 "Yes"。
testString: assert(testLogicalAnd(25) === "Yes");
- text: <code>testLogicalAnd(30)</code>应该返回 "Yes"。
testString: assert(testLogicalAnd(30) === "Yes");
- text: <code>testLogicalAnd(50)</code>应该返回 "Yes"。
testString: assert(testLogicalAnd(50) === "Yes");
- text: <code>testLogicalAnd(51)</code>应该返回 "No"。
testString: assert(testLogicalAnd(51) === "No");
- text: <code>testLogicalAnd(75)</code>应该返回 "No"。
testString: assert(testLogicalAnd(75) === "No");
- text: <code>testLogicalAnd(80)</code>应该返回 "No"。
testString: assert(testLogicalAnd(80) === "No");
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该使用`&&`运算符一次。
```js
function testLogicalAnd(val) {
// Only change code below this line
if (val) {
if (val) {
return "Yes";
}
}
// Only change code above this line
return "No";
}
// Change this value to test
testLogicalAnd(10);
assert(code.match(/&&/g).length === 1);
```
</div>
</section>
## Solution
<section id='solution'>
你应该只有一个`if`表达式。
```js
function testLogicalAnd(val) {
if (val >= 25 && val <= 50) {
return "Yes";
}
return "No";
}
assert(code.match(/if/g).length === 1);
```
</section>
`testLogicalAnd(0)`应该返回 "No"。
```js
assert(testLogicalAnd(0) === 'No');
```
`testLogicalAnd(24)`应该返回 "No"。
```js
assert(testLogicalAnd(24) === 'No');
```
`testLogicalAnd(25)`应该返回 "Yes"。
```js
assert(testLogicalAnd(25) === 'Yes');
```
`testLogicalAnd(30)`应该返回 "Yes"。
```js
assert(testLogicalAnd(30) === 'Yes');
```
`testLogicalAnd(50)`应该返回 "Yes"。
```js
assert(testLogicalAnd(50) === 'Yes');
```
`testLogicalAnd(51)`应该返回 "No"。
```js
assert(testLogicalAnd(51) === 'No');
```
`testLogicalAnd(75)`应该返回 "No"。
```js
assert(testLogicalAnd(75) === 'No');
```
`testLogicalAnd(80)`应该返回 "No"。
```js
assert(testLogicalAnd(80) === 'No');
```
# --solutions--

View File

@ -1,15 +1,17 @@
---
id: 56533eb9ac21ba0edf2244d9
title: 逻辑或运算符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cEPrGTN'
forumTopicId: 16800
title: 逻辑或运算符
---
## Description
<section id='description'>
只要<dfn>逻辑或</dfn>运算符<code>||</code>两边任何一个为<code>true</code>,那么它就返回<code>true</code>;否则返回<code>false</code>
# --description--
只要<dfn>逻辑或</dfn>运算符`||`两边任何一个为`true`,那么它就返回`true`;否则返回`false`
<dfn>逻辑或</dfn>运算符由两个管道符号(|)组成。这个按键位于退格键和回车键之间。
下面这样的语句你应该很熟悉:
```js
@ -22,7 +24,7 @@ if (num < 5) {
return "Yes";
```
只有当<code>num</code>大于等于 5 或小于等于 10 时,函数返回"Yes"。相同的逻辑可以简写成:
只有当`num`大于等于 5 或小于等于 10 时,函数返回"Yes"。相同的逻辑可以简写成:
```js
if (num > 10 || num < 5) {
@ -31,85 +33,71 @@ if (num > 10 || num < 5) {
return "Yes";
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
请使用逻辑或运算符把两个 if 语句合并为一个 if 语句,如果<code>val</code>不在 10 和 20 之间(包括 10 和 20),返回<code>"Outside"</code>。反之,返回<code>"Inside"</code>
</section>
请使用逻辑或运算符把两个 if 语句合并为一个 if 语句,如果`val`不在 10 和 20 之间(包括 10 和 20),返回`"Outside"`。反之,返回`"Inside"`
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: 你应该使用一次<code>||</code>操作符。
testString: assert(code.match(/\|\|/g).length === 1);
- text: 你应该只有一个<code>if</code>表达式。
testString: assert(code.match(/if/g).length === 1);
- text: <code>testLogicalOr(0)</code>应该返回 "Outside"。
testString: assert(testLogicalOr(0) === "Outside");
- text: <code>testLogicalOr(9)</code>应该返回 "Outside"。
testString: assert(testLogicalOr(9) === "Outside");
- text: <code>testLogicalOr(10)</code>应该返回 "Inside"。
testString: assert(testLogicalOr(10) === "Inside");
- text: <code>testLogicalOr(15)</code>应该返回 "Inside"。
testString: assert(testLogicalOr(15) === "Inside");
- text: <code>testLogicalOr(19)</code>应该返回 "Inside"。
testString: assert(testLogicalOr(19) === "Inside");
- text: <code>testLogicalOr(20)</code>应该返回 "Inside"。
testString: assert(testLogicalOr(20) === "Inside");
- text: <code>testLogicalOr(21)</code>应该返回 "Outside"。
testString: assert(testLogicalOr(21) === "Outside");
- text: <code>testLogicalOr(25)</code>应该返回 "Outside"。
testString: assert(testLogicalOr(25) === "Outside");
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该使用一次`||`操作符。
```js
function testLogicalOr(val) {
// Only change code below this line
if (val) {
return "Outside";
}
if (val) {
return "Outside";
}
// Only change code above this line
return "Inside";
}
// Change this value to test
testLogicalOr(15);
assert(code.match(/\|\|/g).length === 1);
```
</div>
</section>
## Solution
<section id='solution'>
你应该只有一个`if`表达式。
```js
function testLogicalOr(val) {
if (val < 10 || val > 20) {
return "Outside";
}
return "Inside";
}
assert(code.match(/if/g).length === 1);
```
</section>
`testLogicalOr(0)`应该返回 "Outside"。
```js
assert(testLogicalOr(0) === 'Outside');
```
`testLogicalOr(9)`应该返回 "Outside"。
```js
assert(testLogicalOr(9) === 'Outside');
```
`testLogicalOr(10)`应该返回 "Inside"。
```js
assert(testLogicalOr(10) === 'Inside');
```
`testLogicalOr(15)`应该返回 "Inside"。
```js
assert(testLogicalOr(15) === 'Inside');
```
`testLogicalOr(19)`应该返回 "Inside"。
```js
assert(testLogicalOr(19) === 'Inside');
```
`testLogicalOr(20)`应该返回 "Inside"。
```js
assert(testLogicalOr(20) === 'Inside');
```
`testLogicalOr(21)`应该返回 "Outside"。
```js
assert(testLogicalOr(21) === 'Outside');
```
`testLogicalOr(25)`应该返回 "Outside"。
```js
assert(testLogicalOr(25) === 'Outside');
```
# --solutions--

View File

@ -1,17 +1,20 @@
---
id: 56533eb9ac21ba0edf2244af
title: 复合赋值之 +=
challengeType: 1
videoUrl: 'https://scrimba.com/c/cDR6LCb'
forumTopicId: 16661
title: 复合赋值之 +=
---
## Description
<section id='description'>
在编程当中,通常通过赋值来修改变量的内容。记住,赋值时 Javascript 会先计算<code>=</code>右边的内容,所以我们可以写这样的语句:
<code>myVar = myVar + 5;</code>
# --description--
在编程当中,通常通过赋值来修改变量的内容。记住,赋值时 Javascript 会先计算`=`右边的内容,所以我们可以写这样的语句:
`myVar = myVar + 5;`
以上是最常见的运算赋值语句,即先运算、再赋值。还有一类操作符是一步到位既做运算也赋值的。
其中一种就是<code>+=</code>运算符。
其中一种就是`+=`运算符。
```js
var myVar = 1;
@ -19,77 +22,45 @@ myVar += 5;
console.log(myVar); // Returns 6
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
使用<code>+=</code>操作符实现同样的效果。
</section>
使用`+=`操作符实现同样的效果。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>a</code>应该等于<code>15</code>。
testString: assert(a === 15);
- text: <code>b</code>应该等于<code>26</code>。
testString: assert(b === 26);
- text: <code>c</code>应该等于<code>19</code>。
testString: assert(c === 19);
- text: 你应该对每个变量使用<code>+=</code>操作符。
testString: assert(code.match(/\+=/g).length === 3);
- text: 不要修改注释上面的代码。
testString: assert(/var a = 3;/.test(code) && /var b = 17;/.test(code) && /var c = 12;/.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`a`应该等于`15`
```js
var a = 3;
var b = 17;
var c = 12;
// Only modify code below this line
a = a + 12;
b = 9 + b;
c = c + 7;
assert(a === 15);
```
</div>
### After Test
<div id='js-teardown'>
`b`应该等于`26`
```js
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
assert(b === 26);
```
</div>
</section>
## Solution
<section id='solution'>
`c`应该等于`19`
```js
var a = 3;
var b = 17;
var c = 12;
a += 12;
b += 9;
c += 7;
assert(c === 19);
```
</section>
你应该对每个变量使用`+=`操作符。
```js
assert(code.match(/\+=/g).length === 3);
```
不要修改注释上面的代码。
```js
assert(
/var a = 3;/.test(code) &&
/var b = 17;/.test(code) &&
/var c = 12;/.test(code)
);
```
# --solutions--

View File

@ -1,88 +1,60 @@
---
id: 56533eb9ac21ba0edf2244b2
title: 复合赋值之 /=
challengeType: 1
videoUrl: 'https://scrimba.com/c/c2QvKT2'
forumTopicId: 16659
title: 复合赋值之 /=
---
## Description
<section id='description'>
<code>/=</code>操作符是让变量与另一个数相除并赋值。
<code>myVar = myVar / 5;</code>
变量<code>myVar</code>等于自身除以<code>5</code>的值。等价于:
<code>myVar /= 5;</code>
</section>
# --description--
## Instructions
<section id='instructions'>
使用<code>/=</code>操作符实现同样的效果。
</section>
`/=`操作符是让变量与另一个数相除并赋值。
## Tests
<section id='tests'>
`myVar = myVar / 5;`
```yml
tests:
- text: <code>a</code>应该等于<code>4</code>。
testString: assert(a === 4);
- text: <code>b</code>应该等于<code>27</code>。
testString: assert(b === 27);
- text: <code>c</code>应该等于<code>3</code>。
testString: assert(c === 3);
- text: 应该对每个变量使用<code>/=</code>操作符。
testString: assert(code.match(/\/=/g).length === 3);
- text: 不要修改注释上面的代码。
testString: assert(/var a = 48;/.test(code) && /var b = 108;/.test(code) && /var c = 33;/.test(code));
变量`myVar`等于自身除以`5`的值。等价于:
```
`myVar /= 5;`
</section>
# --instructions--
## Challenge Seed
<section id='challengeSeed'>
使用`/=`操作符实现同样的效果。
<div id='js-seed'>
# --hints--
`a`应该等于`4`
```js
var a = 48;
var b = 108;
var c = 33;
// Only modify code below this line
a = a / 12;
b = b / 4;
c = c / 11;
assert(a === 4);
```
</div>
### After Test
<div id='js-teardown'>
`b`应该等于`27`
```js
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
assert(b === 27);
```
</div>
</section>
## Solution
<section id='solution'>
`c`应该等于`3`
```js
var a = 48;
var b = 108;
var c = 33;
a /= 12;
b /= 4;
c /= 11;
assert(c === 3);
```
</section>
应该对每个变量使用`/=`操作符。
```js
assert(code.match(/\/=/g).length === 3);
```
不要修改注释上面的代码。
```js
assert(
/var a = 48;/.test(code) &&
/var b = 108;/.test(code) &&
/var c = 33;/.test(code)
);
```
# --solutions--

View File

@ -1,89 +1,60 @@
---
id: 56533eb9ac21ba0edf2244b1
title: 复合赋值之 *=
challengeType: 1
videoUrl: 'https://scrimba.com/c/c83vrfa'
forumTopicId: 16662
title: 复合赋值之 *=
---
## Description
<section id='description'>
<code>*=</code>操作符是让变量与一个数相乘并赋值。
<code>myVar = myVar * 5;</code>
变量<code>myVar</code>等于自身与数值<code>5</code>相乘的值。也可以写作这样的形式:
<code>myVar *= 5;</code>
</section>
# --description--
## Instructions
<section id='instructions'>
使用<code>*=</code>操作符实现同样的效果。
</section>
`*=`操作符是让变量与一个数相乘并赋值。
## Tests
<section id='tests'>
`myVar = myVar * 5;`
```yml
tests:
- text: <code>a</code>应该等于<code>25</code>。
testString: assert(a === 25);
- text: <code>b</code>应该等于<code>36</code>。
testString: assert(b === 36);
- text: <code>c</code>应该等于<code>46</code>。
testString: assert(c === 46);
- text: 应该对每个变量使用<code>*=</code>操作符。
testString: assert(code.match(/\*=/g).length === 3);
- text: 不要修改注释上面的代码。
testString: assert(/var a = 5;/.test(code) && /var b = 12;/.test(code) && /var c = 4\.6;/.test(code));
变量`myVar`等于自身与数值`5`相乘的值。也可以写作这样的形式:
```
`myVar *= 5;`
</section>
# --instructions--
## Challenge Seed
<section id='challengeSeed'>
使用`*=`操作符实现同样的效果。
<div id='js-seed'>
# --hints--
`a`应该等于`25`
```js
var a = 5;
var b = 12;
var c = 4.6;
// Only modify code below this line
a = a * 5;
b = 3 * b;
c = c * 10;
assert(a === 25);
```
</div>
### After Test
<div id='js-teardown'>
`b`应该等于`36`
```js
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
assert(b === 36);
```
</div>
</section>
## Solution
<section id='solution'>
`c`应该等于`46`
```js
var a = 5;
var b = 12;
var c = 4.6;
a *= 5;
b *= 3;
c *= 10;
assert(c === 46);
```
</section>
应该对每个变量使用`*=`操作符。
```js
assert(code.match(/\*=/g).length === 3);
```
不要修改注释上面的代码。
```js
assert(
/var a = 5;/.test(code) &&
/var b = 12;/.test(code) &&
/var c = 4\.6;/.test(code)
);
```
# --solutions--

View File

@ -1,91 +1,58 @@
---
id: 56533eb9ac21ba0edf2244b0
title: 复合赋值之 -=
challengeType: 1
videoUrl: 'https://scrimba.com/c/c2Qv7AV'
forumTopicId: 16660
title: 复合赋值之 -=
---
## Description
<section id='description'>
<code>+=</code>操作符类似,<code>-=</code>操作符用来对一个变量进行减法赋值操作。
<code>myVar = myVar - 5;</code>
变量<code>myVar</code>等于自身减去<code>5</code>的值。也可以写成这种形式:
<code>myVar -= 5;</code>
</section>
# --description--
## Instructions
<section id='instructions'>
使用<code>-=</code>操作符实现同样的效果。
</section>
`+=`操作符类似,`-=`操作符用来对一个变量进行减法赋值操作。
## Tests
<section id='tests'>
`myVar = myVar - 5;`
```yml
tests:
- text: <code>a</code>应该等于<code>5</code>。
testString: assert(a === 5);
- text: <code>b</code>应该等于<code>-6</code>。
testString: assert(b === -6);
- text: <code>c</code>应该等于<code>2</code>。
testString: assert(c === 2);
- text: 应该对每个变量使用<code>-=</code>操作符。
testString: assert(code.match(/-=/g).length === 3);
- text: 不要修改注释上面的代码。
testString: assert(/var a = 11;/.test(code) && /var b = 9;/.test(code) && /var c = 3;/.test(code));
变量`myVar`等于自身减去`5`的值。也可以写成这种形式:
```
`myVar -= 5;`
</section>
# --instructions--
## Challenge Seed
<section id='challengeSeed'>
使用`-=`操作符实现同样的效果。
<div id='js-seed'>
# --hints--
`a`应该等于`5`
```js
var a = 11;
var b = 9;
var c = 3;
// Only modify code below this line
a = a - 6;
b = b - 15;
c = c - 1;
assert(a === 5);
```
</div>
### After Test
<div id='js-teardown'>
`b`应该等于`-6`
```js
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
assert(b === -6);
```
</div>
</section>
## Solution
<section id='solution'>
`c`应该等于`2`
```js
var a = 11;
var b = 9;
var c = 3;
a -= 6;
b -= 15;
c -= 1;
assert(c === 2);
```
</section>
应该对每个变量使用`-=`操作符。
```js
assert(code.match(/-=/g).length === 3);
```
不要修改注释上面的代码。
```js
assert(
/var a = 11;/.test(code) && /var b = 9;/.test(code) && /var c = 3;/.test(code)
);
```
# --solutions--

View File

@ -1,89 +1,53 @@
---
id: 56533eb9ac21ba0edf2244b7
title: 用加号运算符连接字符串
challengeType: 1
videoUrl: 'https://scrimba.com/c/cNpM8AN'
forumTopicId: 16802
title: 用加号运算符连接字符串
---
## Description
<section id='description'>
在 JavaScript 中,当对一个<code>String</code>类型的值使用<code>+</code>操作符的时候,它被称作 <dfn>拼接操作符</dfn>。你可以通过<dfn>拼接</dfn>其他字符串来创建一个新的字符串。
<strong>示例</strong>
# --description--
在 JavaScript 中,当对一个`String`类型的值使用`+`操作符的时候,它被称作 <dfn>拼接操作符</dfn>。你可以通过<dfn>拼接</dfn>其他字符串来创建一个新的字符串。
**示例**
```js
'My name is Alan,' + ' I concatenate.'
```
<strong>提示</strong><br>注意空格。拼接操作不会在两个字符串之间添加空格,所以想加上空格的话,你需要自己在字符串里面添加。
</section>
**提示**
注意空格。拼接操作不会在两个字符串之间添加空格,所以想加上空格的话,你需要自己在字符串里面添加。
## Instructions
<section id='instructions'>
使用<code>+</code>操作符,把字符串<code>"This is the start. "</code><code>"This is the end."</code>连接起来并赋值给变量<code>myStr</code>
</section>
# --instructions--
## Tests
<section id='tests'>
使用`+`操作符,把字符串`"This is the start. "``"This is the end."`连接起来并赋值给变量`myStr`
```yml
tests:
- text: <code>myStr</code>的值应该是<code>This is the start. This is the end.</code>。
testString: assert(myStr === "This is the start. This is the end.");
- text: 使用<code>+</code>操作符构建<code>myStr</code>。
testString: assert(code.match(/(["']).*(["'])\s*\+\s*(["']).*(["'])/g).length > 1);
- text: <code>myStr</code>应该被<code>var</code>关键字声明。
testString: assert(/var\s+myStr/.test(code));
- text: 确保有给<code>myStr</code>赋值。
testString: assert(/myStr\s*=/.test(code));
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myStr`的值应该是`This is the start. This is the end.`
```js
// Example
var ourStr = "I come first. " + "I come second.";
// Only change code below this line
var myStr;
assert(myStr === 'This is the start. This is the end.');
```
</div>
### After Test
<div id='js-teardown'>
使用`+`操作符构建`myStr`
```js
(function(){
if(typeof myStr === 'string') {
return 'myStr = "' + myStr + '"';
} else {
return 'myStr is not a string';
}
})();
assert(code.match(/(["']).*(["'])\s*\+\s*(["']).*(["'])/g).length > 1);
```
</div>
</section>
## Solution
<section id='solution'>
`myStr`应该被`var`关键字声明。
```js
var ourStr = "I come first. " + "I come second.";
var myStr = "This is the start. " + "This is the end.";
assert(/var\s+myStr/.test(code));
```
</section>
确保有给`myStr`赋值。
```js
assert(/myStr\s*=/.test(code));
```
# --solutions--

View File

@ -1,83 +1,39 @@
---
id: 56533eb9ac21ba0edf2244b8
title: 用 += 运算符连接字符串
challengeType: 1
videoUrl: 'https://scrimba.com/c/cbQmmC4'
forumTopicId: 16803
title: 用 += 运算符连接字符串
---
## Description
<section id='description'>
我们还可以使用<code>+=</code>运算符来<dfn>concatenate</dfn>(拼接)字符串到现有字符串的结尾。对于那些被分割成几段的长的字符串来说,这一操作是非常有用的。
<strong>提示</strong><br>注意空格。拼接操作不会在两个字符串之间添加空格,所以如果想要加上空格的话,你需要自己在字符串里面添加。
</section>
# --description--
## Instructions
<section id='instructions'>
通过使用<code>+=</code>操作符来连接这两个字符串:<br><code>"This is the first sentence. "</code><code>"This is the second sentence."</code>并赋给变量<code>myStr</code>
</section>
我们还可以使用`+=`运算符来<dfn>concatenate</dfn>(拼接)字符串到现有字符串的结尾。对于那些被分割成几段的长的字符串来说,这一操作是非常有用的。
## Tests
<section id='tests'>
**提示**
注意空格。拼接操作不会在两个字符串之间添加空格,所以如果想要加上空格的话,你需要自己在字符串里面添加。
```yml
tests:
- text: <code>myStr</code>的值应该是<code>This is the first sentence. This is the second sentence.</code>。
testString: assert(myStr === "This is the first sentence. This is the second sentence.");
- text: 使用<code>+=</code>操作符创建<code>myStr</code>变量。
testString: assert(code.match(/\w\s*\+=\s*["']/g).length > 1 && code.match(/\w\s*\=\s*["']/g).length > 1);
# --instructions--
```
通过使用`+=`操作符来连接这两个字符串:
`"This is the first sentence. "``"This is the second sentence."`并赋给变量`myStr`
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myStr`的值应该是`This is the first sentence. This is the second sentence.`
```js
// Example
var ourStr = "I come first. ";
ourStr += "I come second.";
// Only change code below this line
var myStr;
assert(myStr === 'This is the first sentence. This is the second sentence.');
```
</div>
### After Test
<div id='js-teardown'>
使用`+=`操作符创建`myStr`变量。
```js
(function(){
if(typeof myStr === 'string') {
return 'myStr = "' + myStr + '"';
} else {
return 'myStr is not a string';
}
})();
assert(
code.match(/\w\s*\+=\s*["']/g).length > 1 &&
code.match(/\w\s*\=\s*["']/g).length > 1
);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var ourStr = "I come first. ";
ourStr += "I come second.";
var myStr = "This is the first sentence. ";
myStr += "This is the second sentence.";
```
</section>

View File

@ -1,86 +1,32 @@
---
id: 56533eb9ac21ba0edf2244b9
title: 用变量构造字符串
challengeType: 1
videoUrl: 'https://scrimba.com/c/cqk8rf4'
forumTopicId: 16805
title: 用变量构造字符串
---
## Description
<section id='description'>
有时候你需要创建一个类似<a href="https://en.wikipedia.org/wiki/Mad_Libs" target="_blank">Mad Libs</a>(填词游戏)风格的字符串。通过使用连接运算符<code> + </code>,你可以插入一个或多个变量来组成一个字符串。
</section>
# --description--
## Instructions
<section id='instructions'>
把你的名字赋值给变量<code>myName</code>,然后把变量<code>myName</code>插入到字符串<code>"My name is "</code><code>" and I am well!"</code>之间,并把连接后的结果赋值给变量<code>myStr</code>
</section>
有时候你需要创建一个类似[Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs)(填词游戏)风格的字符串。通过使用连接运算符`+`,你可以插入一个或多个变量来组成一个字符串。
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: <code>myName</code>至少要包含三个字符。
testString: assert(typeof myName !== 'undefined' && myName.length > 2);
- text: 使用两个<code>+</code>操作符创建包含<code>myName</code>的<code>myStr</code>变量。
testString: assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
把你的名字赋值给变量`myName`,然后把变量`myName`插入到字符串`"My name is "``" and I am well!"`之间,并把连接后的结果赋值给变量`myStr`
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myName`至少要包含三个字符。
```js
// Example
var ourName = "freeCodeCamp";
var ourStr = "Hello, our name is " + ourName + ", how are you?";
// Only change code below this line
var myName;
var myStr;
assert(typeof myName !== 'undefined' && myName.length > 2);
```
</div>
### After Test
<div id='js-teardown'>
使用两个`+`操作符创建包含`myName``myStr`变量。
```js
(function(){
var output = [];
if(typeof myName === 'string') {
output.push('myName = "' + myName + '"');
} else {
output.push('myName is not a string');
}
if(typeof myStr === 'string') {
output.push('myStr = "' + myStr + '"');
} else {
output.push('myStr is not a string');
}
return output.join('\n');
})();
assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myName = "Bob";
var myStr = "My name is " + myName + " and I am well!";
```
</section>

View File

@ -1,16 +1,18 @@
---
id: 56105e7b514f539506016a5e
title: 使用 For 循环反向遍历数组
challengeType: 1
videoUrl: 'https://scrimba.com/c/c2R6BHa'
forumTopicId: 16808
title: 使用 For 循环反向遍历数组
---
## Description
<section id='description'>
# --description--
for循环也可以逆向迭代只要我们定义好合适的条件。
为了让每次倒数递减 2我们需要改变我们的<code>初始化</code><code>条件判断</code><code>计数器</code>
我们让<code>i = 10</code>,并且当<code>i > 0</code>的时候才继续循环。我们使用<code>i -= 2</code>来让<code>i</code>每次循环递减 2
为了让每次倒数递减 2我们需要改变我们的`初始化``条件判断``计数器`
我们让`i = 10`,并且当`i > 0`的时候才继续循环。我们使用`i -= 2`来让`i`每次循环递减 2。
```js
var ourArray = [];
@ -19,79 +21,31 @@ for (var i=10; i > 0; i-=2) {
}
```
循环结束后,<code>ourArray</code>的值为<code>[10,8,6,4,2]</code>
让我们改变<code>初始化</code><code>计数器</code>,这样我们就可以按照奇数从后往前两两倒着数。
</section>
循环结束后,`ourArray`的值为`[10,8,6,4,2]`。 让我们改变`初始化``计数器`,这样我们就可以按照奇数从后往前两两倒着数
## Instructions
<section id='instructions'>
使用一个<code>for</code>循环,把 9 到 1 的奇数添加进<code>myArray</code>
</section>
# --instructions--
## Tests
<section id='tests'>
使用一个`for`循环,把 9 到 1 的奇数添加进`myArray`
```yml
tests:
- text: 你应该使用<code>for</code>循环。
testString: assert(code.match(/for\s*\(/g).length > 1);
- text: 你应该使用数组方法<code>push</code>。
testString: assert(code.match(/myArray.push/));
- text: <code>myArray</code>应该等于<code>[9,7,5,3,1]</code>。
testString: assert.deepEqual(myArray, [9,7,5,3,1]);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该使用`for`循环。
```js
// Example
var ourArray = [];
for (var i = 10; i > 0; i -= 2) {
ourArray.push(i);
}
// Setup
var myArray = [];
// Only change code below this line.
assert(code.match(/for\s*\(/g).length > 1);
```
</div>
### After Test
<div id='js-teardown'>
你应该使用数组方法`push`
```js
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
assert(code.match(/myArray.push/));
```
</div>
</section>
## Solution
<section id='solution'>
`myArray`应该等于`[9,7,5,3,1]`
```js
var ourArray = [];
for (var i = 10; i > 0; i -= 2) {
ourArray.push(i);
}
var myArray = [];
for (var i = 9; i > 0; i -= 2) {
myArray.push(i);
}
assert.deepEqual(myArray, [9, 7, 5, 3, 1]);
```
</section>
# --solutions--

View File

@ -1,107 +1,156 @@
---
id: 565bbe00e9cc8ac0725390f4
title: 21点游戏
challengeType: 1
videoUrl: 'https://scrimba.com/c/c6KE7ty'
forumTopicId: 16809
title: 21点游戏
---
## Description
<section id='description'>
在赌场 21 点游戏中,玩家可以通过计算牌桌上已经发放的卡牌的高低值来让自己在游戏中保持优势,这就叫<a href='https://www.douban.com/note/273781969/' target='_blank'> 21 点算法</a>
根据下面的表格,每张卡牌都分配了一个值。如果卡牌的值<count>大于 0那么玩家应该追加赌注。反之追加少许赌注甚至不追加赌注。
<table class="table table-striped"><thead><tr><th>Count Change</th><th>Cards</th></tr></thead><tbody><tr><td>+1</td><td>2, 3, 4, 5, 6</td></tr><tr><td>0</td><td>7, 8, 9</td></tr><tr><td>-1</td><td>10, 'J', 'Q', 'K', 'A'</td></tr></tbody></table>
你需要写一个函数实现 21 点算法,它根据参数<code>card</code>的值来递增或递减变量<code>count</code>,函数返回一个由当前<code>count</code><code>Bet</code><code>count>0</code>)或<code>Hold</code><code>count<=0</code>)拼接的字符串。注意<code>count</code><code>"Bet"</code><code>Hold</code>应该用空格分开。
# --description--
<strong>例如:</strong><br><code>-3 Hold<br>5 Bet</code>
在赌场 21 点游戏中,玩家可以通过计算牌桌上已经发放的卡牌的高低值来让自己在游戏中保持优势,这就叫[21 点算法](https://www.douban.com/note/273781969/)。
<strong>提示</strong><br>既然 card 的值为 7、8、9 时count 值不变,那我们就可以忽略这种情况
</section>
根据下面的表格,每张卡牌都分配了一个值。如果卡牌的值大于 0那么玩家应该追加赌注。反之追加少许赌注甚至不追加赌注
## Instructions
<section id='instructions'>
<table class='table table-striped'><thead><tr><th>Count Change</th><th>Cards</th></tr></thead><tbody><tr><td>+1</td><td>2, 3, 4, 5, 6</td></tr><tr><td>0</td><td>7, 8, 9</td></tr><tr><td>-1</td><td>10, 'J', 'Q', 'K', 'A'</td></tr></tbody></table>
你需要写一个函数实现 21 点算法,它根据参数<code>card</code>的值来递增或递减变量<code>count</code>,函数返回一个由当前<code>count</code><code>Bet</code><code>count>0</code>)或<code>Hold</code><code>count&#x3C;=0</code>)拼接的字符串。注意<code>count</code><code>"Bet"</code><code>Hold</code>应该用空格分开。</count>
</section>
**例如:**
<code>-3 Hold<br>5 Bet</code>
## Tests
<section id='tests'>
**提示**
既然 card 的值为 7、8、9 时count 值不变,那我们就可以忽略这种情况。
```yml
tests:
- text: Cards Sequence 2, 3, 4, 5, 6 应该返回<code>5 Bet</code>。
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: Cards Sequence 7, 8, 9 应该返回 <code>0 Hold</code>。
testString: assert((function(){ count = 0; cc(7);cc(8);var out = cc(9); if(out === "0 Hold") {return true;} return false; })());
- text: Cards Sequence 10, J, Q, K, A 应该返回 <code>-5 Hold</code>。
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: Cards Sequence 3, 7, Q, 8, A 应该返回 <code>-1 Hold</code>。
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: Cards Sequence 2, J, 9, 2, 7 应该返回 <code>1 Bet</code>。
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: Cards Sequence 2, 2, 10 应该返回 <code>1 Bet</code>。
testString: assert((function(){ count = 0; cc(2);cc(2);var out = cc(10); if(out === "1 Bet") {return true;} return false; })());
- text: Cards Sequence 3, 2, A, 10, K 应该返回 <code>-1 Hold</code>。
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; })());
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
Cards Sequence 2, 3, 4, 5, 6 应该返回`5 Bet`
```js
var count = 0;
function cc(card) {
// Only change code below this line
return "Change Me";
// Only change code above this line
}
// Add/remove calls to test your function.
// Note: Only the last will display
cc(2); cc(3); cc(7); cc('K'); cc('A');
assert(
(function () {
count = 0;
cc(2);
cc(3);
cc(4);
cc(5);
var out = cc(6);
if (out === '5 Bet') {
return true;
}
return false;
})()
);
```
</div>
</section>
## Solution
<section id='solution'>
Cards Sequence 7, 8, 9 应该返回 `0 Hold`
```js
var count = 0;
function cc(card) {
switch(card) {
case 2:
case 3:
case 4:
case 5:
case 6:
count++;
break;
case 10:
case 'J':
case 'Q':
case 'K':
case 'A':
count--;
}
if(count > 0) {
return count + " Bet";
} else {
return count + " Hold";
}
}
assert(
(function () {
count = 0;
cc(7);
cc(8);
var out = cc(9);
if (out === '0 Hold') {
return true;
}
return false;
})()
);
```
</section>
Cards Sequence 10, J, Q, K, A 应该返回 `-5 Hold`
```js
assert(
(function () {
count = 0;
cc(10);
cc('J');
cc('Q');
cc('K');
var out = cc('A');
if (out === '-5 Hold') {
return true;
}
return false;
})()
);
```
Cards Sequence 3, 7, Q, 8, A 应该返回 `-1 Hold`
```js
assert(
(function () {
count = 0;
cc(3);
cc(7);
cc('Q');
cc(8);
var out = cc('A');
if (out === '-1 Hold') {
return true;
}
return false;
})()
);
```
Cards Sequence 2, J, 9, 2, 7 应该返回 `1 Bet`
```js
assert(
(function () {
count = 0;
cc(2);
cc('J');
cc(9);
cc(2);
var out = cc(7);
if (out === '1 Bet') {
return true;
}
return false;
})()
);
```
Cards Sequence 2, 2, 10 应该返回 `1 Bet`
```js
assert(
(function () {
count = 0;
cc(2);
cc(2);
var out = cc(10);
if (out === '1 Bet') {
return true;
}
return false;
})()
);
```
Cards Sequence 3, 2, A, 10, K 应该返回 `-1 Hold`
```js
assert(
(function () {
count = 0;
cc(3);
cc(2);
cc('A');
cc(10);
var out = cc('K');
if (out === '-1 Hold') {
return true;
}
return false;
})()
);
```
# --solutions--

View File

@ -1,69 +1,35 @@
---
id: cf1391c1c11feddfaeb4bdef
title: 创建一个小数
challengeType: 1
videoUrl: 'https://scrimba.com/c/ca8GEuW'
forumTopicId: 16826
title: 创建一个小数
---
## Description
<section id='description'>
# --description--
我们也可以把小数存储到变量中。小数也被称作<dfn>浮点数</dfn>
<strong>提示</strong><br>不是所有的实数都可以用 <dfn>浮点数</dfn> 来表示。因为可能存在四舍五入的错误,<a href="https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems" target="_blank">详情查看</a>
</section>
## Instructions
<section id='instructions'>
创建一个变量<code>myDecimal</code>并给它赋值一个浮点数。(例如<code>5.21</code>)。
</section>
**提示**
不是所有的实数都可以用 <dfn>浮点数</dfn> 来表示。因为可能存在四舍五入的错误,[详情查看](https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems)。
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: <code>myDecimal</code>应该是一个数字。
testString: assert(typeof myDecimal === "number");
- text: <code>myDecimal</code>应该包含小数点。
testString: assert(myDecimal % 1 != 0);
创建一个变量`myDecimal`并给它赋值一个浮点数。(例如`5.21`)。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myDecimal`应该是一个数字。
```js
var ourDecimal = 5.7;
// Only change code below this line
assert(typeof myDecimal === 'number');
```
</div>
### After Test
<div id='js-teardown'>
`myDecimal`应该包含小数点。
```js
(function(){if(typeof myDecimal !== "undefined"){return myDecimal;}})();
assert(myDecimal % 1 != 0);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myDecimal = 9.9;
```
</section>

View File

@ -1,78 +1,46 @@
---
id: bd7123c9c443eddfaeb5bdef
title: 声明变量
challengeType: 1
videoUrl: 'https://scrimba.com/c/cNanrHq'
forumTopicId: 17556
title: 声明变量
---
## Description
<section id='description'>
在计算机科学中,<dfn>数据</dfn>就是一切它对于计算机意义重大。JavaScript 提供七种不同的<dfn>数据类型</dfn>,它们是<code>undefined</code>(未定义), <code>null</code>(空),<code>boolean</code>(布尔型),<code>string</code>(字符串),<code>symbol</code>(符号)<code>number</code>(数字),和<code>object</code>(对象)。
例如,计算机区分数字和字符集合的字符串,例如数字<code>12</code>和字符串<code>"12"</code><code>"dog"</code><code>"123 cats"</code>。计算机可以对数字执行数学运算,但不能对字符串执行数学运算。
# --description--
在计算机科学中,<dfn>数据</dfn>就是一切它对于计算机意义重大。JavaScript 提供七种不同的<dfn>数据类型</dfn>,它们是`undefined`(未定义), `null`(空),`boolean`(布尔型),`string`(字符串),`symbol`(符号)`number`(数字),和`object`(对象)。
例如,计算机区分数字和字符集合的字符串,例如数字`12`和字符串`"12"``"dog"``"123 cats"`。计算机可以对数字执行数学运算,但不能对字符串执行数学运算。
<dfn>变量</dfn>允许计算机以一种动态的形式来存储和操作数据,通过操作指向数据的指针而不是数据本身来避免了内存泄露,以上的七种数据类型都可以存储到一个变量中。
<code>变量</code>非常类似于你在数学中使用的 xy 变量,都是以一个简单命名的名称来代替我们赋值给它的数据。计算机中的<code>变量</code>与数学中的变量不同的是,计算机可以在不同的时间存储不同类型的变量。
通过在变量的前面使用关键字<code>var</code>,声明一个变量,例如:
`变量`非常类似于你在数学中使用的 xy 变量,都是以一个简单命名的名称来代替我们赋值给它的数据。计算机中的`变量`与数学中的变量不同的是,计算机可以在不同的时间存储不同类型的变量。
通过在变量的前面使用关键字`var`,声明一个变量,例如:
```js
var ourName;
```
上面代码的意思是创建一个名为<code>ourName</code><code>变量</code>,在 JavaScript 中我们以分号结束语句
<code>变量</code>名称可以由数字、字母、美元符号<code>$</code> 或者 下划线<code>_</code>组成,但是不能包含空格或者以数字为开头。
</section>
上面代码的意思是创建一个名为`ourName``变量`,在 JavaScript 中我们以分号结束语句。 `变量`名称可以由数字、字母、美元符号`$` 或者 下划线`_`组成,但是不能包含空格或者以数字为开头
## Instructions
<section id='instructions'>
使用<code>var</code> 关键字来创建一个名为<code>myName</code>的变量。
<strong>提示</strong><br>如果遇到困难了,请看下<code>ourName</code>的例子是怎么写的。
</section>
# --instructions--
## Tests
<section id='tests'>
使用`var` 关键字来创建一个名为`myName`的变量。
```yml
tests:
- text: 你需要使用<code>var</code>关键字定义一个变量<code>myName</code>,并使用分号结尾。
testString: assert(/var\s+myName\s*;/.test(code), '你需要使用<code>var</code>关键字定义一个变量<code>myName</code>。并使用分号结尾。');
**提示**
如果遇到困难了,请看下`ourName`的例子是怎么写的。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你需要使用`var`关键字定义一个变量`myName`,并使用分号结尾。
```js
// Example
var ourName;
// Declare myName below this line
assert(
/var\s+myName\s*;/.test(code),
'你需要使用<code>var</code>关键字定义一个变量<code>myName</code>。并使用分号结尾。'
);
```
</div>
# --solutions--
### After Test
<div id='js-teardown'>
```js
if(typeof myName !== "undefined"){(function(v){return v;})(myName);}
```
</div>
</section>
## Solution
<section id='solution'>
```js
var myName;
```
</section>

View File

@ -1,73 +1,60 @@
---
id: bd7123c9c444eddfaeb5bdef
title: 声明字符串变量
challengeType: 1
videoUrl: 'https://scrimba.com/c/c2QvWU6'
forumTopicId: 17557
title: 声明字符串变量
---
## Description
<section id='description'>
# --description--
之前我们写过这样的代码:
<code>var myName = "your name";</code>
<code>"your name"</code>被称作<dfn>字符串变量</dfn>。字符串是用单引号或双引号包裹起来的一连串的零个或多个字符。
</section>
## Instructions
<section id='instructions'>
创建两个新的<code>字符串变量</code><code>myFirstName</code><code>myLastName</code>,并用你的姓和名分别为它们赋值。
</section>
`var myName = "your name";`
## Tests
<section id='tests'>
`"your name"`被称作<dfn>字符串变量</dfn>。字符串是用单引号或双引号包裹起来的一连串的零个或多个字符。
```yml
tests:
- text: <code>myFirstName</code>应该是一个字符串,并且至少包含一个字符。
testString: assert((function(){if(typeof myFirstName !== "undefined" && typeof myFirstName === "string" && myFirstName.length > 0){return true;}else{return false;}})());
- text: <code>myLastName</code>应该是一个字符串,并且至少包含一个字符。
testString: assert((function(){if(typeof myLastName !== "undefined" && typeof myLastName === "string" && myLastName.length > 0){return true;}else{return false;}})());
# --instructions--
```
创建两个新的`字符串变量``myFirstName``myLastName`,并用你的姓和名分别为它们赋值。
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myFirstName`应该是一个字符串,并且至少包含一个字符。
```js
// Example
var firstName = "Alan";
var lastName = "Turing";
// Only change code below this line
assert(
(function () {
if (
typeof myFirstName !== 'undefined' &&
typeof myFirstName === 'string' &&
myFirstName.length > 0
) {
return true;
} else {
return false;
}
})()
);
```
</div>
### After Test
<div id='js-teardown'>
`myLastName`应该是一个字符串,并且至少包含一个字符。
```js
if(typeof myFirstName !== "undefined" && typeof myLastName !== "undefined"){(function(){return myFirstName + ', ' + myLastName;})();}
assert(
(function () {
if (
typeof myLastName !== 'undefined' &&
typeof myLastName === 'string' &&
myLastName.length > 0
) {
return true;
} else {
return false;
}
})()
);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myFirstName = "Alan";
var myLastName = "Turing";
```
</section>

View File

@ -1,77 +1,55 @@
---
id: 56533eb9ac21ba0edf2244ad
title: 数字递减
challengeType: 1
videoUrl: 'https://scrimba.com/c/cM2KeS2'
forumTopicId: 17558
title: 数字递减
---
## Description
<section id='description'>
使用自减符号<code>--</code>,你可以很方便地对一个变量执行<dfn>自减</dfn>或者<code>-1</code>运算。
<code>i--;</code>
# --description--
使用自减符号`--`,你可以很方便地对一个变量执行<dfn>自减</dfn>或者`-1`运算。
`i--;`
等效于
<code>i = i - 1;</code>
<strong>提示</strong><br><code>i--;</code>这种写法,省去了书写<code>=</code>符号的必要。
</section>
## Instructions
<section id='instructions'>
重写代码,使用<code>--</code>符号对<code>myVar</code>执行自减操作。
</section>
`i = i - 1;`
## Tests
<section id='tests'>
**提示**
`i--;`这种写法,省去了书写`=`符号的必要。
```yml
tests:
- text: <code>myVar</code>应该等于<code>10</code>。
testString: assert(myVar === 10);
- text: <code>myVar = myVar - 1;</code>语句应该被修改。
testString: assert(/var\s*myVar\s*=\s*11;\s*\/*.*\s*([-]{2}\s*myVar|myVar\s*[-]{2});/.test(code));
- text: 对<code>myVar</code>使用<code>--</code>运算符。
testString: assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
- text: 不要修改注释上面的代码。
testString: assert(/var myVar = 11;/.test(code));
# --instructions--
```
重写代码,使用`--`符号对`myVar`执行自减操作。
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myVar`应该等于`10`
```js
var myVar = 11;
// Only change code below this line
myVar = myVar - 1;
assert(myVar === 10);
```
</div>
### After Test
<div id='js-teardown'>
`myVar = myVar - 1;`语句应该被修改。
```js
(function(z){return 'myVar = ' + z;})(myVar);
assert(
/var\s*myVar\s*=\s*11;\s*\/*.*\s*([-]{2}\s*myVar|myVar\s*[-]{2});/.test(code)
);
```
</div>
</section>
## Solution
<section id='solution'>
`myVar`使用`--`运算符。
```js
var myVar = 11;
myVar--;
assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
```
</section>
不要修改注释上面的代码。
```js
assert(/var myVar = 11;/.test(code));
```
# --solutions--

View File

@ -1,101 +1,34 @@
---
id: 56bbb991ad1ed5201cd392d3
title: 删除对象的属性
challengeType: 1
videoUrl: 'https://scrimba.com/c/cDqKdTv'
forumTopicId: 17560
title: 删除对象的属性
---
## Description
<section id='description'>
# --description--
我们同样可以删除对象的属性,例如:
<code>delete ourDog.bark;</code>
</section>
## Instructions
<section id='instructions'>
删除<code>myDog</code>对象的<code>"tails"</code>属性。
</section>
`delete ourDog.bark;`
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: 从<code>myDog</code>中删除<code>"tails"</code>属性。
testString: assert(typeof myDog === "object" && myDog.tails === undefined);
- text: 不要修改<code>myDog</code>的初始化。
testString: 'assert(code.match(/"tails": 1/g).length > 1);'
删除`myDog`对象的`"tails"`属性。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myDog`中删除`"tails"`属性。
```js
// Example
var ourDog = {
"name": "Camper",
"legs": 4,
"tails": 1,
"friends": ["everything!"],
"bark": "bow-wow"
};
delete ourDog.bark;
// Setup
var myDog = {
"name": "Happy Coder",
"legs": 4,
"tails": 1,
"friends": ["freeCodeCamp Campers"],
"bark": "woof"
};
// Only change code below this line.
assert(typeof myDog === 'object' && myDog.tails === undefined);
```
</div>
### After Test
<div id='js-teardown'>
不要修改`myDog`的初始化。
```js
(function(z){return z;})(myDog);
assert(code.match(/"tails": 1/g).length > 1);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var ourDog = {
"name": "Camper",
"legs": 4,
"tails": 1,
"friends": ["everything!"],
"bark": "bow-wow"
};
var myDog = {
"name": "Happy Coder",
"legs": 4,
"tails": 1,
"friends": ["freeCodeCamp Campers"],
"bark": "woof"
};
delete myDog.tails;
```
</section>

View File

@ -1,65 +1,38 @@
---
id: bd7993c9ca9feddfaeb7bdef
title: 两个小数相除
challengeType: 1
videoUrl: 'https://scrimba.com/c/cBZe9AW'
forumTopicId: 18255
title: 两个小数相除
---
## Description
<section id='description'>
# --description--
现在让我们将一个小数除以另一个小数。
</section>
## Instructions
<section id='instructions'>
改变数值<code>0.0</code>的值让变量<code>quotient</code>的值等于<code>2.2</code>.
</section>
# --instructions--
## Tests
<section id='tests'>
改变数值`0.0`的值让变量`quotient`的值等于`2.2`.
```yml
tests:
- text: <code>quotient</code>的值应该等于<code>2.2</code>。
testString: assert(quotient === 2.2);
- text: 使用<code>/</code>运算符将 4.4 除以 2。
testString: assert(/4\.40*\s*\/\s*2\.*0*/.test(code));
- text: quotient 变量应该只被赋值一次。
testString: assert(code.match(/quotient/g).length === 1);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`quotient`的值应该等于`2.2`
```js
var quotient = 0.0 / 2.0; // Fix this line
assert(quotient === 2.2);
```
</div>
### After Test
<div id='js-teardown'>
使用`/`运算符将 4.4 除以 2。
```js
(function(y){return 'quotient = '+y;})(quotient);
assert(/4\.40*\s*\/\s*2\.*0*/.test(code));
```
</div>
</section>
## Solution
<section id='solution'>
quotient 变量应该只被赋值一次。
```js
var quotient = 4.4 / 2.0;
assert(code.match(/quotient/g).length === 1);
```
</section>
# --solutions--

View File

@ -1,75 +1,40 @@
---
id: cf1111c1c11feddfaeb6bdef
title: 除法运算
challengeType: 1
videoUrl: 'https://scrimba.com/c/cqkbdAr'
forumTopicId: 17566
title: 除法运算
---
## Description
<section id='description'>
我们可以在 JavaScript 中做除法运算。
JavaScript 中使用<code>/</code>符号做除法运算。
# --description--
<strong>示例</strong>
我们可以在 JavaScript 中做除法运算。
JavaScript 中使用`/`符号做除法运算。
**示例**
```js
myVar = 16 / 2; // assigned 8
```
# --instructions--
</section>
改变数值`0`来让变量`quotient`的值等于`2`
## Instructions
<section id='instructions'>
改变数值<code>0</code>来让变量<code>quotient</code>的值等于<code>2</code>
</section>
# --hints--
## Tests
<section id='tests'>
```yml
tests:
- text: 要使<code>quotient</code>的值等于 2。
testString: assert(quotient === 2);
- text: 使用<code>/</code>运算符。
testString: assert(/\d+\s*\/\s*\d+/.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
要使`quotient`的值等于 2。
```js
var quotient = 66 / 0;
assert(quotient === 2);
```
</div>
### After Test
<div id='js-teardown'>
使用`/`运算符。
```js
(function(z){return 'quotient = '+z;})(quotient);
assert(/\d+\s*\/\s*\d+/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var quotient = 66 / 33;
```
</section>

View File

@ -1,84 +1,76 @@
---
id: 56533eb9ac21ba0edf2244b6
title: 字符串中的转义序列
challengeType: 1
videoUrl: 'https://scrimba.com/c/cvmqRh6'
forumTopicId: 17567
title: 字符串中的转义序列
---
## Description
<section id='description'>
# --description--
引号不是字符串中唯一可以被<dfn>转义</dfn>的字符。使用转义字符有两个原因:首先是可以让你使用无法输入的字符,例如退格。其次是可以让你在一个字符串中表示多个引号,而不会出错。我们在之前的挑战中学到了这个。
<table class="table table-striped"><thead><tr><th>代码</th><th>输出</th></tr></thead><tbody><tr><td><code>\'</code></td><td>单引号</td></tr><tr><td><code>\"</code></td><td>双引号</td></tr><tr><td><code>\\</code></td><td>反斜杠</td></tr><tr><td><code>\n</code></td><td>换行符</td></tr><tr><td><code>\r</code></td><td>回车符</td></tr><tr><td><code>\t</code></td><td>制表符</td></tr><tr><td><code>\b</code></td><td>退格</td></tr><tr><td><code>\f</code></td><td>换页符</td></tr></tbody></table>
<em>请注意,必须对反斜杠本身进行转义才能显示为反斜杠。</em>
</section>
## Instructions
<section id='instructions'>
使用转义字符将下面三行文本字符串赋给变量<code>myStr</code>
<blockquote>FirstLine<br/>&nbsp;&nbsp;&nbsp;&nbsp;\SecondLine<br/>ThirdLine</blockquote>
<table class='table table-striped'><thead><tr><th>代码</th><th>输出</th></tr></thead><tbody><tr><td><code>\'</code></td><td>单引号</td></tr><tr><td><code>\"</code></td><td>双引号</td></tr><tr><td><code>\\</code></td><td>反斜杠</td></tr><tr><td><code>\n</code></td><td>换行符</td></tr><tr><td><code>\r</code></td><td>回车符</td></tr><tr><td><code>\t</code></td><td>制表符</td></tr><tr><td><code>\b</code></td><td>退格</td></tr><tr><td><code>\f</code></td><td>换页符</td></tr></tbody></table>
*请注意,必须对反斜杠本身进行转义才能显示为反斜杠。*
# --instructions--
使用转义字符将下面三行文本字符串赋给变量`myStr`
<blockquote>FirstLine<br>    \SecondLine<br>ThirdLine</blockquote>
你需要使用转义字符正确地插入特殊字符,确保间距与上面文本一致并且单词或转义字符之间没有空格。
像这样用转义字符写出来:
<q>FirstLine<code>换行符</code><code>制表符</code><code>反斜杠</code>SecondLine<code>换行符</code>ThirdLine</q>
</section>
## Tests
<section id='tests'>
"FirstLine```换行符``制表符``反斜杠```SecondLine`换行符`ThirdLine"
```yml
tests:
- text: <code>myStr</code>不能包含空格。
testString: assert(!/ /.test(myStr));
- text: <code>myStr</code>应该包含字符串<code>FirstLine</code>, <code>SecondLine</code> and <code>ThirdLine</code> (记得区分大小写)。
testString: assert(/FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr));
- text: <code>FirstLine</code>后面应该是一个新行<code>\n</code>。
testString: assert(/FirstLine\n/.test(myStr));
- text: <code>myStr</code>应该包含制表符<code>\t</code>并且制表符要在换行符后面。
testString: assert(/\n\t/.test(myStr));
- text: <code>SecondLine</code>前面应该是反斜杠<code>\\</code>。
testString: assert(/\SecondLine/.test(myStr));
- text: <code>SecondLine</code>和<code>ThirdLine</code>之间应该是换行符。
testString: assert(/SecondLine\nThirdLine/.test(myStr));
- text: <code>myStr</code> 应该只包含介绍里面展示的字符串。
testString: assert(myStr === 'FirstLine\n\t\\SecondLine\nThirdLine');
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myStr`不能包含空格。
```js
var myStr; // Change this line
assert(!/ /.test(myStr));
```
</div>
### After Test
<div id='js-teardown'>
`myStr`应该包含字符串`FirstLine`, `SecondLine` and `ThirdLine` (记得区分大小写)。
```js
(function(){
if (myStr !== undefined){
console.log('myStr:\n' + myStr);}})();
assert(
/FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr)
);
```
</div>
</section>
## Solution
<section id='solution'>
`FirstLine`后面应该是一个新行`\n`。
```js
var myStr = "FirstLine\n\t\\SecondLine\nThirdLine";
assert(/FirstLine\n/.test(myStr));
```
</section>
`myStr`应该包含制表符`\t`并且制表符要在换行符后面。
```js
assert(/\n\t/.test(myStr));
```
`SecondLine`前面应该是反斜杠`\\`。
```js
assert(/\SecondLine/.test(myStr));
```
`SecondLine`和`ThirdLine`之间应该是换行符。
```js
assert(/SecondLine\nThirdLine/.test(myStr));
```
`myStr` 应该只包含介绍里面展示的字符串。
```js
assert(myStr === 'FirstLine\n\t\\SecondLine\nThirdLine');
```
# --solutions--

View File

@ -1,77 +1,42 @@
---
id: 56533eb9ac21ba0edf2244b5
title: 转义字符串中的引号
challengeType: 1
videoUrl: 'https://scrimba.com/c/c2QvgSr'
forumTopicId: 17568
title: 转义字符串中的引号
---
## Description
<section id='description'>
定义一个字符串必须要用单引号或双引号来包裹它。那么当你的字符串里面包含:<code>"</code>或者<code>'</code>时该怎么办呢?
在 JavaScript 中,你可以通过在引号前面使用<dfn>反斜杠</dfn><code>\</code>)来转义引号。
<code>var sampleStr = "Alan said, \"Peter is learning JavaScript\".";</code>
# --description--
定义一个字符串必须要用单引号或双引号来包裹它。那么当你的字符串里面包含:`"`或者`'`时该怎么办呢?
在 JavaScript 中,你可以通过在引号前面使用<dfn>反斜杠</dfn>`\`)来转义引号。
`var sampleStr = "Alan said, \"Peter is learning JavaScript\".";`
有了转义符号JavaScript 就知道这个单引号或双引号并不是字符串的结尾,而是字符串内的字符。所以,上面的字符串打印到控制台的结果为:
<code>Alan said, "Peter is learning JavaScript".</code>
</section>
## Instructions
<section id='instructions'>
使用<dfn>反斜杠</dfn>将一个字符串赋值给变量<code>myStr</code>,打印到控制台,输出为:
<code>I am a "double quoted" string inside "double quotes".</code>
</section>
`Alan said, "Peter is learning JavaScript".`
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: 你的代码中应该包含两个双引号 (<code>&quot;</code>) 以及四个转义的双引 (<code>&#92;&quot;</code>)。
testString: assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
- text: 变量 myStr 应该包含字符串<code>I am a "double quoted" string inside "double quotes".</code>。
testString: assert(myStr === "I am a \"double quoted\" string inside \"double quotes\".");
使用<dfn>反斜杠</dfn>将一个字符串赋值给变量`myStr`,打印到控制台,输出为:
```
`I am a "double quoted" string inside "double quotes".`
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你的代码中应该包含两个双引号 (`"`) 以及四个转义的双引 (`\"`)。
```js
var myStr = ""; // Change this line
assert(code.match(/\\"/g).length === 4 && code.match(/[^\\]"/g).length === 2);
```
</div>
### After Test
<div id='js-teardown'>
变量 myStr 应该包含字符串`I am a "double quoted" string inside "double quotes".`
```js
(function(){
if(typeof myStr === 'string') {
console.log("myStr = \"" + myStr + "\"");
} else {
console.log("myStr is undefined");
}
})();
assert(myStr === 'I am a "double quoted" string inside "double quotes".');
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myStr = "I am a \"double quoted\" string inside \"double quotes\".";
```
</section>

View File

@ -1,78 +1,45 @@
---
id: bd7123c9c448eddfaeb5bdef
title: 查找字符串的长度
challengeType: 1
videoUrl: 'https://scrimba.com/c/cvmqEAd'
forumTopicId: 18182
title: 查找字符串的长度
---
## Description
<section id='description'>
你可以通过在字符串变量或字符串后面写上<code>.length</code>来获得字符串变量值的长度。
<code>"Alan Peter".length; // 10</code>
例如,我们创建了一个变量<code>var firstName = "Charles"</code>,我们就可以通过使用<code>firstName.length</code>来获得<code>"Charles"</code>字符串的长度。
</section>
# --description--
## Instructions
<section id='instructions'>
使用<code>.length</code>属性来获得变量<code>lastName</code>的长度,并把它赋值给变量<code>lastNameLength</code>
</section>
你可以通过在字符串变量或字符串后面写上`.length`来获得字符串变量值的长度。
## Tests
<section id='tests'>
`"Alan Peter".length; // 10`
```yml
tests:
- text: 不能改变 <code>// Setup</code> 部分声明的变量。
testString: assert(code.match(/var lastNameLength = 0;/) && code.match(/var lastName = "Lovelace";/));
- text: <code>lastNameLength</code>应该等于 8。
testString: assert(typeof lastNameLength !== 'undefined' && lastNameLength === 8);
- text: 你应该使用 <code>.length</code> 获取 <code>lastName</code> 的长度,像这样 <code>lastName.length</code>。
testString: assert(code.match(/=\s*lastName\.length/g) && !code.match(/lastName\s*=\s*8/));
例如,我们创建了一个变量`var firstName = "Charles"`,我们就可以通过使用`firstName.length`来获得`"Charles"`字符串的长度。
```
# --instructions--
</section>
使用`.length`属性来获得变量`lastName`的长度,并把它赋值给变量`lastNameLength`
## Challenge Seed
<section id='challengeSeed'>
# --hints--
<div id='js-seed'>
不能改变 `// Setup` 部分声明的变量。
```js
// Example
var firstNameLength = 0;
var firstName = "Ada";
firstNameLength = firstName.length;
// Setup
var lastNameLength = 0;
var lastName = "Lovelace";
// Only change code below this line.
lastNameLength = lastName;
assert(
code.match(/var lastNameLength = 0;/) &&
code.match(/var lastName = "Lovelace";/)
);
```
</div>
</section>
## Solution
<section id='solution'>
`lastNameLength`应该等于 8。
```js
var firstNameLength = 0;
var firstName = "Ada";
firstNameLength = firstName.length;
var lastNameLength = 0;
var lastName = "Lovelace";
lastNameLength = lastName.length;
assert(typeof lastNameLength !== 'undefined' && lastNameLength === 8);
```
</section>
你应该使用 `.length` 获取 `lastName` 的长度,像这样 `lastName.length`
```js
assert(code.match(/=\s*lastName\.length/g) && !code.match(/lastName\s*=\s*8/));
```
# --solutions--

View File

@ -1,74 +1,50 @@
---
id: 56533eb9ac21ba0edf2244ae
title: 求余运算
challengeType: 1
videoUrl: 'https://scrimba.com/c/cWP24Ub'
forumTopicId: 18184
title: 求余运算
---
## Description
<section id='description'>
<dfn>remainder</dfn>求余运算符<code>%</code>返回两个数相除得到的余数
<strong>示例</strong>
# --description--
<dfn>remainder</dfn>求余运算符`%`返回两个数相除得到的余数
**示例**
<blockquote>5 % 2 = 1 因为<br>Math.floor(5 / 2) = 2 (商)<br>2 * 2 = 4<br>5 - 4 = 1 (余数)</blockquote>
<strong>用法</strong><br>在数学中,判断一个数是奇数还是偶数,只需要判断这个数除以 2 得到的余数是 0 还是 1。
**用法**
在数学中,判断一个数是奇数还是偶数,只需要判断这个数除以 2 得到的余数是 0 还是 1。
<blockquote>17 % 2 = 117 是奇数)<br>48 % 2 = 048 是偶数)</blockquote>
<strong>提示<strong><br>余数运算符(<dfn>remainder</dfn>)有时被错误地称为“模数”运算符。它与模数非常相似,但不能用于负数的运算。
</section>
## Instructions
<section id='instructions'>
使用<code>%</code>运算符,计算 11 除以 3 的余数,并把余数赋给变量 remainder。
</section>
**提示**
余数运算符(<dfn>remainder</dfn>)有时被错误地称为“模数”运算符。它与模数非常相似,但不能用于负数的运算。\*\*\*\*
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: 变量<code>remainder</code>应该被初始化。
testString: assert(/var\s+?remainder/.test(code));
- text: <code>remainder</code>的值应该等于<code>2</code>。
testString: assert(remainder === 2);
- text: 你应该使用<code>%</code>运算符。
testString: assert(/\s+?remainder\s*?=\s*?.*%.*;/.test(code));
使用`%`运算符,计算 11 除以 3 的余数,并把余数赋给变量 remainder。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
变量`remainder`应该被初始化。
```js
// Only change code below this line
var remainder;
assert(/var\s+?remainder/.test(code));
```
</div>
### After Test
<div id='js-teardown'>
`remainder`的值应该等于`2`
```js
(function(y){return 'remainder = '+y;})(remainder);
assert(remainder === 2);
```
</div>
</section>
## Solution
<section id='solution'>
你应该使用`%`运算符。
```js
var remainder = 11 % 3;
assert(/\s+?remainder\s*?=\s*?.*%.*;/.test(code));
```
</section>
# --solutions--

View File

@ -1,77 +1,43 @@
---
id: cf1111c1c11feddfaeb9bdef
title: 使用 JavaScript 生成随机分数
challengeType: 1
videoUrl: 'https://scrimba.com/c/cyWJJs3'
forumTopicId: 18185
title: 使用 JavaScript 生成随机分数
---
## Description
<section id='description'>
# --description--
随机数非常适合用来创建随机行为。
<code>Math.random()</code>用来生成一个在<code>0</code>(包括 0<code>1</code>(不包括 1之间的随机小数因此<code>Math.random()</code>可能返回 0 但绝不会返回 1。
<strong>提示</strong><br><a href='storing-values-with-the-assignment-operator' target='_blank'>使用赋值运算符存储值</a>这一节讲过,所有函数调用将在<code>return</code>执行之前解析,因此我们可以返回<code>Math.random()</code>函数的值。
</section>
## Instructions
<section id='instructions'>
更改<code>randomFraction</code>使其返回一个随机数而不是<code>0</code>
</section>
`Math.random()`用来生成一个在`0`(包括 0`1`(不包括 1之间的随机小数因此`Math.random()`可能返回 0 但绝不会返回 1。
## Tests
<section id='tests'>
**提示**
[使用赋值运算符存储值](storing-values-with-the-assignment-operator)这一节讲过,所有函数调用将在`return`执行之前解析,因此我们可以返回`Math.random()`函数的值。
```yml
tests:
- text: <code>randomFraction</code>应该返回一个随机数。
testString: assert(typeof randomFraction() === "number");
- text: <code>randomFraction</code>应该返回一个小数。
testString: assert((randomFraction()+''). match(/\./g));
- text: 需要使用<code>Math.random</code>生成随机的小数。
testString: assert(code.match(/Math\.random/g).length >= 0);
# --instructions--
```
更改`randomFraction`使其返回一个随机数而不是`0`
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`randomFraction`应该返回一个随机数。
```js
function randomFraction() {
// Only change code below this line.
return 0;
// Only change code above this line.
}
assert(typeof randomFraction() === 'number');
```
</div>
### After Test
<div id='js-teardown'>
`randomFraction`应该返回一个小数。
```js
(function(){return randomFraction();})();
assert((randomFraction() + '').match(/\./g));
```
</div>
</section>
## Solution
<section id='solution'>
需要使用`Math.random`生成随机的小数。
```js
function randomFraction() {
return Math.random();
}
assert(code.match(/Math\.random/g).length >= 0);
```
</section>
# --solutions--

View File

@ -1,83 +1,63 @@
---
id: cf1111c1c12feddfaeb1bdef
title: 使用 JavaScript 生成随机整数
challengeType: 1
videoUrl: 'https://scrimba.com/c/cRn6bfr'
forumTopicId: 18186
title: 使用 JavaScript 生成随机整数
---
## Description
<section id='description'>
# --description--
生成随机小数很棒,但随机数更有用的地方在于生成随机整数。
<ol><li><code>Math.random()</code>生成一个随机小数。</li><li>把这个随机小数乘以<code>20</code></li><li><code>Math.floor()</code>向下取整 获得它最近的整数。</li></ol>
记住<code>Math.random()</code>永远不会返回<code>1</code>。同时因为我们是在用<code>Math.floor()</code>向下取整,所以最终我们获得的结果不可能有<code>20</code>。这确保了我们获得了一个在0到19之间的整数。
记住`Math.random()`永远不会返回`1`。同时因为我们是在用`Math.floor()`向下取整,所以最终我们获得的结果不可能有`20`。这确保了我们获得了一个在0到19之间的整数。
把操作连缀起来,代码类似于下面:
<code>Math.floor(Math.random() * 20);</code>
我们先调用<code>Math.random()</code>把它的结果乘以20然后把上一步的结果传给<code>Math.floor()</code>,最终通过向下取整获得最近的整数。
</section>
## Instructions
<section id='instructions'>
生成一个<code>0</code><code>9</code>之间的随机整数。
</section>
`Math.floor(Math.random() * 20);`
## Tests
<section id='tests'>
我们先调用`Math.random()`把它的结果乘以20然后把上一步的结果传给`Math.floor()`,最终通过向下取整获得最近的整数。
```yml
tests:
- text: <code>myFunction</code>的结果应该是一个整数。
testString: assert(typeof randomWholeNum() === "number" && (function(){var r = randomWholeNum();return Math.floor(r) === r;})());
- text: 需要使用<code>Math.random</code>生成随机数字。
testString: assert(code.match(/Math.random/g).length > 1);
- text: 你应该将<code>Math.random</code>的结果乘以 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: 你需要使用<code>Math.floor</code>移除数字中的小数部分。
testString: assert(code.match(/Math.floor/g).length > 1);
# --instructions--
```
生成一个`0``9`之间的随机整数。
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myFunction`的结果应该是一个整数。
```js
var randomNumberBetween0and19 = Math.floor(Math.random() * 20);
function randomWholeNum() {
// Only change code below this line.
return Math.random();
}
assert(
typeof randomWholeNum() === 'number' &&
(function () {
var r = randomWholeNum();
return Math.floor(r) === r;
})()
);
```
</div>
### After Test
<div id='js-teardown'>
需要使用`Math.random`生成随机数字。
```js
(function(){return randomWholeNum();})();
assert(code.match(/Math.random/g).length > 1);
```
</div>
</section>
## Solution
<section id='solution'>
你应该将`Math.random`的结果乘以 10 来生成 0 到 9 之间的随机数。
```js
var randomNumberBetween0and19 = Math.floor(Math.random() * 20);
function randomWholeNum() {
return Math.floor(Math.random() * 10);
}
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)
);
```
</section>
你需要使用`Math.floor`移除数字中的小数部分。
```js
assert(code.match(/Math.floor/g).length > 1);
```
# --solutions--

View File

@ -1,103 +1,63 @@
---
id: cf1111c1c12feddfaeb2bdef
title: 生成某个范围内的随机整数
challengeType: 1
videoUrl: 'https://scrimba.com/c/cm83yu6'
forumTopicId: 18187
title: 生成某个范围内的随机整数
---
## Description
<section id='description'>
# --description--
我们之前生成的随机数是在0到某个数之间现在我们要生成的随机数是在两个指定的数之间。
我们需要定义一个最小值和一个最大值。
下面是我们将要使用的方法,仔细看看并尝试理解这行代码到底在干嘛:
<code>Math.floor(Math.random() * (max - min + 1)) + min</code>
</section>
## Instructions
<section id='instructions'>
创建一个叫<code>randomRange</code>的函数,参数为 myMin 和 myMax返回一个在<code>myMin</code>(包括 myMin<code>myMax</code>(包括 myMax之间的随机数。
</section>
`Math.floor(Math.random() * (max - min + 1)) + min`
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: <code>randomRange</code>返回的随机数应该大于或等于<code>myMin</code>。
testString: assert(calcMin === 5);
- text: <code>randomRange</code>返回的随机数应该小于或等于<code>myMax</code>。
testString: assert(calcMax === 15);
- text: <code>randomRange</code>应该返回一个随机整数, 而不是小数。
testString: assert(randomRange(0,1) % 1 === 0 );
- text: <code>randomRange</code>应该使用<code>myMax</code>和<code>myMin</code>, 并且返回两者之间的随机数。
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;}})());
创建一个叫`randomRange`的函数,参数为 myMin 和 myMax返回一个在`myMin`(包括 myMin`myMax`(包括 myMax之间的随机数。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`randomRange`返回的随机数应该大于或等于`myMin`
```js
// Example
function ourRandomRange(ourMin, ourMax) {
return Math.floor(Math.random() * (ourMax - ourMin + 1)) + ourMin;
}
ourRandomRange(1, 9);
// Only change code below this line.
function randomRange(myMin, myMax) {
return 0; // Change this line
}
// Change these values to test your function
var myRandom = randomRange(5, 15);
assert(calcMin === 5);
```
</div>
### After Test
<div id='js-teardown'>
`randomRange`返回的随机数应该小于或等于`myMax`
```js
var calcMin = 100;
var calcMax = -100;
for(var i = 0; i < 100; i++) {
var result = randomRange(5,15);
calcMin = Math.min(calcMin, result);
calcMax = Math.max(calcMax, result);
}
(function(){
if(typeof myRandom === 'number') {
return "myRandom = " + myRandom;
} else {
return "myRandom undefined";
}
})()
assert(calcMax === 15);
```
</div>
</section>
## Solution
<section id='solution'>
`randomRange`应该返回一个随机整数, 而不是小数。
```js
function randomRange(myMin, myMax) {
return Math.floor(Math.random() * (myMax - myMin + 1)) + myMin;
}
assert(randomRange(0, 1) % 1 === 0);
```
</section>
`randomRange`应该使用`myMax``myMin`, 并且返回两者之间的随机数。
```js
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;
}
})()
);
```
# --solutions--

View File

@ -1,136 +1,48 @@
---
id: 56533eb9ac21ba0edf2244be
title: 全局作用域和函数
challengeType: 1
videoUrl: 'https://scrimba.com/c/cQM7mCN'
forumTopicId: 18193
title: 全局作用域和函数
---
## Description
<section id='description'>
# --description--
在 JavaScript 中,<dfn>作用域</dfn>涉及到变量的作用范围。在函数外定义的变量具有 <dfn>全局</dfn> 作用域。这意味着,具有全局作用域的变量可以在代码的任何地方被调用。
这些没有使用<code>var</code>关键字定义的变量会被自动创建在全局作用域中形成全局变量。当在代码其他地方无意间定义了一个变量刚好变量名与全局变量相同这时会产生意想不到的后果。因此你应该总是使用var关键字来声明你的变量。
</section>
## Instructions
<section id='instructions'>
在函数外声明一个<code>全局</code>变量<code>myGlobal</code>,并给它一个初始值<code>10</code>
在函数<code>fun1</code>的内部,<strong></strong>使用<code>var</code>关键字来声明<code>oopsGlobal</code>,并赋值为<code>5</code>
</section>
这些没有使用`var`关键字定义的变量会被自动创建在全局作用域中形成全局变量。当在代码其他地方无意间定义了一个变量刚好变量名与全局变量相同这时会产生意想不到的后果。因此你应该总是使用var关键字来声明你的变量。
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: 应定义<code>myGlobal</code>。
testString: assert(typeof myGlobal != "undefined");
- text: <code>myGlobal</code>的值应为<code>10</code>。
testString: assert(myGlobal === 10);
- text: 应使用<code>var</code>关键字定义<code>myGlobal</code>。
testString: assert(/var\s+myGlobal/.test(code));
- text: <code>oopsGlobal</code>应为全局变量且值为<code>5</code>。
testString: assert(typeof oopsGlobal != "undefined" && oopsGlobal === 5);
在函数外声明一个`全局`变量`myGlobal`,并给它一个初始值`10`
```
在函数`fun1`的内部,**不**使用`var`关键字来声明`oopsGlobal`,并赋值为`5`
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
应定义`myGlobal`
```js
// Declare your variable here
function fun1() {
// Assign 5 to oopsGlobal Here
}
// Only change code above this line
function fun2() {
var output = "";
if (typeof myGlobal != "undefined") {
output += "myGlobal: " + myGlobal;
}
if (typeof oopsGlobal != "undefined") {
output += " oopsGlobal: " + oopsGlobal;
}
console.log(output);
}
assert(typeof myGlobal != 'undefined');
```
</div>
### Before Test
<div id='js-setup'>
`myGlobal`的值应为`10`
```js
var logOutput = "";
var originalConsole = console
function capture() {
var nativeLog = console.log;
console.log = function (message) {
logOutput = message;
if(nativeLog.apply) {
nativeLog.apply(originalConsole, arguments);
} else {
var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
nativeLog(nativeMsg);
}
};
}
function uncapture() {
console.log = originalConsole.log;
}
var oopsGlobal;
capture();
assert(myGlobal === 10);
```
</div>
### After Test
<div id='js-teardown'>
应使用`var`关键字定义`myGlobal`
```js
fun1();
fun2();
uncapture();
(function() { return logOutput || "console.log never called"; })();
assert(/var\s+myGlobal/.test(code));
```
</div>
</section>
## Solution
<section id='solution'>
`oopsGlobal`应为全局变量且值为`5`
```js
// Declare your variable here
var myGlobal = 10;
function fun1() {
// Assign 5 to oopsGlobal Here
oopsGlobal = 5;
}
// Only change code above this line
function fun2() {
var output = "";
if(typeof myGlobal != "undefined") {
output += "myGlobal: " + myGlobal;
}
if(typeof oopsGlobal != "undefined") {
output += " oopsGlobal: " + oopsGlobal;
}
console.log(output);
}
assert(typeof oopsGlobal != 'undefined' && oopsGlobal === 5);
```
</section>
# --solutions--

View File

@ -1,14 +1,15 @@
---
id: 56533eb9ac21ba0edf2244c0
title: 函数中的全局作用域和局部作用域
challengeType: 1
videoUrl: 'https://scrimba.com/c/c2QwKH2'
forumTopicId: 18194
title: 函数中的全局作用域和局部作用域
---
## Description
<section id='description'>
一个程序中有可能具有相同名称的<dfn>局部</dfn>变量 和<dfn>全局</dfn>变量。在这种情况下,<code>局部</code>变量将会优先于<code>全局</code>变量。
# --description--
一个程序中有可能具有相同名称的<dfn>局部</dfn>变量 和<dfn>全局</dfn>变量。在这种情况下,`局部`变量将会优先于`全局`变量。
下面为例:
```js
@ -19,67 +20,31 @@ function myFun() {
}
```
函数<code>myFun</code>将会返回<code>"Head"</code>,因为<code>局部变量</code>优先级更高。
</section>
函数`myFun`将会返回`"Head"`,因为`局部变量`优先级更高。
## Instructions
<section id='instructions'>
<code>myOutfit</code>添加一个局部变量来覆盖<code>outerWear</code>的值为<code>"sweater"</code>
</section>
# --instructions--
## Tests
<section id='tests'>
`myOutfit`添加一个局部变量来覆盖`outerWear`的值为`"sweater"`
```yml
tests:
- text: 不要修改全局变量<code>outerWear</code>的值。
testString: assert(outerWear === "T-Shirt");
- text: <code>myOutfit</code>应该返回<code>"sweater"</code>。
testString: assert(myOutfit() === "sweater");
- text: 不要修改<code>return</code>语句。
testString: assert(/return outerWear/.test(code));
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
不要修改全局变量`outerWear`的值。
```js
// Setup
var outerWear = "T-Shirt";
function myOutfit() {
// Only change code below this line
// Only change code above this line
return outerWear;
}
myOutfit();
assert(outerWear === 'T-Shirt');
```
</div>
</section>
## Solution
<section id='solution'>
`myOutfit`应该返回`"sweater"`
```js
var outerWear = "T-Shirt";
function myOutfit() {
var outerWear = "sweater";
return outerWear;
}
assert(myOutfit() === 'sweater');
```
</section>
不要修改`return`语句。
```js
assert(/return outerWear/.test(code));
```
# --solutions--

View File

@ -1,113 +1,88 @@
---
id: 5664820f61c48e80c9fa476c
title: 高尔夫代码
challengeType: 1
videoUrl: 'https://scrimba.com/c/c9ykNUR'
forumTopicId: 18195
title: 高尔夫代码
---
## Description
<section id='description'>
在高尔夫<a href="https://en.wikipedia.org/wiki/Golf" target="_blank">golf</a>游戏中,每个洞都有自己的标准杆数<code>par</code>,代表着距离。根据你把球打进洞所挥杆的次数<code>strokes</code>,可以计算出你的高尔夫水平。
函数将会传送 2 个参数,分别是标准杆数<code>par</code>和挥杆次数<code>strokes</code>,根据下面的表格返回正确的水平段位。
<table class="table table-striped"><thead><tr><th>Strokes</th><th>Return</th></tr></thead><tbody><tr><td>1</td><td>"Hole-in-one!"</td></tr><tr><td>&lt;= par - 2</td><td>"Eagle"</td></tr><tr><td>par - 1</td><td>"Birdie"</td></tr><tr><td>par</td><td>"Par"</td></tr><tr><td>par + 1</td><td>"Bogey"</td></tr><tr><td>par + 2</td><td>"Double Bogey"</td></tr><tr><td>&gt;= par + 3</td><td>"Go Home!"</td></tr></tbody></table>
<code>par</code><code>strokes</code>必须是数字而且是正数。
</section>
# --description--
## Instructions
<section id='instructions'>
在高尔夫[golf](https://en.wikipedia.org/wiki/Golf)游戏中,每个洞都有自己的标准杆数`par`,代表着距离。根据你把球打进洞所挥杆的次数`strokes`,可以计算出你的高尔夫水平。
</section>
函数将会传送 2 个参数,分别是标准杆数`par`和挥杆次数`strokes`,根据下面的表格返回正确的水平段位。
## Tests
<section id='tests'>
<table class='table table-striped'><thead><tr><th>Strokes</th><th>Return</th></tr></thead><tbody><tr><td>1</td><td>"Hole-in-one!"</td></tr><tr><td>&#x3C;= par - 2</td><td>"Eagle"</td></tr><tr><td>par - 1</td><td>"Birdie"</td></tr><tr><td>par</td><td>"Par"</td></tr><tr><td>par + 1</td><td>"Bogey"</td></tr><tr><td>par + 2</td><td>"Double Bogey"</td></tr><tr><td>>= par + 3</td><td>"Go Home!"</td></tr></tbody></table>
```yml
tests:
- text: <code>golfScore(4, 1)</code>应该返回 "Hole-in-one!"。
testString: assert(golfScore(4, 1) === "Hole-in-one!");
- text: <code>golfScore(4, 2)</code>应该返回 "Eagle"。
testString: assert(golfScore(4, 2) === "Eagle");
- text: <code>golfScore(5, 2)</code>应该返回 "Eagle"。
testString: assert(golfScore(5, 2) === "Eagle");
- text: <code>golfScore(4, 3)</code>应该返回 "Birdie"。
testString: assert(golfScore(4, 3) === "Birdie");
- text: <code>golfScore(4, 4)</code>应该返回 "Par"。
testString: assert(golfScore(4, 4) === "Par");
- text: <code>golfScore(1, 1)</code>应该返回 "Hole-in-one!"。
testString: assert(golfScore(1, 1) === "Hole-in-one!");
- text: <code>golfScore(5, 5)</code>应该返回 "Par"。
testString: assert(golfScore(5, 5) === "Par");
- text: <code>golfScore(4, 5)</code>应该返回 "Bogey"。
testString: assert(golfScore(4, 5) === "Bogey");
- text: <code>golfScore(4, 6)</code>应该返回 "Double Bogey"。
testString: assert(golfScore(4, 6) === "Double Bogey");
- text: <code>golfScore(4, 7)</code>应该返回 "Go Home!"。
testString: assert(golfScore(4, 7) === "Go Home!");
- text: <code>golfScore(5, 9)</code>应该返回 "Go Home!"。
testString: assert(golfScore(5, 9) === "Go Home!");
`par``strokes`必须是数字而且是正数。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`golfScore(4, 1)`应该返回 "Hole-in-one!"。
```js
var names = ["Hole-in-one!", "Eagle", "Birdie", "Par", "Bogey", "Double Bogey", "Go Home!"];
function golfScore(par, strokes) {
// Only change code below this line
return "Change Me";
// Only change code above this line
}
// Change these values to test
golfScore(5, 4);
assert(golfScore(4, 1) === 'Hole-in-one!');
```
</div>
</section>
## Solution
<section id='solution'>
`golfScore(4, 2)`应该返回 "Eagle"。
```js
function golfScore(par, strokes) {
if (strokes === 1) {
return "Hole-in-one!";
}
if (strokes <= par - 2) {
return "Eagle";
}
if (strokes === par - 1) {
return "Birdie";
}
if (strokes === par) {
return "Par";
}
if (strokes === par + 1) {
return "Bogey";
}
if(strokes === par + 2) {
return "Double Bogey";
}
return "Go Home!";
}
assert(golfScore(4, 2) === 'Eagle');
```
</section>
`golfScore(5, 2)`应该返回 "Eagle"。
```js
assert(golfScore(5, 2) === 'Eagle');
```
`golfScore(4, 3)`应该返回 "Birdie"。
```js
assert(golfScore(4, 3) === 'Birdie');
```
`golfScore(4, 4)`应该返回 "Par"。
```js
assert(golfScore(4, 4) === 'Par');
```
`golfScore(1, 1)`应该返回 "Hole-in-one!"。
```js
assert(golfScore(1, 1) === 'Hole-in-one!');
```
`golfScore(5, 5)`应该返回 "Par"。
```js
assert(golfScore(5, 5) === 'Par');
```
`golfScore(4, 5)`应该返回 "Bogey"。
```js
assert(golfScore(4, 5) === 'Bogey');
```
`golfScore(4, 6)`应该返回 "Double Bogey"。
```js
assert(golfScore(4, 6) === 'Double Bogey');
```
`golfScore(4, 7)`应该返回 "Go Home!"。
```js
assert(golfScore(4, 7) === 'Go Home!');
```
`golfScore(5, 9)`应该返回 "Go Home!"。
```js
assert(golfScore(5, 9) === 'Go Home!');
```
# --solutions--

View File

@ -1,78 +1,56 @@
---
id: 56533eb9ac21ba0edf2244ac
title: 数字递增
challengeType: 1
videoUrl: 'https://scrimba.com/c/ca8GLT9'
forumTopicId: 18201
title: 数字递增
---
## Description
<section id='description'>
使用<code>++</code>,我们可以很容易地对变量进行自增或者<code>+1</code>运算。
<code>i++;</code>
# --description--
使用`++`,我们可以很容易地对变量进行自增或者`+1`运算。
`i++;`
等效于
<code>i = i + 1;</code>
<strong>注意</strong><br><code>i++;</code>这种写法,省去了书写<code>=</code>符号的必要。
</section>
## Instructions
<section id='instructions'>
重写代码,使用<code>++</code>来对变量<code>myVar</code>进行自增操作。
<strong>提示</strong><br>了解更多关于<code>++</code>运算符<a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#%E9%80%92%E5%A2%9E_()" target="_blank">Arithmetic operators - Increment (++)</a>.
</section>
`i = i + 1;`
## Tests
<section id='tests'>
**注意**
`i++;`这种写法,省去了书写`=`符号的必要。
```yml
tests:
- text: <code>myVar</code>应该等于<code>88</code>。
testString: assert(myVar === 88);
- text: <code>myVar = myVar + 1;</code>语句应该被修改。
testString: assert(/var\s*myVar\s*=\s*87;\s*\/*.*\s*myVar\+\+;/.test(code));
- text: 使用<code>++</code>运算符。
testString: assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
- text: 不要修改注释上方的代码。
testString: assert(/var myVar = 87;/.test(code));
# --instructions--
```
重写代码,使用`++`来对变量`myVar`进行自增操作。
</section>
**提示**
了解更多关于`++`运算符[Arithmetic operators - Increment (++)](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#%E9%80%92%E5%A2%9E_()).
## Challenge Seed
<section id='challengeSeed'>
# --hints--
<div id='js-seed'>
`myVar`应该等于`88`
```js
var myVar = 87;
// Only change code below this line
myVar = myVar + 1;
assert(myVar === 88);
```
</div>
### After Test
<div id='js-teardown'>
`myVar = myVar + 1;`语句应该被修改。
```js
(function(z){return 'myVar = ' + z;})(myVar);
assert(/var\s*myVar\s*=\s*87;\s*\/*.*\s*myVar\+\+;/.test(code));
```
</div>
</section>
## Solution
<section id='solution'>
使用`++`运算符。
```js
var myVar = 87;
myVar++;
assert(/[+]{2}\s*myVar|myVar\s*[+]{2}/.test(code));
```
</section>
不要修改注释上方的代码。
```js
assert(/var myVar = 87;/.test(code));
```
# --solutions--

View File

@ -1,68 +1,30 @@
---
id: 56533eb9ac21ba0edf2244a9
title: 使用赋值运算符初始化变量
challengeType: 1
videoUrl: 'https://scrimba.com/c/cWJ4Bfb'
forumTopicId: 301171
title: 使用赋值运算符初始化变量
---
## Description
<section id='description'>
# --description--
通常在声明变量的时候会给变量<dfn>初始化</dfn>一个初始值。
<code>var myVar = 0;</code>
创建一个名为<code>myVar</code>的变量并指定一个初始值<code>0</code>
</section>
## Instructions
<section id='instructions'>
通过关键字<code>var</code>定义一个变量<code>a</code>并且给它一个初始值<code>9</code>
</section>
`var myVar = 0;`
## Tests
<section id='tests'>
创建一个名为`myVar`的变量并指定一个初始值`0`
```yml
tests:
- text: 你需要初始化<code>a</code>的值为<code>9</code>。
testString: assert(/var\s+a\s*=\s*9\s*/.test(code));
# --instructions--
```
通过关键字`var`定义一个变量`a`并且给它一个初始值`9`
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你需要初始化`a`的值为`9`
```js
// Example
var ourVar = 19;
// Only change code below this line
assert(/var\s+a\s*=\s*9\s*/.test(code));
```
</div>
# --solutions--
### After Test
<div id='js-teardown'>
```js
if(typeof a !== 'undefined') {(function(a){return "a = " + a;})(a);} else { (function() {return 'a is undefined';})(); }
```
</div>
</section>
## Solution
<section id='solution'>
```js
var a = 9;
```
</section>

View File

@ -1,14 +1,14 @@
---
id: 56533eb9ac21ba0edf2244db
title: 介绍 else if 语句
challengeType: 1
videoUrl: 'https://scrimba.com/c/caeJ2hm'
forumTopicId: 18206
title: 介绍 else if 语句
---
## Description
<section id='description'>
如果你有多个条件语句,你可以通过<code>else if</code>语句把<code>if</code>语句链起来。
# --description--
如果你有多个条件语句,你可以通过`else if`语句把`if`语句链起来。
```js
if (num > 15) {
@ -20,82 +20,59 @@ if (num > 15) {
}
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
使用<code>if else</code>实现同样的效果。
</section>
使用`if else`实现同样的效果。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: 你应该至少有两个<code>else</code>表达式。
testString: assert(code.match(/else/g).length > 1);
- text: 你应该至少有两个<code>if</code>表达式。
testString: assert(code.match(/if/g).length > 1);
- text: <code>testElseIf(0)</code>应该返回 "Smaller than 5"。
testString: assert(testElseIf(0) === "Smaller than 5");
- text: <code>testElseIf(5)</code>应该返回 "Between 5 and 10"。
testString: assert(testElseIf(5) === "Between 5 and 10");
- text: <code>testElseIf(7)</code>应该返回 "Between 5 and 10"。
testString: assert(testElseIf(7) === "Between 5 and 10");
- text: <code>testElseIf(10)</code>应该返回 "Between 5 and 10"。
testString: assert(testElseIf(10) === "Between 5 and 10");
- text: <code>testElseIf(12)</code>应该返回 "Greater than 10"。
testString: assert(testElseIf(12) === "Greater than 10");
- text: <code>testElseIf(12)</code> 应该返回 "Greater than 10"。
testString: assert(testElseIf(12) === "Greater than 10");
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该至少有两个`else`表达式。
```js
function testElseIf(val) {
if (val > 10) {
return "Greater than 10";
}
if (val < 5) {
return "Smaller than 5";
}
return "Between 5 and 10";
}
// Change this value to test
testElseIf(7);
assert(code.match(/else/g).length > 1);
```
</div>
</section>
## Solution
<section id='solution'>
你应该至少有两个`if`表达式。
```js
function testElseIf(val) {
if(val > 10) {
return "Greater than 10";
} else if(val < 5) {
return "Smaller than 5";
} else {
return "Between 5 and 10";
}
}
assert(code.match(/if/g).length > 1);
```
</section>
`testElseIf(0)`应该返回 "Smaller than 5"。
```js
assert(testElseIf(0) === 'Smaller than 5');
```
`testElseIf(5)`应该返回 "Between 5 and 10"。
```js
assert(testElseIf(5) === 'Between 5 and 10');
```
`testElseIf(7)`应该返回 "Between 5 and 10"。
```js
assert(testElseIf(7) === 'Between 5 and 10');
```
`testElseIf(10)`应该返回 "Between 5 and 10"。
```js
assert(testElseIf(10) === 'Between 5 and 10');
```
`testElseIf(12)`应该返回 "Greater than 10"。
```js
assert(testElseIf(12) === 'Greater than 10');
```
`testElseIf(12)` 应该返回 "Greater than 10"。
```js
assert(testElseIf(12) === 'Greater than 10');
```
# --solutions--

View File

@ -1,14 +1,14 @@
---
id: 56533eb9ac21ba0edf2244da
title: 介绍 else 语句
challengeType: 1
videoUrl: 'https://scrimba.com/c/cek4Efq'
forumTopicId: 18207
title: 介绍 else 语句
---
## Description
<section id='description'>
<code>if</code>语句的条件为真大括号里的代码执行那如果条件为假呢正常情况下什么也不会发生。使用else语句可以执行当条件为假时相应的代码。
# --description--
`if`语句的条件为真大括号里的代码执行那如果条件为假呢正常情况下什么也不会发生。使用else语句可以执行当条件为假时相应的代码。
```js
if (num > 10) {
@ -18,84 +18,53 @@ if (num > 10) {
}
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
请把多个<code>if</code>语句合并为一个<code>if/else</code>语句。
</section>
请把多个`if`语句合并为一个`if/else`语句。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: 你应该只有一个<code>if</code>表达式。
testString: assert(code.match(/if/g).length === 1);
- text: 你应该使用一个<code>else</code>表达式。
testString: assert(/else/g.test(code));
- text: <code>testElse(4)</code>应该返回 "5 or Smaller"。
testString: assert(testElse(4) === "5 or Smaller");
- text: <code>testElse(5)</code>应该返回 "5 or Smaller"。
testString: assert(testElse(5) === "5 or Smaller");
- text: <code>testElse(6)</code>应该返回 "Bigger than 5"。
testString: assert(testElse(6) === "Bigger than 5");
- text: <code>testElse(10)</code>应该返回 "Bigger than 5"。
testString: assert(testElse(10) === "Bigger than 5");
- text: 不要修改上面和下面的代码。
testString: assert(/var result = "";/.test(code) && /return result;/.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该只有一个`if`表达式。
```js
function testElse(val) {
var result = "";
// Only change code below this line
if (val > 5) {
result = "Bigger than 5";
}
if (val <= 5) {
result = "5 or Smaller";
}
// Only change code above this line
return result;
}
// Change this value to test
testElse(4);
assert(code.match(/if/g).length === 1);
```
</div>
</section>
## Solution
<section id='solution'>
你应该使用一个`else`表达式。
```js
function testElse(val) {
var result = "";
if(val > 5) {
result = "Bigger than 5";
} else {
result = "5 or Smaller";
}
return result;
}
assert(/else/g.test(code));
```
</section>
`testElse(4)`应该返回 "5 or Smaller"。
```js
assert(testElse(4) === '5 or Smaller');
```
`testElse(5)`应该返回 "5 or Smaller"。
```js
assert(testElse(5) === '5 or Smaller');
```
`testElse(6)`应该返回 "Bigger than 5"。
```js
assert(testElse(6) === 'Bigger than 5');
```
`testElse(10)`应该返回 "Bigger than 5"。
```js
assert(testElse(10) === 'Bigger than 5');
```
不要修改上面和下面的代码。
```js
assert(/var result = "";/.test(code) && /return result;/.test(code));
```
# --solutions--

View File

@ -1,16 +1,18 @@
---
id: 56104e9e514f539506016a5c
title: 使用 For 循环遍历数组的奇数
challengeType: 1
videoUrl: 'https://scrimba.com/c/cm8n7T9'
forumTopicId: 18212
title: 使用 For 循环遍历数组的奇数
---
## Description
<section id='description'>
for循环可以按照我们指定的顺序来迭代通过更改我们的<code>计数器</code>,我们可以按照偶数顺序来迭代。
初始化<code>i = 0</code>,当<code>i < 10</code>的时候继续循环。
<code>i += 2</code><code>i</code>每次循环之后增加2
# --description--
for循环可以按照我们指定的顺序来迭代通过更改我们的`计数器`,我们可以按照偶数顺序来迭代。
初始化`i = 0`,当`i < 10`的时候继续循环
`i += 2``i`每次循环之后增加2。
```js
var ourArray = [];
@ -19,77 +21,25 @@ for (var i = 0; i < 10; i += 2) {
}
```
循环结束后,<code>ourArray</code>的值为<code>[0,2,4,6,8]</code>
改变<code>计数器</code>,这样我们可以用奇数来数。
</section>
循环结束后,`ourArray`的值为`[0,2,4,6,8]`。 改变`计数器`,这样我们可以用奇数来数
## Instructions
<section id='instructions'>
写一个<code>for</code>循环,把从 1 到 9 的奇数添加到<code>myArray</code>
</section>
# --instructions--
## Tests
<section id='tests'>
写一个`for`循环,把从 1 到 9 的奇数添加到`myArray`
```yml
tests:
- text: 你应该使用<code>for</code>循环。
testString: assert(code.match(/for\s*\(/g).length > 1);
- text: <code>myArray</code>应该等于<code>[1,3,5,7,9]</code>。
testString: assert.deepEqual(myArray, [1,3,5,7,9]);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该使用`for`循环。
```js
// Example
var ourArray = [];
for (var i = 0; i < 10; i += 2) {
ourArray.push(i);
}
// Setup
var myArray = [];
// Only change code below this line.
assert(code.match(/for\s*\(/g).length > 1);
```
</div>
### After Test
<div id='js-teardown'>
`myArray`应该等于`[1,3,5,7,9]`
```js
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
assert.deepEqual(myArray, [1, 3, 5, 7, 9]);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var ourArray = [];
for (var i = 0; i < 10; i += 2) {
ourArray.push(i);
}
var myArray = [];
for (var i = 1; i < 10; i += 2) {
myArray.push(i);
}
```
</section>

View File

@ -1,14 +1,14 @@
---
id: 5675e877dbd60be8ad28edc6
title: 使用 For 循环遍历数组
challengeType: 1
videoUrl: 'https://scrimba.com/c/caeR3HB'
forumTopicId: 18216
title: 使用 For 循环遍历数组
---
## Description
<section id='description'>
迭代输出一个数组的每个元素是 JavaScript 中的常见需求,<code>for</code>循环可以做到这一点。下面的代码将输出数组 <code>arr</code>的每个元素到控制台:
# --description--
迭代输出一个数组的每个元素是 JavaScript 中的常见需求,`for`循环可以做到这一点。下面的代码将输出数组 `arr`的每个元素到控制台:
```js
var arr = [10, 9, 8, 7, 6];
@ -17,82 +17,37 @@ for (var i = 0; i < arr.length; i++) {
}
```
记住数组的索引从零开始的,这意味着数组的最后一个元素的下标是:数组的长度 -1。我们这个循环的 <dfn>条件</dfn><code>i < arr.length</code>,当<code>i</code>的值为 长度 -1 的时候循环就停止了。在这个例子中,最后一个循环是 i === 4也就是说当i的值等于arr.length时结果输出 6。
</section>
记住数组的索引从零开始的,这意味着数组的最后一个元素的下标是:数组的长度 -1。我们这个循环的 <dfn>条件</dfn>`i < arr.length`,当`i`的值为 长度 -1 的时候循环就停止了。在这个例子中,最后一个循环是 i === 4也就是说当i的值等于arr.length时结果输出 6。
## Instructions
<section id='instructions'>
声明并初始化一个变量<code>total</code><code>0</code>。使用<code>for</code>循环,使得<code>total</code>的值为<code>myArr</code>的数组中的每个元素的值的总和。
</section>
# --instructions--
## Tests
<section id='tests'>
声明并初始化一个变量`total``0`。使用`for`循环,使得`total`的值为`myArr`的数组中的每个元素的值的总和。
```yml
tests:
- text: <code>total</code>应该被声明, 并且初始化值为 0。
testString: assert(code.match(/var.*?total\s*=\s*0.*?;/));
- text: <code>total</code>应该等于 20。
testString: assert(total === 20);
- text: 你应该使用<code>for</code>循环在<code>myArr</code>中遍历。
testString: assert(code.match(/for\s*\(/g).length > 1 && code.match(/myArr\s*\[/));
- text: 不能直接把<code>total</code>设置成 20。
testString: assert(!code.match(/total[\s\+\-]*=\s*(\d(?!\s*[;,])|[1-9])/g));
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`total`应该被声明, 并且初始化值为 0。
```js
// Example
var ourArr = [ 9, 10, 11, 12];
var ourTotal = 0;
for (var i = 0; i < ourArr.length; i++) {
ourTotal += ourArr[i];
}
// Setup
var myArr = [ 2, 3, 4, 5, 6];
// Only change code below this line
assert(code.match(/var.*?total\s*=\s*0.*?;/));
```
</div>
### After Test
<div id='js-teardown'>
`total`应该等于 20。
```js
(function(){if(typeof total !== 'undefined') { return "total = " + total; } else { return "total is undefined";}})()
assert(total === 20);
```
</div>
</section>
## Solution
<section id='solution'>
你应该使用`for`循环在`myArr`中遍历。
```js
var ourArr = [ 9, 10, 11, 12];
var ourTotal = 0;
for (var i = 0; i < ourArr.length; i++) {
ourTotal += ourArr[i];
}
var myArr = [ 2, 3, 4, 5, 6];
var total = 0;
for (var i = 0; i < myArr.length; i++) {
total += myArr[i];
}
assert(code.match(/for\s*\(/g).length > 1 && code.match(/myArr\s*\[/));
```
</section>
不能直接把`total`设置成 20。
```js
assert(!code.match(/total[\s\+\-]*=\s*(\d(?!\s*[;,])|[1-9])/g));
```
# --solutions--

View File

@ -1,14 +1,14 @@
---
id: 5a2efd662fb457916e1fe604
title: do...while 循环
challengeType: 1
videoUrl: 'https://scrimba.com/c/cDqWGcp'
forumTopicId: 301172
title: do...while 循环
---
## Description
<section id='description'>
这一节我们将要学习的是<code>do...while</code>循环,它会先执行<code>do</code>里面的代码,如果<code>while</code>表达式为真则重复执行,反之则停止执行。我们来看一个例子。
# --description--
这一节我们将要学习的是`do...while`循环,它会先执行`do`里面的代码,如果`while`表达式为真则重复执行,反之则停止执行。我们来看一个例子。
```js
var ourArray = [];
@ -19,8 +19,7 @@ do {
} while (i < 5);
```
这看起来和其他循环语句差不多,返回的结果是<code>[0, 1, 2, 3, 4]</code><code>do...while</code>与其他循环不同点在于,初始条件为假时的表现,让我们通过实际的例子来看看
这是一个普通的 while 循环,只要<code>i < 5</code>,它就会在循环中运行代码。
这看起来和其他循环语句差不多,返回的结果是`[0, 1, 2, 3, 4]``do...while`与其他循环不同点在于,初始条件为假时的表现,让我们通过实际的例子来看看。 这是一个普通的 while 循环,只要`i < 5`,它就会在循环中运行代码
```js
var ourArray = [];
@ -31,8 +30,7 @@ while (i < 5) {
}
```
注意,我们首先将<code>i</code>的值初始化为 5。执行下一行时注意到<code>i</code>不小于 5循环内的代码将不会执行。所以<code>ourArray</code>最终没有添加任何内容,因此示例中的所有代码执行完时,<code>ourArray</code>仍然是<code>[]</code>
现在,看一下<code>do...while</code>循环。
注意,我们首先将`i`的值初始化为 5。执行下一行时注意到`i`不小于 5循环内的代码将不会执行。所以`ourArray`最终没有添加任何内容,因此示例中的所有代码执行完时,`ourArray`仍然是`[]`。 现在,看一下`do...while`循环
```js
var ourArray = [];
@ -43,73 +41,31 @@ do {
} while (i < 5);
```
在这里,和使用 while 循环时一样,我们将<code>i</code>的值初始化为 5。执行下一行时没有检查<code>i</code>的值,直接执行花括号内的代码。数组会添加一个元素,并在进行条件检查之前递增<code>i</code>。然后,在条件检查时因为<code>i</code>等于 6 不符合条件<code>i < 5</code>,所以退出循环。最终<code>ourArray</code>的值是<code>[5]</code>
本质上,<code>do...while</code>循环确保循环内的代码至少运行一次。
让我们通过<code>do...while</code>循环将值添加到数组中。
</section>
在这里,和使用 while 循环时一样,我们将`i`的值初始化为 5。执行下一行时没有检查`i`的值,直接执行花括号内的代码。数组会添加一个元素,并在进行条件检查之前递增`i`。然后,在条件检查时因为`i`等于 6 不符合条件`i < 5`,所以退出循环。最终`ourArray`的值是`[5]`。 本质上,`do...while`循环确保循环内的代码至少运行一次。 让我们通过`do...while`循环将值添加到数组中
## Instructions
<section id='instructions'>
将代码中的<code>while</code>循环更改为<code>do...while</code>循环,实现数字 10 添加到<code>myArray</code>中,代码执行完时,<code>i</code>等于<code>11</code>
</section>
# --instructions--
## Tests
<section id='tests'>
将代码中的`while`循环更改为`do...while`循环,实现数字 10 添加到`myArray`中,代码执行完时,`i`等于`11`
```yml
tests:
- text: 你应该使用<code>do...while</code>循环。
testString: assert(code.match(/do/g));
- text: <code>myArray</code>应该等于<code>[10]</code>。
testString: assert.deepEqual(myArray, [10]);
- text: <code>i</code>应该等于<code>11</code>。
testString: assert.deepEqual(i, 11);
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该使用`do...while`循环。
```js
// Setup
var myArray = [];
var i = 10;
// Only change code below this line
while (i < 5) {
myArray.push(i);
i++;
}
assert(code.match(/do/g));
```
</div>
### After Test
<div id='js-teardown'>
`myArray`应该等于`[10]`
```js
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
assert.deepEqual(myArray, [10]);
```
</div>
</section>
## Solution
<section id='solution'>
`i`应该等于`11`
```js
var myArray = [];
var i = 10;
do {
myArray.push(i);
i++;
} while (i < 5)
assert.deepEqual(i, 11);
```
</section>
# --solutions--

View File

@ -1,21 +1,28 @@
---
id: cf1111c1c11feddfaeb5bdef
title: for 循环
challengeType: 1
videoUrl: 'https://scrimba.com/c/c9yNVCe'
forumTopicId: 18219
title: for 循环
---
## Description
<section id='description'>
# --description--
你可以使用循环多次执行相同的代码。
JavaScript 中最常见的循环就是 “<code>for循环</code>”。
JavaScript 中最常见的循环就是 “`for循环`”。
for循环中的三个表达式用分号隔开
<code>for ([初始化]; [条件判断]; [计数器])</code>
<code>初始化</code>语句只会在执行循环开始之前执行一次。它通常用于定义和设置你的循环变量。
<code>条件判断</code>语句会在每一轮循环的开始执行,只要条件判断为<code>true</code>就会继续执行循环。当条件为<code>false</code>的时候,循环将停止执行。这意味着,如果条件在一开始就为<code>false</code>,这个循环将不会执行。
<code>计数器</code>是在每一轮循环结束时执行,通常用于递增或递减
在下面的例子中,先初始化<code>i = 0</code>,条件<code>i &#60; 5</code>为真,进入第一次循环,执行大括号里的代码,第一次循环结束。递增<code>i</code>的值,条件判断,就这样依次执行下去,直到条件判断为假,整个循环结束。
`for ([初始化]; [条件判断]; [计数器])`
`初始化`语句只会在执行循环开始之前执行一次。它通常用于定义和设置你的循环变量
`条件判断`语句会在每一轮循环的开始执行,只要条件判断为`true`就会继续执行循环。当条件为`false`的时候,循环将停止执行。这意味着,如果条件在一开始就为`false`,这个循环将不会执行。
`计数器`是在每一轮循环结束时执行,通常用于递增或递减。
在下面的例子中,先初始化`i = 0`,条件`i < 5`为真,进入第一次循环,执行大括号里的代码,第一次循环结束。递增`i`的值,条件判断,就这样依次执行下去,直到条件判断为假,整个循环结束。
```js
var ourArray = [];
@ -24,76 +31,25 @@ for (var i = 0; i < 5; i++) {
}
```
最终<code>ourArray</code>的值为<code>[0,1,2,3,4]</code>.
</section>
最终`ourArray`的值为`[0,1,2,3,4]`.
## Instructions
<section id='instructions'>
使用<code>for</code>循环把从 1 到 5 添加进<code>myArray</code>中。
</section>
# --instructions--
## Tests
<section id='tests'>
使用`for`循环把从 1 到 5 添加进`myArray`中。
```yml
tests:
- text: 你应该使用<code>for</code>循环。
testString: assert(code.match(/for\s*\(/g).length > 1);
- text: <code>myArray</code>应该等于<code>[1,2,3,4,5]</code>。
testString: assert.deepEqual(myArray, [1,2,3,4,5]);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该使用`for`循环。
```js
// Example
var ourArray = [];
for (var i = 0; i < 5; i++) {
ourArray.push(i);
}
// Setup
var myArray = [];
// Only change code below this line.
assert(code.match(/for\s*\(/g).length > 1);
```
</div>
### After Test
<div id='js-teardown'>
`myArray`应该等于`[1,2,3,4,5]`
```js
if (typeof myArray !== "undefined"){(function(){return myArray;})();}
assert.deepEqual(myArray, [1, 2, 3, 4, 5]);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var ourArray = [];
for (var i = 0; i < 5; i++) {
ourArray.push(i);
}
var myArray = [];
for (var i = 1; i < 6; i++) {
myArray.push(i);
}
```
</section>

View File

@ -1,15 +1,16 @@
---
id: cf1111c1c11feddfaeb1bdef
title: while 循环
challengeType: 1
videoUrl: 'https://scrimba.com/c/c8QbnCM'
forumTopicId: 18220
title: while 循环
---
## Description
<section id='description'>
# --description--
你可以使用循环多次执行相同的代码。
我们将学习的第一种类型的循环称为 "<code>while</code>" 循环,因为它规定,当 "while" 条件为真,循环才会执行,反之不执行。
我们将学习的第一种类型的循环称为 "`while`" 循环,因为它规定,当 "while" 条件为真,循环才会执行,反之不执行。
```js
var ourArray = [];
@ -20,69 +21,27 @@ while(i < 5) {
}
```
在上面的代码里,<code>while</code> 循环执行 5 次把 0 到 4 的数字添加到 <code>ourArray</code> 数组里。
在上面的代码里,`while` 循环执行 5 次把 0 到 4 的数字添加到 `ourArray` 数组里。
让我们通过 while 循环将值添加到数组中。
</section>
## Instructions
<section id='instructions'>
通过一个<code>while</code>循环,把从 0 到 4 的值添加到<code>myArray</code>中。
</section>
# --instructions--
## Tests
<section id='tests'>
通过一个`while`循环,把从 0 到 4 的值添加到`myArray`中。
```yml
tests:
- text: 你应该使用<code>while</code>循环。
testString: assert(code.match(/while/g));
- text: <code>myArray</code>应该等于<code>[0,1,2,3,4]</code>。
testString: assert.deepEqual(myArray, [0,1,2,3,4]);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
你应该使用`while`循环。
```js
// Setup
var myArray = [];
// Only change code below this line.
assert(code.match(/while/g));
```
</div>
### After Test
<div id='js-teardown'>
`myArray`应该等于`[0,1,2,3,4]`
```js
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
assert.deepEqual(myArray, [0, 1, 2, 3, 4]);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myArray = [];
var i = 5;
while(i >= 0) {
myArray.push(i);
i--;
}
```
</section>

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244bf
title: 局部作用域和函数
challengeType: 1
videoUrl: 'https://scrimba.com/c/cd62NhM'
forumTopicId: 18227
title: 局部作用域和函数
---
## Description
<section id='description'>
# --description--
在一个函数内声明的变量,以及该函数的参数都是局部变量,意味着它们只在该函数内可见。
这是在函数<code>myTest</code>内声明局部变量<code>loc</code>的例子:
这是在函数`myTest`内声明局部变量`loc`的例子:
```js
function myTest() {
@ -20,104 +21,28 @@ myTest(); // logs "foo"
console.log(loc); // loc is not defined
```
在函数外,<code>loc</code>是未定义的。
</section>
在函数外,`loc`是未定义的。
## Instructions
<section id='instructions'>
在函数<code>myFunction</code>内部声明一个局部变量<code>myVar</code>,并删除外部的 console.log。
<strong>提示:</strong><br>如果你遇到了问题,可以先尝试刷新页面。
</section>
# --instructions--
## Tests
<section id='tests'>
在函数`myFunction`内部声明一个局部变量`myVar`,并删除外部的 console.log。
```yml
tests:
- text: 未找到全局的<code>myVar</code>变量。
testString: assert(typeof myVar === 'undefined');
- text: 需要定义局部的<code>myVar</code>变量。
testString: assert(/var\s+myVar/.test(code));
**提示:**
如果你遇到了问题,可以先尝试刷新页面。
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
未找到全局的`myVar`变量。
```js
function myLocalScope() {
'use strict'; // you shouldn't need to edit this line
console.log(myVar);
}
myLocalScope();
// Run and check the console
// myVar is not defined outside of myLocalScope
console.log(myVar);
// Now remove the console log line to pass the test
assert(typeof myVar === 'undefined');
```
</div>
### Before Test
<div id='js-setup'>
需要定义局部的`myVar`变量。
```js
var logOutput = "";
var originalConsole = console
function capture() {
var nativeLog = console.log;
console.log = function (message) {
logOutput = message;
if(nativeLog.apply) {
nativeLog.apply(originalConsole, arguments);
} else {
var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
nativeLog(nativeMsg);
}
};
}
function uncapture() {
console.log = originalConsole.log;
}
assert(/var\s+myVar/.test(code));
```
</div>
# --solutions--
### After Test
<div id='js-teardown'>
```js
typeof myLocalScope === 'function' && (capture(), myLocalScope(), uncapture());
(function() { return logOutput || "console.log never called"; })();
```
</div>
</section>
## Solution
<section id='solution'>
```js
function myLocalScope() {
'use strict';
var myVar;
console.log(myVar);
}
myLocalScope();
```
</section>

View File

@ -1,16 +1,19 @@
---
id: 5690307fddb111c6084545d7
title: if else 语句中的逻辑顺序
challengeType: 1
videoUrl: 'https://scrimba.com/c/cwNvMUV'
forumTopicId: 18228
title: if else 语句中的逻辑顺序
---
## Description
<section id='description'>
<code>if</code><code>else if</code>语句中代码的执行顺序是很重要的。
# --description--
`if``else if`语句中代码的执行顺序是很重要的。
在条件判断语句中,代码的执行顺序是从上到下,所以你需要考虑清楚先执行哪一句,后执行哪一句。
这有两个例子。
第一个例子:
```js
@ -46,69 +49,29 @@ foo(0) // "Less than one"
bar(0) // "Less than two"
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
更改函数的逻辑顺序以便通过所有的测试用例。
</section>
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>orderMyLogic(4)</code>应该返回 "Less than 5"。
testString: assert(orderMyLogic(4) === "Less than 5");
- text: <code>orderMyLogic(6)</code>应该返回 "Less than 10"。
testString: assert(orderMyLogic(6) === "Less than 10");
- text: <code>orderMyLogic(11)</code>应该返回 "Greater than or equal to 10"。
testString: assert(orderMyLogic(11) === "Greater than or equal to 10");
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`orderMyLogic(4)`应该返回 "Less than 5"。
```js
function orderMyLogic(val) {
if (val < 10) {
return "Less than 10";
} else if (val < 5) {
return "Less than 5";
} else {
return "Greater than or equal to 10";
}
}
// Change this value to test
orderMyLogic(7);
assert(orderMyLogic(4) === 'Less than 5');
```
</div>
</section>
## Solution
<section id='solution'>
`orderMyLogic(6)`应该返回 "Less than 10"。
```js
function orderMyLogic(val) {
if(val < 5) {
return "Less than 5";
} else if (val < 10) {
return "Less than 10";
} else {
return "Greater than or equal to 10";
}
}
assert(orderMyLogic(6) === 'Less than 10');
```
</section>
`orderMyLogic(11)`应该返回 "Greater than or equal to 10"。
```js
assert(orderMyLogic(11) === 'Greater than or equal to 10');
```
# --solutions--

View File

@ -1,15 +1,17 @@
---
id: 56bbb991ad1ed5201cd392cc
title: 使用 pop() 操作数组
challengeType: 1
videoUrl: 'https://scrimba.com/c/cRbVZAB'
forumTopicId: 18236
title: 使用 pop() 操作数组
---
## Description
<section id='description'>
改变数组中数据的另一种方法是用<code>.pop()</code>函数。
<code>.pop()</code>函数用来“抛出”一个数组末尾的值。我们可以把这个“抛出”的值赋给一个变量存储起来。换句话说就是<code>.pop()</code>函数移除数组末尾的元素并返回这个元素。
# --description--
改变数组中数据的另一种方法是用`.pop()`函数。
`.pop()`函数用来“抛出”一个数组末尾的值。我们可以把这个“抛出”的值赋给一个变量存储起来。换句话说就是`.pop()`函数移除数组末尾的元素并返回这个元素。
数组中任何类型的元素(数值,字符串,甚至是数组)可以被“抛出来” 。
```js
@ -19,70 +21,45 @@ console.log(oneDown); // Returns 6
console.log(threeArr); // Returns [1, 4]
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
使用<code>.pop()</code>函数移除<code>myArray</code>中的最后一个元素,并且把“抛出”的值赋给<code>removedFromMyArray</code>
</section>
使用`.pop()`函数移除`myArray`中的最后一个元素,并且把“抛出”的值赋给`removedFromMyArray`
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>myArray</code>应该只包含<code>[["John", 23]]</code>。
testString: assert((function(d){if(d[0][0] == 'John' && d[0][1] === 23 && d[1] == undefined){return true;}else{return false;}})(myArray));
- text: 对<code>myArray</code>使用<code>pop()</code>函数。
testString: assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code));
- text: <code>removedFromMyArray</code>应该只包含<code>["cat", 2]</code>。
testString: assert((function(d){if(d[0] == 'cat' && d[1] === 2 && d[2] == undefined){return true;}else{return false;}})(removedFromMyArray));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myArray`应该只包含`[["John", 23]]`
```js
// Example
var ourArray = [1,2,3];
var removedFromOurArray = ourArray.pop();
// removedFromOurArray now equals 3, and ourArray now equals [1,2]
// Setup
var myArray = [["John", 23], ["cat", 2]];
// Only change code below this line.
var removedFromMyArray;
assert(
(function (d) {
if (d[0][0] == 'John' && d[0][1] === 23 && d[1] == undefined) {
return true;
} else {
return false;
}
})(myArray)
);
```
</div>
### After Test
<div id='js-teardown'>
`myArray`使用`pop()`函数。
```js
(function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
assert(/removedFromMyArray\s*=\s*myArray\s*.\s*pop\s*(\s*)/.test(code));
```
</div>
</section>
## Solution
<section id='solution'>
`removedFromMyArray`应该只包含`["cat", 2]`
```js
var myArray = [["John", 23], ["cat", 2]];
var removedFromMyArray = myArray.pop();
assert(
(function (d) {
if (d[0] == 'cat' && d[1] === 2 && d[2] == undefined) {
return true;
} else {
return false;
}
})(removedFromMyArray)
);
```
</section>
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56bbb991ad1ed5201cd392cb
title: 使用 push() 操作数组
challengeType: 1
videoUrl: 'https://scrimba.com/c/cnqmVtJ'
forumTopicId: 18237
title: 使用 push() 操作数组
---
## Description
<section id='description'>
一个简单的方法将数据添加到一个数组的末尾是通过<code>push()</code>函数。
<code>.push()</code>接受一个或多个参数,并把它“推”入到数组的末尾。
# --description--
一个简单的方法将数据添加到一个数组的末尾是通过`push()`函数。
`.push()`接受一个或多个参数,并把它“推”入到数组的末尾。
```js
var arr = [1,2,3];
@ -17,65 +18,32 @@ arr.push(4);
// arr is now [1,2,3,4]
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
<code>["dog", 3]</code>“推”入到<code>myArray</code>变量的末尾。
</section>
`["dog", 3]`“推”入到`myArray`变量的末尾。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>myArray</code>应该等于<code>[["John", 23], ["cat", 2], ["dog", 3]]</code>。
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));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myArray`应该等于`[["John", 23], ["cat", 2], ["dog", 3]]`
```js
// Example
var ourArray = ["Stimpson", "J", "cat"];
ourArray.push(["happy", "joy"]);
// ourArray now equals ["Stimpson", "J", "cat", ["happy", "joy"]]
// Setup
var myArray = [["John", 23], ["cat", 2]];
// Only change code below this line.
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)
);
```
</div>
# --solutions--
### After Test
<div id='js-teardown'>
```js
(function(z){return 'myArray = ' + JSON.stringify(z);})(myArray);
```
</div>
</section>
## Solution
<section id='solution'>
```js
var myArray = [["John", 23], ["cat", 2]];
myArray.push(["dog",3]);
```
</section>

View File

@ -1,79 +1,54 @@
---
id: 56bbb991ad1ed5201cd392cd
title: 使用 shift() 操作数组
challengeType: 1
videoUrl: 'https://scrimba.com/c/cRbVETW'
forumTopicId: 18238
title: 使用 shift() 操作数组
---
## Description
<section id='description'>
<code>pop()</code>函数用来移出数组中最后一个元素。如果想要移出第一个元素要怎么办呢?
这就是<code>.shift()</code>的用武之地。它的工作原理就像<code>.pop()</code>,但它移除的是第一个元素,而不是最后一个。
</section>
# --description--
## Instructions
<section id='instructions'>
使用<code>.shift()</code>函数移出<code>myArray</code>中的第一项,并把“移出”的值赋给<code>removedFromMyArray</code>
</section>
`pop()`函数用来移出数组中最后一个元素。如果想要移出第一个元素要怎么办呢?
## Tests
<section id='tests'>
这就是`.shift()`的用武之地。它的工作原理就像`.pop()`,但它移除的是第一个元素,而不是最后一个。
```yml
tests:
- text: <code>myArray</code>应该等于<code>[["dog", 3]]</code>。
testString: assert((function(d){if(d[0][0] == 'dog' && d[0][1] === 3 && d[1] == undefined){return true;}else{return false;}})(myArray));
- text: <code>removedFromMyArray</code>应该包含<code>["John", 23]</code>。
testString: assert((function(d){if(d[0] == 'John' && d[1] === 23 && typeof removedFromMyArray === 'object'){return true;}else{return false;}})(removedFromMyArray));
# --instructions--
```
使用`.shift()`函数移出`myArray`中的第一项,并把“移出”的值赋给`removedFromMyArray`
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myArray`应该等于`[["dog", 3]]`
```js
// Example
var ourArray = ["Stimpson", "J", ["cat"]];
var removedFromOurArray = ourArray.shift();
// removedFromOurArray now equals "Stimpson" and ourArray now equals ["J", ["cat"]].
// Setup
var myArray = [["John", 23], ["dog", 3]];
// Only change code below this line.
var removedFromMyArray;
assert(
(function (d) {
if (d[0][0] == 'dog' && d[0][1] === 3 && d[1] == undefined) {
return true;
} else {
return false;
}
})(myArray)
);
```
</div>
### After Test
<div id='js-teardown'>
`removedFromMyArray`应该包含`["John", 23]`
```js
(function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
assert(
(function (d) {
if (
d[0] == 'John' &&
d[1] === 23 &&
typeof removedFromMyArray === 'object'
) {
return true;
} else {
return false;
}
})(removedFromMyArray)
);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myArray = [["John", 23], ["dog", 3]];
// Only change code below this line.
var removedFromMyArray = myArray.shift();
```
</section>

View File

@ -1,77 +1,44 @@
---
id: 56bbb991ad1ed5201cd392ce
title: 使用 unshift() 操作数组
challengeType: 1
videoUrl: 'https://scrimba.com/c/ckNDESv'
forumTopicId: 18239
title: 使用 unshift() 操作数组
---
## Description
<section id='description'>
你不仅可以<code>shift</code>(移出)数组中的第一个元素,你也可以<code>unshift</code>(移入)一个元素到数组的头部。
<code>.unshift()</code>函数用起来就像<code>.push()</code>函数一样, 但不是在数组的末尾添加元素,而是在数组的头部添加元素。
</section>
# --description--
## Instructions
<section id='instructions'>
使用<code>unshift()</code>函数把<code>["Paul",35]</code>加入到<code>myArray</code>的头部。
</section>
你不仅可以`shift`(移出)数组中的第一个元素,你也可以`unshift`(移入)一个元素到数组的头部。
## Tests
<section id='tests'>
`.unshift()`函数用起来就像`.push()`函数一样, 但不是在数组的末尾添加元素,而是在数组的头部添加元素。
```yml
tests:
- text: <code>myArray</code>应该包含[["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));
# --instructions--
```
使用`unshift()`函数把`["Paul",35]`加入到`myArray`的头部。
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myArray`应该包含\[["Paul", 35], ["dog", 3]]。
```js
// Example
var ourArray = ["Stimpson", "J", "cat"];
ourArray.shift(); // ourArray now equals ["J", "cat"]
ourArray.unshift("Happy");
// ourArray now equals ["Happy", "J", "cat"]
// Setup
var myArray = [["John", 23], ["dog", 3]];
myArray.shift();
// Only change code below this line.
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)
);
```
</div>
# --solutions--
### After Test
<div id='js-teardown'>
```js
(function(y, z){return 'myArray = ' + JSON.stringify(y);})(myArray);
```
</div>
</section>
## Solution
<section id='solution'>
```js
var myArray = [["John", 23], ["dog", 3]];
myArray.shift();
myArray.unshift(["Paul", 35]);
```
</section>

View File

@ -1,14 +1,15 @@
---
id: 56533eb9ac21ba0edf2244cb
title: 操作复杂对象
challengeType: 1
videoUrl: 'https://scrimba.com/c/c9yNMfR'
forumTopicId: 18208
title: 操作复杂对象
---
## Description
<section id='description'>
# --description--
有时你可能希望将数据存储在灵活的<dfn>数据结构</dfn>中。JavaScript 对象是处理灵活数据的一种方法。它可以储存<dfn>字符串</dfn><dfn>数字</dfn><dfn>布尔值</dfn><dfn>函数</dfn>,和<dfn>对象</dfn>以及这些值的任意组合。
这是一个复杂数据结构的示例:
```js
@ -27,9 +28,7 @@ var ourMusic = [
];
```
这是一个对象数组,并且对象有各种关于专辑的 <dfn>详细信息</dfn>。它也有一个嵌套的<code>formats</code>的数组。附加专辑记录可以被添加到数组的最上层
对象将数据以一种键-值对的形式保存。在上面的示例中,<code>"artist": "Daft Punk"</code>是一个具有<code>"artist"</code>键和<code>"Daft Punk"</code>值的属性。
<a href='http://www.json.org/' target=_blank>JavaScript Object Notation</a> 简称<code>JSON</code>是用于存储数据的相关数据交换格式。
这是一个对象数组,并且对象有各种关于专辑的 <dfn>详细信息</dfn>。它也有一个嵌套的`formats`的数组。附加专辑记录可以被添加到数组的最上层。 对象将数据以一种键-值对的形式保存。在上面的示例中,`"artist": "Daft Punk"`是一个具有`"artist"`键和`"Daft Punk"`值的属性。 [JavaScript Object Notation](http://www.json.org/) 简称`JSON`是用于存储数据的相关数据交换格式
```json
{
@ -45,107 +44,81 @@ var ourMusic = [
}
```
<strong>提示</strong><br>数组中有多个 JSON 对象的时候,对象与对象之间要用逗号隔开。
</section>
**提示**
数组中有多个 JSON 对象的时候,对象与对象之间要用逗号隔开。
## Instructions
<section id='instructions'>
添加一个新专辑到<code>myMusic</code>的JSON对象。添加<code>artist</code><code>title</code>字符串,<code>release_year</code>数字和<code>formats</code>字符串数组。
</section>
# --instructions--
## Tests
<section id='tests'>
添加一个新专辑到`myMusic`的JSON对象。添加`artist``title`字符串,`release_year`数字和`formats`字符串数组。
```yml
tests:
- text: <code>myMusic</code>应该是一个数组。
testString: assert(Array.isArray(myMusic));
- text: <code>myMusic</code>应该至少包含两个元素。
testString: assert(myMusic.length > 1);
- text: <code>myMusic[1]</code>应该是一个对象。
testString: assert(typeof myMusic[1] === 'object');
- text: <code>myMusic[1]</code>至少要包含四个属性。
testString: assert(Object.keys(myMusic[1]).length > 3);
- text: <code>myMusic[1]</code>应该包含一个类型为字符串的<code>artist</code>的属性。
testString: assert(myMusic[1].hasOwnProperty('artist') && typeof myMusic[1].artist === 'string');
- text: <code>myMusic[1]</code>应该包含一个类型为字符串的<code>title</code>的属性。
testString: assert(myMusic[1].hasOwnProperty('title') && typeof myMusic[1].title === 'string');
- text: <code>myMusic[1]</code>应该包含一个类型为数字的<code>release_year</code> 应该包含一个类型为数字的属性。
testString: assert(myMusic[1].hasOwnProperty('release_year') && typeof myMusic[1].release_year === 'number');
- text: <code>myMusic[1]</code>应该包含一个类型为数组的<code>formats</code>属性。
testString: assert(myMusic[1].hasOwnProperty('formats') && Array.isArray(myMusic[1].formats));
- text: <code>formats</code>应该是一个至少包含两个字符串元素的数组。
testString: assert(myMusic[1].formats.every(function(item) { return (typeof item === "string")}) && myMusic[1].formats.length > 1);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myMusic`应该是一个数组。
```js
var myMusic = [
{
"artist": "Billy Joel",
"title": "Piano Man",
"release_year": 1973,
"formats": [
"CD",
"8T",
"LP"
],
"gold": true
}
// Add record here
];
assert(Array.isArray(myMusic));
```
</div>
### After Test
<div id='js-teardown'>
`myMusic`应该至少包含两个元素。
```js
(function(x){ if (Array.isArray(x)) { return JSON.stringify(x); } return "myMusic is not an array"})(myMusic);
assert(myMusic.length > 1);
```
</div>
</section>
## Solution
<section id='solution'>
`myMusic[1]`应该是一个对象。
```js
var myMusic = [
{
"artist": "Billy Joel",
"title": "Piano Man",
"release_year": 1973,
"formats": [
"CS",
"8T",
"LP" ],
"gold": true
},
{
"artist": "ABBA",
"title": "Ring Ring",
"release_year": 1973,
"formats": [
"CS",
"8T",
"LP",
"CD",
]
}
];
assert(typeof myMusic[1] === 'object');
```
</section>
`myMusic[1]`至少要包含四个属性。
```js
assert(Object.keys(myMusic[1]).length > 3);
```
`myMusic[1]`应该包含一个类型为字符串的`artist`的属性。
```js
assert(
myMusic[1].hasOwnProperty('artist') && typeof myMusic[1].artist === 'string'
);
```
`myMusic[1]`应该包含一个类型为字符串的`title`的属性。
```js
assert(
myMusic[1].hasOwnProperty('title') && typeof myMusic[1].title === 'string'
);
```
`myMusic[1]`应该包含一个类型为数字的`release_year` 应该包含一个类型为数字的属性。
```js
assert(
myMusic[1].hasOwnProperty('release_year') &&
typeof myMusic[1].release_year === 'number'
);
```
`myMusic[1]`应该包含一个类型为数组的`formats`属性。
```js
assert(
myMusic[1].hasOwnProperty('formats') && Array.isArray(myMusic[1].formats)
);
```
`formats`应该是一个至少包含两个字符串元素的数组。
```js
assert(
myMusic[1].formats.every(function (item) {
return typeof item === 'string';
}) && myMusic[1].formats.length > 1
);
```
# --solutions--

View File

@ -1,82 +1,63 @@
---
id: cf1111c1c11feddfaeb8bdef
title: 通过索引修改数组中的数据
challengeType: 1
videoUrl: 'https://scrimba.com/c/czQM4A8'
forumTopicId: 18241
title: 通过索引修改数组中的数据
---
## Description
<section id='description'>
# --description--
与字符串的数据不可变不同,数组的数据是可变的,并且可以自由地改变。
<strong>示例</strong>
**示例**
```js
var ourArray = [50,40,30];
ourArray[0] = 15; // equals [15,40,30]
```
<strong>提示</strong><br>数组名称和方括号之间不应有任何空格,如<code>array [0]</code>尽管 JavaScript 能够正确处理,但可能会让看你代码的其他程序员感到困惑。
</section>
**提示**
数组名称和方括号之间不应有任何空格,如`array [0]`尽管 JavaScript 能够正确处理,但可能会让看你代码的其他程序员感到困惑。
## Instructions
<section id='instructions'>
修改数组<code>myArray</code>中索引0上的值为<code>45</code>
</section>
# --instructions--
## Tests
<section id='tests'>
修改数组`myArray`中索引0上的值为`45`
```yml
tests:
- text: <code>myArray</code>的值应该 [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: 你应该使用正确的索引修改<code>myArray</code>的值。
testString: assert((function(){if(code.match(/myArray\[0\]\s*=\s*/g)){return true;}else{return false;}})());
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myArray`的值应该 [45,64,99]。
```js
// Example
var ourArray = [18,64,99];
ourArray[1] = 45; // ourArray now equals [18,45,99].
// Setup
var myArray = [18,64,99];
// Only change code below this line.
assert(
(function () {
if (
typeof myArray != 'undefined' &&
myArray[0] == 45 &&
myArray[1] == 64 &&
myArray[2] == 99
) {
return true;
} else {
return false;
}
})()
);
```
</div>
### After Test
<div id='js-teardown'>
你应该使用正确的索引修改`myArray`的值。
```js
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
assert(
(function () {
if (code.match(/myArray\[0\]\s*=\s*/g)) {
return true;
} else {
return false;
}
})()
);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myArray = [18,64,99];
myArray[0] = 45;
```
</section>

View File

@ -1,14 +1,14 @@
---
id: 56533eb9ac21ba0edf2244df
title: 在 Switch 语句添加多个相同选项
challengeType: 1
videoUrl: 'https://scrimba.com/c/cdBKWCV'
forumTopicId: 18242
title: 在 Switch 语句添加多个相同选项
---
## Description
<section id='description'>
如果你忘了给<code>switch</code>的每一条<code>case</code>添加<code>break</code>,那么直到遇见<code>break</code>为止,后续的<code>case</code>会一直执行。如果你想为多个不同的输入设置相同的结果,可以这样写:
# --description--
如果你忘了给`switch`的每一条`case`添加`break`,那么直到遇见`break`为止,后续的`case`会一直执行。如果你想为多个不同的输入设置相同的结果,可以这样写:
```js
switch(val) {
@ -23,100 +23,84 @@ switch(val) {
```
这样1、2、3 都会有相同的结果。
</section>
## Instructions
<section id='instructions'>
请写一个<code>switch</code>语句,根据输入的<code>val</code>的范围得出对应的<code>answer</code><br><code>1-3</code> - "Low"<br><code>4-6</code> - "Mid"<br><code>7-9</code> - "High"
<strong>提示:</strong><br>你的<code>case</code>应基于范围中的每一个数字编写。
</section>
# --instructions--
## Tests
<section id='tests'>
请写一个`switch`语句,根据输入的`val`的范围得出对应的`answer`
`1-3` - "Low"
`4-6` - "Mid"
`7-9` - "High"
```yml
tests:
- text: <code>sequentialSizes(1)</code>应该返回 "Low"。
testString: assert(sequentialSizes(1) === "Low");
- text: <code>sequentialSizes(2)</code>应该返回 "Low"。
testString: assert(sequentialSizes(2) === "Low");
- text: <code>sequentialSizes(3)</code>应该返回 "Low"。
testString: assert(sequentialSizes(3) === "Low");
- text: <code>sequentialSizes(4)</code>应该返回 "Mid"。
testString: assert(sequentialSizes(4) === "Mid");
- text: <code>sequentialSizes(5)</code>应该返回 "Mid"。
testString: assert(sequentialSizes(5) === "Mid");
- text: <code>sequentialSizes(6)</code>应该返回 "Mid"。
testString: assert(sequentialSizes(6) === "Mid");
- text: <code>sequentialSizes(7)</code>应该返回 "High"。
testString: assert(sequentialSizes(7) === "High");
- text: <code>sequentialSizes(8)</code>应该返回 "High"。
testString: assert(sequentialSizes(8) === "High");
- text: <code>sequentialSizes(9)</code>应该返回 "High"。
testString: assert(sequentialSizes(9) === "High");
- text: 你不应使用<code>if</code>或<code>else</code>语句。
testString: assert(!/else/g.test(code) || !/if/g.test(code));
- text: 你应该编写 9 个<code>case</code>语句。
testString: assert(code.match(/case/g).length === 9);
**提示:**
你的`case`应基于范围中的每一个数字编写。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`sequentialSizes(1)`应该返回 "Low"。
```js
function sequentialSizes(val) {
var answer = "";
// Only change code below this line
// Only change code above this line
return answer;
}
// Change this value to test
sequentialSizes(1);
assert(sequentialSizes(1) === 'Low');
```
</div>
</section>
## Solution
<section id='solution'>
`sequentialSizes(2)`应该返回 "Low"。
```js
function sequentialSizes(val) {
var answer = "";
switch(val) {
case 1:
case 2:
case 3:
answer = "Low";
break;
case 4:
case 5:
case 6:
answer = "Mid";
break;
case 7:
case 8:
case 9:
answer = "High";
}
return answer;
}
assert(sequentialSizes(2) === 'Low');
```
</section>
`sequentialSizes(3)`应该返回 "Low"。
```js
assert(sequentialSizes(3) === 'Low');
```
`sequentialSizes(4)`应该返回 "Mid"。
```js
assert(sequentialSizes(4) === 'Mid');
```
`sequentialSizes(5)`应该返回 "Mid"。
```js
assert(sequentialSizes(5) === 'Mid');
```
`sequentialSizes(6)`应该返回 "Mid"。
```js
assert(sequentialSizes(6) === 'Mid');
```
`sequentialSizes(7)`应该返回 "High"。
```js
assert(sequentialSizes(7) === 'High');
```
`sequentialSizes(8)`应该返回 "High"。
```js
assert(sequentialSizes(8) === 'High');
```
`sequentialSizes(9)`应该返回 "High"。
```js
assert(sequentialSizes(9) === 'High');
```
你不应使用`if``else`语句。
```js
assert(!/else/g.test(code) || !/if/g.test(code));
```
你应该编写 9 个`case`语句。
```js
assert(code.match(/case/g).length === 9);
```
# --solutions--

View File

@ -1,67 +1,34 @@
---
id: bd7993c9c69feddfaeb7bdef
title: 两个小数相乘
challengeType: 1
videoUrl: 'https://scrimba.com/c/ce2GeHq'
forumTopicId: 301173
title: 两个小数相乘
---
## Description
<section id='description'>
# --description--
在 JavaScript 中,你也可以用小数进行计算,就像整数一样。
把两个小数相乘,并得到它们乘积。
</section>
## Instructions
<section id='instructions'>
改变<code>0.0</code>的数值让变量<code>product</code>的值等于<code>5.0</code>
</section>
# --instructions--
## Tests
<section id='tests'>
改变`0.0`的数值让变量`product`的值等于`5.0`
```yml
tests:
- text: 变量<code>product</code>应该等于<code>5.0</code>。
testString: assert(product === 5.0);
- text: 要使用<code>*</code>运算符。
testString: assert(/\*/.test(code));
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
变量`product`应该等于`5.0`
```js
var product = 2.0 * 0.0;
assert(product === 5.0);
```
</div>
### After Test
<div id='js-teardown'>
要使用`*`运算符。
```js
(function(y){return 'product = '+y;})(product);
assert(/\*/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var product = 2.0 * 2.5;
```
</section>

View File

@ -1,75 +1,40 @@
---
id: cf1231c1c11feddfaeb5bdef
title: 乘法运算
challengeType: 1
videoUrl: 'https://scrimba.com/c/cP3y3Aq'
forumTopicId: 18243
title: 乘法运算
---
## Description
<section id='description'>
我们也可在 JavaScript 中使用乘法运算。
JavaScript 使用<code>*</code>符号表示两数相乘。
# --description--
<strong>示例</strong>
我们也可在 JavaScript 中使用乘法运算。
JavaScript 使用`*`符号表示两数相乘。
**示例**
```js
myVar = 13 * 13; // assigned 169
```
# --instructions--
</section>
改变数值`0`来让变量 product 的值等于`80`
## Instructions
<section id='instructions'>
改变数值<code>0</code>来让变量 product 的值等于<code>80</code>
</section>
# --hints--
## Tests
<section id='tests'>
```yml
tests:
- text: 要使<code>product</code>的值等于 80。
testString: assert(product === 80);
- text: 使用<code>*</code>运算符。
testString: assert(/\*/.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
要使`product`的值等于 80。
```js
var product = 8 * 0;
assert(product === 80);
```
</div>
### After Test
<div id='js-teardown'>
使用`*`运算符。
```js
(function(z){return 'product = '+z;})(product);
assert(/\*/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var product = 8 * 10;
```
</section>

View File

@ -1,67 +1,26 @@
---
id: cf1111c1c11feddfaeb7bdef
title: 将一个数组嵌套在另一个数组中
challengeType: 1
videoUrl: 'https://scrimba.com/c/crZQZf8'
forumTopicId: 18247
title: 将一个数组嵌套在另一个数组中
---
## Description
<section id='description'>
你也可以在数组中包含其他数组,例如:<code>[["Bulls", 23], ["White Sox", 45]]</code>。这被称为一个<dfn>多维数组<dfn>
</section>
# --description--
## Instructions
<section id='instructions'>
创建一个名为<code>myArray</code>的多维数组。
</section>
你也可以在数组中包含其他数组,例如:`[["Bulls", 23], ["White Sox", 45]]`。这被称为一个<dfn>多维数组<dfn></dfn></dfn>
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: 应该包含至少一个嵌入的数组。
testString: assert(Array.isArray(myArray) && myArray.some(Array.isArray));
创建一个名为`myArray`的多维数组。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
应该包含至少一个嵌入的数组。
```js
// Example
var ourArray = [["the universe", 42], ["everything", 101010]];
// Only change code below this line.
var myArray = [];
assert(Array.isArray(myArray) && myArray.some(Array.isArray));
```
</div>
# --solutions--
### After Test
<div id='js-teardown'>
```js
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
```
</div>
</section>
## Solution
<section id='solution'>
```js
var myArray = [[1,2,3]];
```
</section>

View File

@ -1,13 +1,13 @@
---
id: 56533eb9ac21ba0edf2244e1
title: 循环嵌套
challengeType: 1
videoUrl: 'https://scrimba.com/c/cRn6GHM'
forumTopicId: 18248
title: 循环嵌套
---
## Description
<section id='description'>
# --description--
如果你有一个二维数组,可以使用相同的逻辑,先遍历外面的数组,再遍历里面的子数组。下面是一个例子:
```js
@ -21,71 +21,43 @@ for (var i=0; i < arr.length; i++) {
}
```
一次输出<code>arr</code>中的每个子元素。提示,对于内部循环,我们可以通过<code>arr[i]</code><code>.length</code>来获得子数组的长度,因为<code>arr[i]</code>的本身就是一个数组。
</section>
一次输出`arr`中的每个子元素。提示,对于内部循环,我们可以通过`arr[i]``.length`来获得子数组的长度,因为`arr[i]`的本身就是一个数组。
## Instructions
<section id='instructions'>
修改函数<code>multiplyAll</code>,获得<code>arr</code>内部数组的每个数字相乘的结果<code>product</code>
</section>
# --instructions--
## Tests
<section id='tests'>
修改函数`multiplyAll`,获得`arr`内部数组的每个数字相乘的结果`product`
```yml
tests:
- text: <code>multiplyAll([[1],[2],[3]])</code>应该返回 <code>6</code>。
testString: assert(multiplyAll([[1],[2],[3]]) === 6);
- text: <code>multiplyAll([[1,2],[3,4],[5,6,7]])</code>应该返回 <code>5040</code>。
testString: assert(multiplyAll([[1,2],[3,4],[5,6,7]]) === 5040);
- text: <code>multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])</code>应该返回 <code>54</code>。
testString: assert(multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]]) === 54);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`multiplyAll([[1],[2],[3]])`应该返回 `6`
```js
function multiplyAll(arr) {
var product = 1;
// Only change code below this line
// Only change code above this line
return product;
}
// Modify values below to test your code
multiplyAll([[1,2],[3,4],[5,6,7]]);
assert(multiplyAll([[1], [2], [3]]) === 6);
```
</div>
</section>
## Solution
<section id='solution'>
`multiplyAll([[1,2],[3,4],[5,6,7]])`应该返回 `5040`
```js
function multiplyAll(arr) {
var product = 1;
for (var i = 0; i < arr.length; i++) {
for (var j = 0; j < arr[i].length; j++) {
product *= arr[i][j];
}
}
return product;
}
multiplyAll([[1,2],[3,4],[5,6,7]]);
assert(
multiplyAll([
[1, 2],
[3, 4],
[5, 6, 7]
]) === 5040
);
```
</section>
`multiplyAll([[5,1],[0.2, 4, 0.5],[3, 9]])`应该返回 `54`
```js
assert(
multiplyAll([
[5, 1],
[0.2, 4, 0.5],
[3, 9]
]) === 54
);
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244bd
title: 将值传递给带有参数的函数
challengeType: 1
videoUrl: 'https://scrimba.com/c/cy8rahW'
forumTopicId: 18254
title: 将值传递给带有参数的函数
---
## Description
<section id='description'>
函数的参数<code>parameters</code>在函数中充当占位符(也叫形参)的作用,参数可以为一个或多个。调用一个函数时所传入的参数为实参,实参决定着形参真正的值。简单理解:形参即形式、实参即内容。
这是带有两个参数的函数,<code>param1</code><code>param2</code>
# --description--
函数的参数`parameters`在函数中充当占位符(也叫形参)的作用,参数可以为一个或多个。调用一个函数时所传入的参数为实参,实参决定着形参真正的值。简单理解:形参即形式、实参即内容。
这是带有两个参数的函数,`param1``param2`
```js
function testFun(param1, param2) {
@ -17,107 +18,47 @@ function testFun(param1, param2) {
}
```
接着我们调用<code>testFun</code>
<code>testFun("Hello", "World");</code>
我们传递了两个参数,<code>"Hello"</code><code>"World"</code>。在函数内部,<code>param1</code>等于“Hello”<code>param2</code>等于“World”。请注意<code>testFun</code>函数可以多次调用,每次调用时传递的参数会决定形参的实际值。
</section>
接着我们调用`testFun` `testFun("Hello", "World");` 我们传递了两个参数,`"Hello"``"World"`。在函数内部,`param1`等于“Hello”`param2`等于“World”。请注意`testFun`函数可以多次调用,每次调用时传递的参数会决定形参的实际值。
# --instructions--
## Instructions
<section id='instructions'>
<ol><li>创建一个名为<code>functionWithArgs</code>的函数,它可以接收两个参数,计算参数的和,将结果输出到控制台。</li><li>调用这个函数。</li></ol>
</section>
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>functionWithArgs</code>应该是一个函数。
testString: assert(typeof functionWithArgs === 'function');
- text: <code>functionWithArgs(1,2)</code>应该输出<code>3</code>。
testString: if(typeof functionWithArgs === "function") { capture(); functionWithArgs(1,2); uncapture(); } assert(logOutput == 3);
- text: <code>functionWithArgs(7,9)</code>应该输出<code>16</code>。
testString: if(typeof functionWithArgs === "function") { capture(); functionWithArgs(7,9); uncapture(); } assert(logOutput == 16);
- text: 在你定义<code>functionWithArgs</code>之后记得调用它。
testString: assert(/^\s*functionWithArgs\s*\(\s*\d+\s*,\s*\d+\s*\)\s*;?/m.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`functionWithArgs`应该是一个函数。
```js
// Example
function ourFunctionWithArgs(a, b) {
console.log(a - b);
}
ourFunctionWithArgs(10, 5); // Outputs 5
// Only change code below this line.
assert(typeof functionWithArgs === 'function');
```
</div>
### Before Test
<div id='js-setup'>
`functionWithArgs(1,2)`应该输出`3`
```js
var logOutput = "";
var originalConsole = console
function capture() {
var nativeLog = console.log;
console.log = function (message) {
if(message) logOutput = JSON.stringify(message).trim();
if(nativeLog.apply) {
nativeLog.apply(originalConsole, arguments);
} else {
var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
nativeLog(nativeMsg);
}
};
if (typeof functionWithArgs === 'function') {
capture();
functionWithArgs(1, 2);
uncapture();
}
function uncapture() {
console.log = originalConsole.log;
}
capture();
assert(logOutput == 3);
```
</div>
### After Test
<div id='js-teardown'>
`functionWithArgs(7,9)`应该输出`16`
```js
uncapture();
if (typeof functionWithArgs !== "function") {
(function() { return "functionWithArgs is not defined"; })();
} else {
(function() { return logOutput || "console.log never called"; })();
if (typeof functionWithArgs === 'function') {
capture();
functionWithArgs(7, 9);
uncapture();
}
assert(logOutput == 16);
```
</div>
</section>
## Solution
<section id='solution'>
在你定义`functionWithArgs`之后记得调用它。
```js
function functionWithArgs(a, b) {
console.log(a + b);
}
functionWithArgs(10, 5);
assert(/^\s*functionWithArgs\s*\(\s*\d+\s*,\s*\d+\s*\)\s*;?/m.test(code));
```
</section>
# --solutions--

View File

@ -1,88 +1,57 @@
---
id: 599a789b454f2bbd91a3ff4d
title: 比较不同值
challengeType: 1
videoUrl: 'https://scrimba.com/c/cm8PqCa'
forumTopicId: 301174
title: 比较不同值
---
## Description
<section id='description'>
在上两个挑战中,我们学习了相等运算符 (<code>==</code>) 和严格相等运算符 (<code>===</code>)。现在让我们快速回顾并实践一下。
# --description--
在上两个挑战中,我们学习了相等运算符 (`==`) 和严格相等运算符 (`===`)。现在让我们快速回顾并实践一下。
如果要比较的值不是同一类型,相等运算符会先执行数据类型转换,然后比较值。而严格相等运算符只比较值,不会进行数据类型转换。
由此可见,相等运算符和严格相等运算符的区别是:前者会执行隐式类型转换,后者不会。
<strong>示例</strong>
**示例**
```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
```
<strong>提示</strong><br>在JavaScript中你可以使用<code>typeof</code>运算符确定变量的类型或值,如下所示:
**提示**
在JavaScript中你可以使用`typeof`运算符确定变量的类型或值,如下所示:
```js
typeof 3 // returns 'number'
typeof '3' // returns 'string'
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
编辑器中的<code>compareEquality</code>函数使用相等运算符比较两个值。修改函数,使其仅在值严格相等时返回 "Equal" 。
</section>
编辑器中的`compareEquality`函数使用相等运算符比较两个值。修改函数,使其仅在值严格相等时返回 "Equal" 。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>compareEquality(10, "10")</code>应该返回 "Not Equal"。
testString: assert(compareEquality(10, "10") === "Not Equal");
- text: <code>compareEquality("20", 20)</code>应该返回 "Not Equal"。
testString: assert(compareEquality("20", 20) === "Not Equal");
- text: 你应该使用<code>===</code>运算符。
testString: assert(code.match(/===/g));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`compareEquality(10, "10")`应该返回 "Not Equal"。
```js
// Setup
function compareEquality(a, b) {
if (a == b) { // Change this line
return "Equal";
}
return "Not Equal";
}
// Change this value to test
compareEquality(10, "10");
assert(compareEquality(10, '10') === 'Not Equal');
```
</div>
</section>
## Solution
<section id='solution'>
`compareEquality("20", 20)`应该返回 "Not Equal"。
```js
function compareEquality(a,b) {
if (a === b) {
return "Equal";
}
return "Not Equal";
}
assert(compareEquality('20', 20) === 'Not Equal');
```
</section>
你应该使用`===`运算符。
```js
assert(code.match(/===/g));
```
# --solutions--

View File

@ -1,144 +1,65 @@
---
id: 5688e62ea601b2482ff8422b
title: 资料查找
challengeType: 1
videoUrl: 'https://scrimba.com/c/cDqW2Cg'
forumTopicId: 18259
title: 资料查找
---
## Description
<section id='description'>
# --description--
我们有一个对象数组,里面存储着通讯录。
函数<code>lookUp</code>有两个预定义参数:<code>firstName</code>值和<code>prop</code>属性 。
函数将会检查通讯录中是否存在一个与传入的<code>firstName</code>相同的联系人。如果存在,那么还需要检查对应的联系人中是否存在<code>prop</code>属性。
如果它们都存在,函数返回<code>prop</code>属性对应的值。
如果<code>firstName</code>值不存在,返回<code>"No such contact"</code>
如果<code>prop</code>属性不存在,返回<code>"No such property"</code>
</section>
## Instructions
<section id='instructions'>
函数`lookUp`有两个预定义参数:`firstName`值和`prop`属性 。
</section>
函数将会检查通讯录中是否存在一个与传入的`firstName`相同的联系人。如果存在,那么还需要检查对应的联系人中是否存在`prop`属性。
## Tests
<section id='tests'>
如果它们都存在,函数返回`prop`属性对应的值。
```yml
tests:
- text: <code>"Kristian", "lastName"</code>应该返回 <code>"Vos"</code>。
testString: assert(lookUpProfile('Kristian','lastName') === "Vos");
- text: <code>"Sherlock", "likes"</code>应该返回 <code>["Intriguing Cases", "Violin"]</code>。
testString: assert.deepEqual(lookUpProfile("Sherlock", "likes"), ["Intriguing Cases", "Violin"]);
- text: <code>"Harry","likes"</code>应该返回 an array。
testString: assert(typeof lookUpProfile("Harry", "likes") === "object");
- text: <code>"Bob", "number"</code>应该返回 "No such contact"。
testString: assert(lookUpProfile("Bob", "number") === "No such contact");
- text: <code>"Bob", "potato"</code>应该返回 "No such contact"。
testString: assert(lookUpProfile("Bob", "potato") === "No such contact");
- text: <code>"Akira", "address"</code>应该返回 "No such property"。
testString: assert(lookUpProfile("Akira", "address") === "No such property");
如果`firstName`值不存在,返回`"No such contact"`
```
如果`prop`属性不存在,返回`"No such property"`
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`"Kristian", "lastName"`应该返回 `"Vos"`
```js
//Setup
var contacts = [
{
"firstName": "Akira",
"lastName": "Laine",
"number": "0543236543",
"likes": ["Pizza", "Coding", "Brownie Points"]
},
{
"firstName": "Harry",
"lastName": "Potter",
"number": "0994372684",
"likes": ["Hogwarts", "Magic", "Hagrid"]
},
{
"firstName": "Sherlock",
"lastName": "Holmes",
"number": "0487345643",
"likes": ["Intriguing Cases", "Violin"]
},
{
"firstName": "Kristian",
"lastName": "Vos",
"number": "unknown",
"likes": ["JavaScript", "Gaming", "Foxes"]
}
];
function lookUpProfile(name, prop){
// Only change code below this line
// Only change code above this line
}
// Change these values to test your function
lookUpProfile("Akira", "likes");
assert(lookUpProfile('Kristian', 'lastName') === 'Vos');
```
</div>
</section>
## Solution
<section id='solution'>
`"Sherlock", "likes"`应该返回 `["Intriguing Cases", "Violin"]`
```js
var contacts = [
{
"firstName": "Akira",
"lastName": "Laine",
"number": "0543236543",
"likes": ["Pizza", "Coding", "Brownie Points"]
},
{
"firstName": "Harry",
"lastName": "Potter",
"number": "0994372684",
"likes": ["Hogwarts", "Magic", "Hagrid"]
},
{
"firstName": "Sherlock",
"lastName": "Holmes",
"number": "0487345643",
"likes": ["Intriguing Cases", "Violin"]
},
{
"firstName": "Kristian",
"lastName": "Vos",
"number": "unknown",
"likes": ["JavaScript", "Gaming", "Foxes"]
},
];
//Write your function in between these comments
function lookUpProfile(name, prop){
for(var i in contacts){
if(contacts[i].firstName === name) {
return contacts[i][prop] || "No such property";
}
}
return "No such contact";
}
//Write your function in between these comments
lookUpProfile("Akira", "likes");
assert.deepEqual(lookUpProfile('Sherlock', 'likes'), [
'Intriguing Cases',
'Violin'
]);
```
</section>
`"Harry","likes"`应该返回 an array。
```js
assert(typeof lookUpProfile('Harry', 'likes') === 'object');
```
`"Bob", "number"`应该返回 "No such contact"。
```js
assert(lookUpProfile('Bob', 'number') === 'No such contact');
```
`"Bob", "potato"`应该返回 "No such contact"。
```js
assert(lookUpProfile('Bob', 'potato') === 'No such contact');
```
`"Akira", "address"`应该返回 "No such property"。
```js
assert(lookUpProfile('Akira', 'address') === 'No such property');
```
# --solutions--

View File

@ -1,13 +1,13 @@
---
id: 56533eb9ac21ba0edf2244b4
title: 用单引号引用字符串
challengeType: 1
videoUrl: 'https://scrimba.com/c/cbQmnhM'
forumTopicId: 18260
title: 用单引号引用字符串
---
## Description
<section id='description'>
# --description--
JavaScript 中的<dfn>字符串</dfn>可以使用开始和结束都是同类型的单引号或双引号表示,与其他一些编程语言不同的是,单引号和双引号的功能在 JavaScript 中是相同的。
```js
@ -15,7 +15,7 @@ doubleQuoteStr = "This is a string";
singleQuoteStr = 'This is also a string';
```
当你需要在一个字符串中使用多个引号的时候,你可以使用单引号包裹双引号或者相反。常见的场景比如在字符串中包含对话的句子需要用引号包裹。另外比如在一个包含有<code>&#60;a&#62;</code>标签的字符串中,<code>&#60;a&#62;</code>标签的属性值需要用引号包裹。
当你需要在一个字符串中使用多个引号的时候,你可以使用单引号包裹双引号或者相反。常见的场景比如在字符串中包含对话的句子需要用引号包裹。另外比如在一个包含有`<a>`标签的字符串中,`<a>`标签的属性值需要用引号包裹。
```js
conversation = 'Finn exclaims to Jake, "Algebraic!"';
@ -28,61 +28,33 @@ goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"';
badStr = 'Finn responds, "Let's go!"'; // Throws an error
```
在上面的<code>goodStr</code>中,通过使用反斜杠<code>\</code>转义字符可以安全地使用两种引号
<strong>提示</strong><br/>不要把反斜杠<code>\</code>和斜杠<code>/</code>搞混,它们不是一回事。
</section>
在上面的`goodStr`中,通过使用反斜杠`\`转义字符可以安全地使用两种引号 **提示**
不要把反斜杠`\`和斜杠`/`搞混,它们不是一回事。
# --instructions--
## Instructions
<section id='instructions'>
把字符串更改为开头和结尾使用单引号的字符串,并且不包含转义字符。
这样字符串中的<code>&#60;a&#62;</code>标签里面任何地方都可以使用双引号。你需要将最外层引号更改为单引号,以便删除转义字符。
</section>
## Tests
<section id='tests'>
这样字符串中的`<a>`标签里面任何地方都可以使用双引号。你需要将最外层引号更改为单引号,以便删除转义字符。
```yml
tests:
- text: 删除所有<code>反斜杠</code> (<code>\</code>)。
testString: assert(!/\\/g.test(code) && myStr.match('\\s*<a href\\s*=\\s*"http://www.example.com"\\s*target\\s*=\\s*"_blank">\\s*Link\\s*</a>\\s*'));
- text: 应该要有两个单引号<code>&#39;</code>和四个双引号<code>&quot;</code>。
testString: assert(code.match(/"/g).length === 4 && code.match(/'/g).length === 2);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
删除所有`反斜杠` (`\`)。
```js
var myStr = "<a href=\"http://www.example.com\" target=\"_blank\">Link</a>";
assert(
!/\\/g.test(code) &&
myStr.match(
'\\s*<a href\\s*=\\s*"http://www.example.com"\\s*target\\s*=\\s*"_blank">\\s*Link\\s*</a>\\s*'
)
);
```
</div>
### After Test
<div id='js-teardown'>
应该要有两个单引号`'`和四个双引号`"`
```js
(function() { return "myStr = " + myStr; })();
assert(code.match(/"/g).length === 4 && code.match(/'/g).length === 2);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myStr = '<a href="http://www.example.com" target="_blank">Link</a>';
```
</section>

View File

@ -1,146 +1,97 @@
---
id: 56533eb9ac21ba0edf2244cf
title: 记录集合
challengeType: 1
videoUrl: 'https://scrimba.com/c/c4mpysg'
forumTopicId: 18261
title: 记录集合
---
## Description
<section id='description'>
# --description--
给定一个 JSON 对象,用来表示部分音乐专辑收藏。每张专辑都有几个属性和一个唯一的 id 号作为键值。并非所有专辑都有完整的信息。
写一个函数,根据传入的<code>id</code>(如<code>2548</code>)、<code>prop</code>(属性,如<code>"artist"</code><code>"tracks"</code>)以及<code>value</code>(值,如<code>"Addicted to Love"</code>)来修改音乐专辑收藏的数据。
如果属性<code>prop</code>不是<code>"tracks"</code>且值<code>value</code>不为空(<code>""</code>),则更新或设置该专辑属性的值<code>value</code>
写一个函数,根据传入的`id`(如`2548`)、`prop`(属性,如`"artist"``"tracks"`)以及`value`(值,如`"Addicted to Love"`)来修改音乐专辑收藏的数据
如果属性`prop`不是`"tracks"`且值`value`不为空(`""`),则更新或设置该专辑属性的值`value`
你的函数必须始终返回整个音乐专辑集合对象。
处理不完整数据有几条规则:
如果属性<code>prop</code><code>"tracks"</code>,但是专辑没有<code>"tracks"</code>属性,则在添加值之前先给<code>"tracks"</code>创建一个空数组。
如果<code>prop</code><code>"tracks"</code>,并且值<code>value</code>不为空(<code>""</code> 把值<code>value</code>添加到<code>tracks</code>数组中。
如果值<code>value</code>为空(<code>""</code>),则删除专辑的这一属性<code>prop</code>
<strong>提示:</strong><br><a href="javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables" target="_blank">通过变量访问对象的属性</a>时,应使用<code>中括号</code>
Push 是一个数组方法,详情请查看<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push" target="_blank">Mozilla Developer Network</a>.
你可以参考<a href="/javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects" target="_blank">操作复杂对象</a>这一节的内容复习相关知识。
</section>
## Instructions
<section id='instructions'>
如果属性`prop``"tracks"`,但是专辑没有`"tracks"`属性,则在添加值之前先给`"tracks"`创建一个空数组。
</section>
如果`prop``"tracks"`,并且值`value`不为空(`""` 把值`value`添加到`tracks`数组中。
## Tests
<section id='tests'>
如果值`value`为空(`""`),则删除专辑的这一属性`prop`
```yml
tests:
- text: 执行<code>updateRecords(5439, "artist", "ABBA")</code>后,<code>artist</code>属性值应该是<code>"ABBA"</code>。
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: 执行<code>updateRecords(5439, "artist", "ABBA")</code>后,<code>artist</code> 最后的元素应该是 <code>"ABBA"</code>。
testString: assert(updateRecords(5439, "artist", "ABBA")[5439]["artist"] === "ABBA");
- text: 执行 <code>updateRecords(5439, "tracks", "Take a Chance on Me")</code> 后,<code>tracks</code> 最后的元素应该是 <code>"Take a Chance on Me"</code>。
testString: assert(updateRecords(5439, "tracks", "Take a Chance on Me")[5439]["tracks"].pop() === "Take a Chance on Me");
- text: 执行<code>updateRecords(2548, "artist", "")</code>后,<code>artist</code>不应被创建。
testString: updateRecords(2548, "artist", ""); assert(!collection[2548].hasOwnProperty("artist"));
- text: 执行<code>updateRecords(1245, "tracks", "Addicted to Love")</code>后,<code>tracks</code>最后的元素应该是<code>"Addicted to Love"</code>。
testString: assert(updateRecords(1245, "tracks", "Addicted to Love")[1245]["tracks"].pop() === "Addicted to Love");
- text: 执行<code>updateRecords(2468, "tracks", "Free")</code>后,<code>tracks</code>第一个元素应该是<code>"1999"</code>。
testString: assert(updateRecords(2468, "tracks", "Free")[2468]["tracks"][0] === "1999");
- text: 执行<code>updateRecords(2548, "tracks", "")</code>后,<code>tracks</code>不应被创建。
testString: updateRecords(2548, "tracks", ""); assert(!collection[2548].hasOwnProperty("tracks"));
- text: 执行<code>updateRecords(1245, "album", "Riptide")</code>后,<code>album</code>应该是<code>"Riptide"</code>。
testString: assert(updateRecords(1245, "album", "Riptide")[1245]["album"] === "Riptide");
**提示:**
[通过变量访问对象的属性](javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables)时,应使用`中括号`
```
Push 是一个数组方法,详情请查看[Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push).
</section>
你可以参考[操作复杂对象](/javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects)这一节的内容复习相关知识。
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
# --hints--
执行`updateRecords(5439, "artist", "ABBA")`后,`artist`属性值应该是`"ABBA"`
```js
// Setup
var collection = {
2548: {
album: "Slippery When Wet",
artist: "Bon Jovi",
tracks: [
"Let It Rock",
"You Give Love a Bad Name"
]
},
2468: {
album: "1999",
artist: "Prince",
tracks: [
"1999",
"Little Red Corvette"
]
},
1245: {
artist: "Robert Palmer",
tracks: [ ]
},
5439: {
album: "ABBA Gold"
}
};
// Only change code below this line
function updateRecords(id, prop, value) {
return collection;
}
// Alter values below to test your code
updateRecords(5439, "artist", "ABBA");
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
)
);
```
</div>
</section>
## Solution
<section id='solution'>
执行`updateRecords(5439, "artist", "ABBA")`后,`artist` 最后的元素应该是 `"ABBA"`
```js
var collection = {
2548: {
album: "Slippery When Wet",
artist: "Bon Jovi",
tracks: [
"Let It Rock",
"You Give Love a Bad Name"
]
},
2468: {
album: "1999",
artist: "Prince",
tracks: [
"1999",
"Little Red Corvette"
]
},
1245: {
artist: "Robert Palmer",
tracks: [ ]
},
5439: {
album: "ABBA Gold"
}
};
// Only change code below this line
function updateRecords(id, prop, value) {
if(value === "") delete collection[id][prop];
else if(prop === "tracks") {
collection[id][prop] = collection[id][prop] || [];
collection[id][prop].push(value);
} else {
collection[id][prop] = value;
}
return collection;
}
assert(updateRecords(5439, 'artist', 'ABBA')[5439]['artist'] === 'ABBA');
```
</section>
执行 `updateRecords(5439, "tracks", "Take a Chance on Me")` 后,`tracks` 最后的元素应该是 `"Take a Chance on Me"`
```js
assert(
updateRecords(5439, 'tracks', 'Take a Chance on Me')[5439]['tracks'].pop() ===
'Take a Chance on Me'
);
```
执行`updateRecords(2548, "artist", "")`后,`artist`不应被创建。
```js
updateRecords(2548, 'artist', '');
assert(!collection[2548].hasOwnProperty('artist'));
```
执行`updateRecords(1245, "tracks", "Addicted to Love")`后,`tracks`最后的元素应该是`"Addicted to Love"`
```js
assert(
updateRecords(1245, 'tracks', 'Addicted to Love')[1245]['tracks'].pop() ===
'Addicted to Love'
);
```
执行`updateRecords(2468, "tracks", "Free")`后,`tracks`第一个元素应该是`"1999"`
```js
assert(updateRecords(2468, 'tracks', 'Free')[2468]['tracks'][0] === '1999');
```
执行`updateRecords(2548, "tracks", "")`后,`tracks`不应被创建。
```js
updateRecords(2548, 'tracks', '');
assert(!collection[2548].hasOwnProperty('tracks'));
```
执行`updateRecords(1245, "album", "Riptide")`后,`album`应该是`"Riptide"`
```js
assert(updateRecords(1245, 'album', 'Riptide')[1245]['album'] === 'Riptide');
```
# --solutions--

View File

@ -1,14 +1,15 @@
---
id: 5cfa3679138e7d9595b9d9d4
challengeType: 1
videoUrl: 'https://www.freecodecamp.org/news/how-recursion-works-explained-with-flowcharts-and-a-video-de61f40cb7f9/'
forumTopicId: 301175
title: 使用递归代替循环
challengeType: 1
videoUrl: >-
https://www.freecodecamp.org/news/how-recursion-works-explained-with-flowcharts-and-a-video-de61f40cb7f9/
forumTopicId: 301175
---
## Description
<section id='description'>
函数调用自身的编程技巧称为递归。为了便于理解,有如下任务:计算数组内元素第 <code>0</code> 到第 <code>n</code> 的元素乘积,使用 <code>for</code> 循环, 可以这样做:
# --description--
函数调用自身的编程技巧称为递归。为了便于理解,有如下任务:计算数组内元素第 `0` 到第 `n` 的元素乘积,使用 `for` 循环, 可以这样做:
```js
function multiply(arr, n) {
@ -20,7 +21,7 @@ title: 使用递归代替循环
}
```
下面是递归写法,注意代码里的 <code>multiply(arr, n) == multiply(arr, n - 1) * arr[n]</code>。这意味着可以重写 <code>multiply</code> 以调用自身而无需依赖循环。
下面是递归写法,注意代码里的 `multiply(arr, n) == multiply(arr, n - 1) * arr[n]`。这意味着可以重写 `multiply` 以调用自身而无需依赖循环。
```js
function multiply(arr, n) {
@ -32,78 +33,39 @@ title: 使用递归代替循环
}
```
递归版本的 <code>multiply</code> 详述如下。在 <dfn>base case</dfn> 里,也就是 <code>n <= 0</code> 时,返回结果,也就是 <code>arr[0]</code>。在 <code>n</code> 比 0 大的情况里,函数会调用自身,参数 n 的值为 <code>n - 1</code>。函数以相同的方式持续调用 <code>multiply</code>,直到 <code>n = 0</code> 为止。所以,所有函数都可以返回,原始的 <code>multiply</code> 返回结果。
递归版本的 `multiply` 详述如下。在 <dfn>base case</dfn> 里,也就是 `n <= 0` 时,返回结果,也就是 `arr[0]`。在 `n` 比 0 大的情况里,函数会调用自身,参数 n 的值为 `n - 1`。函数以相同的方式持续调用 `multiply`,直到 `n = 0` 为止。所以,所有函数都可以返回,原始的 `multiply` 返回结果。
<strong>注意:</strong> 递归函数在没有函数调用时(在这个例子是,是当 <code>n <= 0</code> 时)必需有一个跳出结构,否则永远不会执行完毕。
**注意:** 递归函数在没有函数调用时(在这个例子是,是当 `n <= 0` 时)必需有一个跳出结构,否则永远不会执行完毕。
</section>
# --instructions--
## Instructions
<section id='instructions'>
写一个递归函数,`sum(arr, n)`,返回递归调用数组 `arr` 从第 `0` 个到第 `n` 个元素和。
写一个递归函数,<code>sum(arr, n)</code>,返回递归调用数组 <code>arr</code> 从第 <code>0</code> 个到第 <code>n</code> 个元素和。
# --hints--
</section>
## Tests
<section id='tests'>
``` yml
tests:
- text: <code>sum([1], 0)</code> 应该返回 1 。
testString: assert.equal(sum([1], 0), 1);
- text: <code>sum([2, 3, 4], 1)</code> 应该返回 5 。
testString: assert.equal(sum([2, 3, 4], 1), 5);
- text: 代码不应该包含任何形式的循环(<code>for</code> 或者 <code>while</code> 或者高阶函数比如 <code>forEach</code><code>map</code><code>filter</code>,或者 <code>reduce</code>)。
testString: assert(!removeJSComments(code).match(/for|while|forEach|map|filter|reduce/g));
- text: 应该使用递归来解决这个问题。
testString: assert(removeJSComments(sum.toString()).match(/sum\(.*\)/g).length > 1);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`sum([1], 0)` 应该返回 1 。
```js
function sum(arr, n) {
// Only change code below this line
// Only change code above this line
}
assert.equal(sum([1], 0), 1);
```
</div>
### After Test
<div id='js-teardown'>
`sum([2, 3, 4], 1)` 应该返回 5 。
```js
const removeJSComments = str => str.replace(/\/\*[\s\S]*?\*\/|\/\/.*$/gm, '');
assert.equal(sum([2, 3, 4], 1), 5);
```
</div>
</section>
## Solution
<section id='solution'>
代码不应该包含任何形式的循环(`for` 或者 `while` 或者高阶函数比如 `forEach``map``filter`,或者 `reduce`)。
```js
function sum(arr, n) {
// Only change code below this line
if(n <= 0) {
return arr[0];
} else {
return sum(arr, n - 1) + arr[n];
}
// Only change code above this line
}
assert(!removeJSComments(code).match(/for|while|forEach|map|filter|reduce/g));
```
</section>
应该使用递归来解决这个问题。
```js
assert(removeJSComments(sum.toString()).match(/sum\(.*\)/g).length > 1);
```
# --solutions--

View File

@ -1,14 +1,14 @@
---
id: 56533eb9ac21ba0edf2244e0
title: 用一个 Switch 语句来替代多个 if else 语句
challengeType: 1
videoUrl: 'https://scrimba.com/c/c3JE8fy'
forumTopicId: 18266
title: 用一个 Switch 语句来替代多个 if else 语句
---
## Description
<section id='description'>
如果你有多个选项需要选择,<code>switch</code>语句写起来会比多个串联的<code>if</code>/<code>if else</code>语句容易些,譬如:
# --description--
如果你有多个选项需要选择,`switch`语句写起来会比多个串联的`if`/`if else`语句容易些,譬如:
```js
if (val === 1) {
@ -35,106 +35,71 @@ switch(val) {
}
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
把串联的<code>if</code>/<code>if else</code>语句改成<code>switch</code>语句。
</section>
把串联的`if`/`if else`语句改成`switch`语句。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: 不要使用<code>else</code>表达式。
testString: assert(!/else/g.test(code));
- text: 不要使用<code>if</code>表达式。
testString: assert(!/if/g.test(code));
- text: 你应该有至少 4 个<code>break</code>表达式。
testString: assert(code.match(/break/g).length >= 4);
- text: <code>chainToSwitch("bob")</code>应该为 "Marley"。
testString: assert(chainToSwitch("bob") === "Marley");
- text: <code>chainToSwitch(42)</code>应该为 "The Answer"。
testString: assert(chainToSwitch(42) === "The Answer");
- text: <code>chainToSwitch(1)</code>应该为 "There is no #1"。
testString: "assert(chainToSwitch(1) === \"There is no #1\");"
- text: <code>chainToSwitch(99)</code>应该为 "Missed me by this much!"。
testString: assert(chainToSwitch(99) === "Missed me by this much!");
- text: <code>chainToSwitch(7)</code>应该为 "Ate Nine"。
testString: assert(chainToSwitch(7) === "Ate Nine");
- text: <code>chainToSwitch("John")</code>应该为 "" (empty string)。
testString: assert(chainToSwitch("John") === "");
- text: <code>chainToSwitch(156)</code>应该为 "" (empty string)。
testString: assert(chainToSwitch(156) === "");
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
不要使用`else`表达式。
```js
function chainToSwitch(val) {
var answer = "";
// Only change code below this line
if (val === "bob") {
answer = "Marley";
} else if (val === 42) {
answer = "The Answer";
} else if (val === 1) {
answer = "There is no #1";
} else if (val === 99) {
answer = "Missed me by this much!";
} else if (val === 7) {
answer = "Ate Nine";
}
// Only change code above this line
return answer;
}
// Change this value to test
chainToSwitch(7);
assert(!/else/g.test(code));
```
</div>
</section>
## Solution
<section id='solution'>
不要使用`if`表达式。
```js
function chainToSwitch(val) {
var answer = "";
switch(val) {
case "bob":
answer = "Marley";
break;
case 42:
answer = "The Answer";
break;
case 1:
answer = "There is no #1";
break;
case 99:
answer = "Missed me by this much!";
break;
case 7:
answer = "Ate Nine";
}
return answer;
}
assert(!/if/g.test(code));
```
</section>
你应该有至少 4 个`break`表达式。
```js
assert(code.match(/break/g).length >= 4);
```
`chainToSwitch("bob")`应该为 "Marley"。
```js
assert(chainToSwitch('bob') === 'Marley');
```
`chainToSwitch(42)`应该为 "The Answer"。
```js
assert(chainToSwitch(42) === 'The Answer');
```
`chainToSwitch(1)`应该为 "There is no
```js
assert(chainToSwitch(1) === 'There is no #1');
```
`chainToSwitch(99)`应该为 "Missed me by this much!"。
```js
assert(chainToSwitch(99) === 'Missed me by this much!');
```
`chainToSwitch(7)`应该为 "Ate Nine"。
```js
assert(chainToSwitch(7) === 'Ate Nine');
```
`chainToSwitch("John")`应该为 "" (empty string)。
```js
assert(chainToSwitch('John') === '');
```
`chainToSwitch(156)`应该为 "" (empty string)。
```js
assert(chainToSwitch(156) === '');
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244c2
title: 函数可以返回某个值
challengeType: 1
videoUrl: 'https://scrimba.com/c/cy87wue'
forumTopicId: 18271
title: 函数可以返回某个值
---
## Description
<section id='description'>
我们可以通过函数的<dfn>参数</dfn>把值传入函数,也可以使用<code>return</code>语句把数据从一个函数中传出来。
<strong>示例</strong>
# --description--
我们可以通过函数的<dfn>参数</dfn>把值传入函数,也可以使用`return`语句把数据从一个函数中传出来。
**示例**
```js
function plusThree(num) {
@ -18,65 +19,37 @@ function plusThree(num) {
var answer = plusThree(5); // 8
```
<code>plusThree</code>带有一个<code>num</code><dfn>参数</dfn>并且返回returns一个等于<code>num + 3</code>的值。
</section>
`plusThree`带有一个`num`<dfn>参数</dfn>并且返回returns一个等于`num + 3`的值。
## Instructions
<section id='instructions'>
创建一个函数<code>timesFive</code>接收一个参数, 把它乘以<code>5</code>之后返回关于如何测试timesFive 函数,可以参考编辑器中最后一行的示例。
</section>
# --instructions--
## Tests
<section id='tests'>
创建一个函数`timesFive`接收一个参数, 把它乘以`5`之后返回关于如何测试timesFive 函数,可以参考编辑器中最后一行的示例。
```yml
tests:
- text: <code>timesFive</code>应是一个函数。
testString: assert(typeof timesFive === 'function');
- text: <code>timesFive(5)</code>应该返回<code>25</code>。
testString: assert(timesFive(5) === 25);
- text: <code>timesFive(2)</code>应该返回<code>10</code>。
testString: assert(timesFive(2) === 10);
- text: <code>timesFive(0)</code>应该返回<code>0</code>。
testString: assert(timesFive(0) === 0);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`timesFive`应是一个函数。
```js
// Example
function minusSeven(num) {
return num - 7;
}
// Only change code below this line
console.log(minusSeven(10));
assert(typeof timesFive === 'function');
```
</div>
</section>
## Solution
<section id='solution'>
`timesFive(5)`应该返回`25`
```js
function timesFive(num) {
return num * 5;
}
timesFive(10);
assert(timesFive(5) === 25);
```
</section>
`timesFive(2)`应该返回`10`
```js
assert(timesFive(2) === 10);
```
`timesFive(0)`应该返回`0`
```js
assert(timesFive(0) === 0);
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56533eb9ac21ba0edf2244c4
title: 函数执行到 return 语句就结束
challengeType: 1
videoUrl: 'https://scrimba.com/c/cQe39Sq'
forumTopicId: 18272
title: 函数执行到 return 语句就结束
---
## Description
<section id='description'>
# --description--
当代码执行到 return 语句时函数返回一个结果就结束运行了return 后面的语句不会执行。
<strong>示例</strong>
**示例**
```js
function myFun() {
@ -20,75 +21,52 @@ function myFun() {
myFun();
```
上面的代码输出"Hello"到控制台、返回 "World",但没有输出<code>"byebye"</code>,因为函数遇到 return 语句就退出了。
</section>
上面的代码输出"Hello"到控制台、返回 "World",但没有输出`"byebye"`,因为函数遇到 return 语句就退出了。
## Instructions
<section id='instructions'>
修改函数<code>abTest</code><code>a</code><code>b</code>小于0时函数立即返回一个<code>undefined</code>并退出。
<strong>提示</strong><br>记住<a href='/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables' target='_blank'><code>undefined</code> 是一个关键字</a>,而不是一个字符串。
</section>
# --instructions--
## Tests
<section id='tests'>
修改函数`abTest``a``b`小于0时函数立即返回一个`undefined`并退出。
```yml
tests:
- text: <code>abTest(2,2)</code> 应该返回一个数字。
testString: assert(typeof abTest(2,2) === 'number' );
- text: <code>abTest(2,2)</code> 应该返回 <code>8</code>。
testString: assert(abTest(2,2) === 8 );
- text: <code>abTest(-2,2)</code> 应该返回 <code>undefined</code>。
testString: assert(abTest(-2,2) === undefined );
- text: <code>abTest(2,-2)</code> 应该返回 <code>undefined</code>。
testString: assert(abTest(2,-2) === undefined );
- text: <code>abTest(2,8)</code> 应该返回 <code>18</code>。
testString: assert(abTest(2,8) === 18 );
- text: <code>abTest(3,3)</code> 应该返回 <code>12</code>。
testString: assert(abTest(3,3) === 12 );
**提示**
记住[`undefined` 是一个关键字](/javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables),而不是一个字符串。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`abTest(2,2)` 应该返回一个数字。
```js
// Setup
function abTest(a, b) {
// Only change code below this line
// Only change code above this line
return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
}
// Change values below to test your code
abTest(2,2);
assert(typeof abTest(2, 2) === 'number');
```
</div>
</section>
## Solution
<section id='solution'>
`abTest(2,2)` 应该返回 `8`
```js
function abTest(a, b) {
if(a < 0 || b < 0) {
return undefined;
}
return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
}
assert(abTest(2, 2) === 8);
```
</section>
`abTest(-2,2)` 应该返回 `undefined`
```js
assert(abTest(-2, 2) === undefined);
```
`abTest(2,-2)` 应该返回 `undefined`
```js
assert(abTest(2, -2) === undefined);
```
`abTest(2,8)` 应该返回 `18`
```js
assert(abTest(2, 8) === 18);
```
`abTest(3,3)` 应该返回 `12`
```js
assert(abTest(3, 3) === 12);
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 5679ceb97cbaa8c51670a16b
title: 从函数返回布尔值
challengeType: 1
videoUrl: 'https://scrimba.com/c/cp62qAQ'
forumTopicId: 18273
title: 从函数返回布尔值
---
## Description
<section id='description'>
你应该还记得<a href="javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator" target="_blank">相等运算符</a>这道挑战题。在那里我们提到,所有比较操作符都会返回 boolean要么是<code>true</code>要么是<code>false</code>
有时人们通过 if/else 语句来做比较然后返回<code>true</code><code>false</code>
# --description--
你应该还记得[相等运算符](javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator)这道挑战题。在那里我们提到,所有比较操作符都会返回 boolean要么是`true`要么是`false`
有时人们通过 if/else 语句来做比较然后返回`true``false`
```js
function isEqual(a,b) {
@ -21,7 +22,7 @@ function isEqual(a,b) {
}
```
有一个更好的方法,因为<code>===</code>总是返回<code>true</code><code>false</code>,所以我们可以直接返回比较的结果:
有一个更好的方法,因为`===`总是返回`true``false`,所以我们可以直接返回比较的结果:
```js
function isEqual(a,b) {
@ -29,62 +30,29 @@ function isEqual(a,b) {
}
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
移除<code>isLess</code>函数的<code>if/else</code>语句但不影响函数的功能。
</section>
移除`isLess`函数的`if/else`语句但不影响函数的功能。
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>isLess(10,15)</code>应该返回 <code>true</code>。
testString: assert(isLess(10,15) === true);
- text: <code>isLess(15,10)</code>应该返回 <code>false</code>。
testString: assert(isLess(15, 10) === false);
- text: 不应该使用 <code>if</code> 或者 <code>else</code> 语句。
testString: assert(!/if|else/g.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`isLess(10,15)`应该返回 `true`
```js
function isLess(a, b) {
// Fix this code
if (a < b) {
return true;
} else {
return false;
}
}
// Change these values to test
isLess(10, 15);
assert(isLess(10, 15) === true);
```
</div>
</section>
## Solution
<section id='solution'>
`isLess(15,10)`应该返回 `false`
```js
function isLess(a, b) {
return a < b;
}
assert(isLess(15, 10) === false);
```
</section>
不应该使用 `if` 或者 `else` 语句。
```js
assert(!/if|else/g.test(code));
```
# --solutions--

View File

@ -1,14 +1,15 @@
---
id: 56533eb9ac21ba0edf2244dd
title: 使用 Switch 语句从许多选项中进行选择
challengeType: 1
videoUrl: 'https://scrimba.com/c/c4mv4fm'
forumTopicId: 18277
title: 使用 Switch 语句从许多选项中进行选择
---
## Description
<section id='description'>
# --description--
如果你有非常多的选项需要选择,可以使用 switch 语句。根据不同的参数值会匹配上不同的 case 分支,语句会从第一个匹配的 case 分支开始执行,直到碰到 break 就结束。
这是一个伪代码案例:
```js
@ -22,86 +23,53 @@ switch(lowercaseLetter) {
}
```
测试<code>case</code>值使用严格相等运算符进行比较break 关键字告诉 JavaScript 停止执行语句。如果没有 break 关键字,下一个语句会继续执行。
</section>
测试`case`值使用严格相等运算符进行比较break 关键字告诉 JavaScript 停止执行语句。如果没有 break 关键字,下一个语句会继续执行。
## Instructions
<section id='instructions'>
写一个测试<code>val</code>的 switch 语句,并且根据下面的条件来设置不同的<code>answer</code><br><code>1</code>- "alpha"<br><code>2</code> - "beta"<br><code>3</code>- "gamma"<br><code>4</code> - "delta"
</section>
# --instructions--
## Tests
<section id='tests'>
写一个测试`val`的 switch 语句,并且根据下面的条件来设置不同的`answer`
`1`- "alpha"
`2` - "beta"
`3`- "gamma"
`4` - "delta"
```yml
tests:
- text: <code>caseInSwitch(1)</code> 应该有一个值为 "alpha"。
testString: assert(caseInSwitch(1) === "alpha");
- text: <code>caseInSwitch(2)</code> 应该有一个值为 "beta"。
testString: assert(caseInSwitch(2) === "beta");
- text: <code>caseInSwitch(3)</code> 应该有一个值为 "gamma"。
testString: assert(caseInSwitch(3) === "gamma");
- text: <code>caseInSwitch(4)</code> 应该有一个值为 "delta"。
testString: assert(caseInSwitch(4) === "delta");
- text: 不能使用任何<code>if</code>或<code>else</code>表达式。
testString: assert(!/else/g.test(code) || !/if/g.test(code));
- text: 你应该有至少 3 个<code>break</code>表达式。
testString: assert(code.match(/break/g).length > 2);
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`caseInSwitch(1)` 应该有一个值为 "alpha"。
```js
function caseInSwitch(val) {
var answer = "";
// Only change code below this line
// Only change code above this line
return answer;
}
// Change this value to test
caseInSwitch(1);
assert(caseInSwitch(1) === 'alpha');
```
</div>
</section>
## Solution
<section id='solution'>
`caseInSwitch(2)` 应该有一个值为 "beta"。
```js
function caseInSwitch(val) {
var answer = "";
switch(val) {
case 1:
answer = "alpha";
break;
case 2:
answer = "beta";
break;
case 3:
answer = "gamma";
break;
case 4:
answer = "delta";
}
return answer;
}
assert(caseInSwitch(2) === 'beta');
```
</section>
`caseInSwitch(3)` 应该有一个值为 "gamma"。
```js
assert(caseInSwitch(3) === 'gamma');
```
`caseInSwitch(4)` 应该有一个值为 "delta"。
```js
assert(caseInSwitch(4) === 'delta');
```
不能使用任何`if``else`表达式。
```js
assert(!/else/g.test(code) || !/if/g.test(code));
```
你应该有至少 3 个`break`表达式。
```js
assert(code.match(/break/g).length > 2);
```
# --solutions--

View File

@ -1,104 +1,46 @@
---
id: 56533eb9ac21ba0edf2244bc
title: 购物清单
challengeType: 1
videoUrl: 'https://scrimba.com/c/c9MEKHZ'
forumTopicId: 18280
title: 购物清单
---
## Description
<section id='description'>
创建一个名叫<code>myList</code>的购物清单,清单的数据格式就是多维数组。
# --description--
创建一个名叫`myList`的购物清单,清单的数据格式就是多维数组。
每个子数组中的第一个元素应该是购买的物品名称,第二个元素应该是物品的数量,类似于:
<code>["Chocolate Bar", 15]</code>
`["Chocolate Bar", 15]`
任务:你的购物清单至少应该有 5 个子数组。
</section>
## Instructions
<section id='instructions'>
# --hints--
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myList</code>应该一个数组。
testString: assert(isArray);
- text: 你的每个子数组的第一个元素的类型都应该是字符串。
testString: assert(hasString);
- text: 你的每个子数组的第二个元素的类型都应该是数字。
testString: assert(hasNumber);
- text: 你的列表中至少要包含 5 个元素。
testString: assert(count > 4);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`myList`应该一个数组。
```js
var myList = [];
assert(isArray);
```
</div>
### After Test
<div id='js-teardown'>
你的每个子数组的第一个元素的类型都应该是字符串。
```js
var count = 0;
var isArray = false;
var hasString = false;
var hasNumber = false;
(function(list){
if(Array.isArray(myList)) {
isArray = true;
if(myList.length > 0) {
hasString = true;
hasNumber = true;
for (var elem of myList) {
if(!elem || !elem[0] || typeof elem[0] !== 'string') {
hasString = false;
}
if(!elem || typeof elem[1] !== 'number') {
hasNumber = false;
}
}
}
count = myList.length;
return JSON.stringify(myList);
} else {
return "myList is not an array";
}
})(myList);
assert(hasString);
```
</div>
</section>
## Solution
<section id='solution'>
你的每个子数组的第二个元素的类型都应该是数字。
```js
var myList = [
["Candy", 10],
["Potatoes", 12],
["Eggs", 12],
["Catfood", 1],
["Toads", 9]
];
assert(hasNumber);
```
</section>
你的列表中至少要包含 5 个元素。
```js
assert(count > 4);
```
# --solutions--

View File

@ -1,119 +1,53 @@
---
id: 56533eb9ac21ba0edf2244c6
title: 排队
challengeType: 1
videoUrl: 'https://scrimba.com/c/ca8Q8tP'
forumTopicId: 18307
title: 排队
---
## Description
<section id='description'>
在计算机科学中<dfn>队列</dfn>queue是一个抽象的数据结构队列中的条目都是有秩序的。新的条目会被加到<code>队列</code>的末尾,旧的条目会从<code>队列</code>的头部被移出。
写一个函数<code>nextInLine</code>,用一个数组(<code>arr</code>)和一个数字(<code>item</code>)作为参数。
# --description--
在计算机科学中<dfn>队列</dfn>queue是一个抽象的数据结构队列中的条目都是有秩序的。新的条目会被加到`队列`的末尾,旧的条目会从`队列`的头部被移出。
写一个函数`nextInLine`,用一个数组(`arr`)和一个数字(`item`)作为参数。
把数字添加到数组的结尾,然后移出数组的第一个元素。
最后<code>nextInLine</code>函数应该返回被删除的元素。
</section>
## Instructions
<section id='instructions'>
最后`nextInLine`函数应该返回被删除的元素。
</section>
# --hints--
## Tests
<section id='tests'>
```yml
tests:
- text: <code>nextInLine([], 5)</code>应该返回一个数字。
testString: assert.isNumber(nextInLine([],5));
- text: <code>nextInLine([], 1)</code>应该返回<code>1</code>。
testString: assert(nextInLine([],1) === 1);
- text: <code>nextInLine([2], 1)</code>应该返回<code>2</code>。
testString: assert(nextInLine([2],1) === 2);
- text: <code>nextInLine([5,6,7,8,9], 1)</code>应该返回<code>5</code>。
testString: assert(nextInLine([5,6,7,8,9],1) === 5);
- text: 在<code>nextInLine(testArr, 10)</code>执行后<code>testArr[4]</code>应该是<code>10</code>。
testString: nextInLine(testArr, 10); assert(testArr[4] === 10);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`nextInLine([], 5)`应该返回一个数字。
```js
function nextInLine(arr, item) {
// Your code here
return item; // Change this line
}
// Test Setup
var testArr = [1,2,3,4,5];
// Display Code
console.log("Before: " + JSON.stringify(testArr));
console.log(nextInLine(testArr, 6)); // Modify this line to test
console.log("After: " + JSON.stringify(testArr));
assert.isNumber(nextInLine([], 5));
```
</div>
### Before Test
<div id='js-setup'>
`nextInLine([], 1)`应该返回`1`
```js
var logOutput = [];
var originalConsole = console
function capture() {
var nativeLog = console.log;
console.log = function (message) {
logOutput.push(message);
if(nativeLog.apply) {
nativeLog.apply(originalConsole, arguments);
} else {
var nativeMsg = Array.prototype.slice.apply(arguments).join(' ');
nativeLog(nativeMsg);
}
};
}
function uncapture() {
console.log = originalConsole.log;
}
capture();
assert(nextInLine([], 1) === 1);
```
</div>
### After Test
<div id='js-teardown'>
`nextInLine([2], 1)`应该返回`2`
```js
uncapture();
testArr = [1,2,3,4,5];
(function() { return logOutput.join("\n");})();
assert(nextInLine([2], 1) === 2);
```
</div>
</section>
## Solution
<section id='solution'>
`nextInLine([5,6,7,8,9], 1)`应该返回`5`
```js
var testArr = [ 1,2,3,4,5];
function nextInLine(arr, item) {
arr.push(item);
return arr.shift();
}
assert(nextInLine([5, 6, 7, 8, 9], 1) === 5);
```
</section>
`nextInLine(testArr, 10)`执行后`testArr[4]`应该是`10`
```js
nextInLine(testArr, 10);
assert(testArr[4] === 10);
```
# --solutions--

View File

@ -1,74 +1,45 @@
---
id: bd7993c9c69feddfaeb8bdef
title: 使用 JavaScript 数组将多个值存储在一个变量中
challengeType: 1
videoUrl: 'https://scrimba.com/c/crZQWAm'
forumTopicId: 18309
title: 使用 JavaScript 数组将多个值存储在一个变量中
---
## Description
<section id='description'>
使用<code>数组</code>,我们可以在一个地方存储多个数据。
以左方括号<code>[</code>开始定义一个数组,以右方括号<code>]</code>结束,里面每个元素之间用逗号隔开,例如:
<code>var sandwich = ["peanut butter", "jelly", "bread"]</code>.
</section>
# --description--
## Instructions
<section id='instructions'>
创建一个包含<code>字符串</code><code>数字</code>的数组<code>myArray</code>
<strong>提示</strong><br>如果你遇到困难,请参考文本编辑器中的示例代码。
</section>
使用`数组`,我们可以在一个地方存储多个数据。
## Tests
<section id='tests'>
以左方括号`[`开始定义一个数组,以右方括号`]`结束,里面每个元素之间用逗号隔开,例如:
```yml
tests:
- text: <code>myArray</code>应该是一个<code>数组</code>。
testString: assert(typeof myArray == 'object');
- text: <code>myArray</code>数组的第一个元素应该是一个<code>字符串</code>。
testString: assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
- text: <code>myArray</code>数组的第二个元素应该是一个<code>数字</code>。
testString: assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
`var sandwich = ["peanut butter", "jelly", "bread"]`.
```
# --instructions--
</section>
创建一个包含`字符串``数字`的数组`myArray`
## Challenge Seed
<section id='challengeSeed'>
**提示**
如果你遇到困难,请参考文本编辑器中的示例代码。
<div id='js-seed'>
# --hints--
`myArray`应该是一个`数组`
```js
// Example
var ourArray = ["John", 23];
// Only change code below this line.
var myArray = [];
assert(typeof myArray == 'object');
```
</div>
### After Test
<div id='js-teardown'>
`myArray`数组的第一个元素应该是一个`字符串`
```js
(function(z){return z;})(myArray);
assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
```
</div>
</section>
## Solution
<section id='solution'>
`myArray`数组的第二个元素应该是一个`数字`
```js
var myArray = ["The Answer", 42];
assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
```
</section>
# --solutions--

View File

@ -1,100 +1,59 @@
---
id: 56533eb9ac21ba0edf2244a8
title: 使用赋值运算符存储值
challengeType: 1
videoUrl: 'https://scrimba.com/c/cEanysE'
forumTopicId: 18310
title: 使用赋值运算符存储值
---
## Description
<section id='description'>
# --description--
在 JavaScript 中,你可以使用赋值运算符将值存储在变量中。
<code>myVariable = 5;</code>
这条语句把<code>Number</code>类型的值<code>5</code>赋给变量<code>myVariable</code>
赋值过程是从右到左进行的。在将值分配给运算符左侧的变量之前,将解析<code>=</code>运算符右侧的所有内容。
`myVariable = 5;`
这条语句把`Number`类型的值`5`赋给变量`myVariable`
赋值过程是从右到左进行的。在将值分配给运算符左侧的变量之前,将解析`=`运算符右侧的所有内容。
```js
myVar = 5;
myNum = myVar;
```
数值<code>5</code>被赋给变量<code>myVar</code>中,然后再次将变量<code>myVar</code>解析为<code>5</code>并将其赋给<code>myNum</code>变量。
</section>
数值`5`被赋给变量`myVar`中,然后再次将变量`myVar`解析为`5`并将其赋给`myNum`变量。
## Instructions
<section id='instructions'>
把数值<code>7</code>赋给变量 <code>a</code>
把变量<code>a</code>中的内容赋给变量<code>b</code>
</section>
# --instructions--
## Tests
<section id='tests'>
把数值`7`赋给变量 `a`
```yml
tests:
- text: 不要修改注释上方的代码。
testString: assert(/var a;/.test(code) && /var b = 2;/.test(code));
- text: <code>a</code>的值应该是 7。
testString: assert(typeof a === 'number' && a === 7);
- text: <code>b</code>的值应该是 7。
testString: assert(typeof b === 'number' && b === 7);
- text: 你需要用<code>=</code>把<code>a</code>的值赋给<code>b</code>。
testString: assert(/b\s*=\s*a\s*;/g.test(code));
把变量`a`中的内容赋给变量`b`
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
不要修改注释上方的代码。
```js
// Setup
var a;
var b = 2;
// Only change code below this line
assert(/var a;/.test(code) && /var b = 2;/.test(code));
```
</div>
### Before Test
<div id='js-setup'>
`a`的值应该是 7。
```js
if (typeof a != 'undefined') {
a = undefined;
}
if (typeof b != 'undefined') {
b = undefined;
}
assert(typeof a === 'number' && a === 7);
```
</div>
### After Test
<div id='js-teardown'>
`b`的值应该是 7。
```js
(function(a,b){return "a = " + a + ", b = " + b;})(a,b);
assert(typeof b === 'number' && b === 7);
```
</div>
</section>
## Solution
<section id='solution'>
你需要用`=``a`的值赋给`b`
```js
var a;
var b = 2;
a = 7;
b = a;
assert(/b\s*=\s*a\s*;/g.test(code));
```
</section>
# --solutions--

View File

@ -1,75 +1,40 @@
---
id: cf1111c1c11feddfaeb4bdef
title: 减法运算
challengeType: 1
videoUrl: 'https://scrimba.com/c/cP3yQtk'
forumTopicId: 18314
title: 减法运算
---
## Description
<section id='description'>
我们也可以在 JavaScript 中进行减法运算。
JavaScript 中使用<code>-</code>来做减法运算。
# --description--
<strong>示例</strong>
我们也可以在 JavaScript 中进行减法运算。
JavaScript 中使用`-`来做减法运算。
**示例**
```js
myVar = 12 - 6; // assigned 6
```
# --instructions--
</section>
改变数字`0`让变量 difference 的值为`12`
## Instructions
<section id='instructions'>
改变数字<code>0</code>让变量 difference 的值为<code>12</code>
</section>
# --hints--
## Tests
<section id='tests'>
```yml
tests:
- text: 要使<code>difference</code>的值等于 12。
testString: assert(difference === 12);
- text: 只用 45 减去一个数。
testString: assert(/var\s*difference\s*=\s*45\s*-\s*[0-9]*;(?!\s*[a-zA-Z0-9]+)/.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
要使`difference`的值等于 12。
```js
var difference = 45 - 0;
assert(difference === 12);
```
</div>
### After Test
<div id='js-teardown'>
只用 45 减去一个数。
```js
(function(z){return 'difference = '+z;})(difference);
assert(/var\s*difference\s*=\s*45\s*-\s*[0-9]*;(?!\s*[a-zA-Z0-9]+)/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var difference = 45 - 33;
```
</section>

View File

@ -1,15 +1,16 @@
---
id: 567af2437cbaa8c51670a16c
title: 测试对象的属性
challengeType: 1
videoUrl: 'https://scrimba.com/c/cm8Q7Ua'
forumTopicId: 18324
title: 测试对象的属性
---
## Description
<section id='description'>
有时检查一个对象属性是否存在是非常有用的,我们可以用<code>.hasOwnProperty(propname)</code>方法来检查对象是否有该属性。如果有返回<code>true</code>,反之返回<code>false</code>
<strong>示例</strong>
# --description--
有时检查一个对象属性是否存在是非常有用的,我们可以用`.hasOwnProperty(propname)`方法来检查对象是否有该属性。如果有返回`true`,反之返回`false`
**示例**
```js
var myObj = {
@ -20,75 +21,29 @@ myObj.hasOwnProperty("top"); // true
myObj.hasOwnProperty("middle"); // false
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
修改函数<code>checkObj</code>检查<code>myObj</code>是否有<code>checkProp</code>属性,如果属性存在,返回属性对应的值,如果不存在,返回<code>"Not Found"</code>
</section>
修改函数`checkObj`检查`myObj`是否有`checkProp`属性,如果属性存在,返回属性对应的值,如果不存在,返回`"Not Found"`
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>checkObj("gift")</code>应该返回<code>"pony"</code>。
testString: assert(checkObj("gift") === "pony");
- text: <code>checkObj("pet")</code>应该返回<code>"kitten"</code>。
testString: assert(checkObj("pet") === "kitten");
- text: <code>checkObj("house")</code>应该返回<code>"Not Found"</code>。
testString: assert(checkObj("house") === "Not Found");
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`checkObj("gift")`应该返回`"pony"`
```js
// Setup
var myObj = {
gift: "pony",
pet: "kitten",
bed: "sleigh"
};
function checkObj(checkProp) {
// Your Code Here
return "Change Me!";
}
// Test your code by modifying these values
checkObj("gift");
assert(checkObj('gift') === 'pony');
```
</div>
</section>
## Solution
<section id='solution'>
`checkObj("pet")`应该返回`"kitten"`
```js
var myObj = {
gift: "pony",
pet: "kitten",
bed: "sleigh"
};
function checkObj(checkProp) {
if(myObj.hasOwnProperty(checkProp)) {
return myObj[checkProp];
} else {
return "Not Found";
}
}
assert(checkObj('pet') === 'kitten');
```
</section>
`checkObj("house")`应该返回`"Not Found"`
```js
assert(checkObj('house') === 'Not Found');
```
# --solutions--

View File

@ -1,14 +1,15 @@
---
id: 56533eb9ac21ba0edf2244ba
title: 了解字符串的不变性
challengeType: 1
videoUrl: 'https://scrimba.com/c/cWPVaUR'
forumTopicId: 18331
title: 了解字符串的不变性
---
## Description
<section id='description'>
在 JavaScript 中,<code>字符串</code>的值是 <dfn>不可变的</dfn>,这意味着一旦字符串被创建就不能被改变。
# --description--
在 JavaScript 中,`字符串`的值是 <dfn>不可变的</dfn>,这意味着一旦字符串被创建就不能被改变。
例如,下面的代码:
```js
@ -16,71 +17,30 @@ var myStr = "Bob";
myStr[0] = "J";
```
是不会把变量<code>myStr</code>的值改变成 "Job" 的,因为变量<code>myStr</code>是不可变的。注意,这<em>并不</em>意味着<code>myStr</code>永远不能被改变,只是字符串字面量 <dfn>string literal</dfn> 的各个字符不能被改变。改变<code>myStr</code>中的唯一方法是重新给它赋一个值,例如:
是不会把变量`myStr`的值改变成 "Job" 的,因为变量`myStr`是不可变的。注意,这*并不*意味着`myStr`永远不能被改变,只是字符串字面量 <dfn>string literal</dfn> 的各个字符不能被改变。改变`myStr`中的唯一方法是重新给它赋一个值,例如:
```js
var myStr = "Bob";
myStr = "Job";
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
<code>myStr</code>的值改为<code>Hello World</code>
</section>
`myStr`的值改为`Hello World`
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: message:<code>myStr</code>的值应该是<code>Hello World</code>。
testString: assert(myStr === "Hello World");
- text: 不要修改注释上面的代码。
testString: assert(/myStr = "Jello World"/.test(code));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
message:`myStr`的值应该是`Hello World`
```js
// Setup
var myStr = "Jello World";
// Only change code below this line
myStr[0] = "H"; // Fix Me
assert(myStr === 'Hello World');
```
</div>
### After Test
<div id='js-teardown'>
不要修改注释上面的代码。
```js
(function(v){return "myStr = " + v;})(myStr);
assert(/myStr = "Jello World"/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myStr = "Jello World";
myStr = "Hello World";
```
</section>

View File

@ -1,74 +1,35 @@
---
id: bd7123c9c441eddfaeb5bdef
title: 理解布尔值
challengeType: 1
videoUrl: 'https://scrimba.com/c/c9Me8t4'
forumTopicId: 301176
title: 理解布尔值
---
## Description
<section id='description'>
另一种数据类型是<dfn>布尔</dfn>Boolean<code>布尔</code>值要么是<code>true</code>要么是<code>false</code>。它非常像电路开关,<code>true</code>是 “开”,<code>false</code>是 “关”。这两种状态是互斥的。
<strong>注意</strong><br><code>布尔值</code>是不带引号的,<code>"true"</code><code>"false"</code><code>字符串</code>而不是<code>布尔值</code>,在 JavaScript 中也没有特殊含义。
</section>
# --description--
## Instructions
<section id='instructions'>
修改<code>welcomeToBooleans</code>函数,让它返回<code>true</code>而不是<code>false</code>
</section>
另一种数据类型是<dfn>布尔</dfn>Boolean`布尔`值要么是`true`要么是`false`。它非常像电路开关,`true`是 “开”,`false`是 “关”。这两种状态是互斥的。
## Tests
<section id='tests'>
**注意**
`布尔值`是不带引号的,`"true"``"false"``字符串`而不是`布尔值`,在 JavaScript 中也没有特殊含义。
```yml
tests:
- text: <code>welcomeToBooleans()</code>函数应该返回一个布尔值 &#40;true/false&#41;。
testString: assert(typeof welcomeToBooleans() === 'boolean');
- text: <code>welcomeToBooleans()</code>应该返回 true。
testString: assert(welcomeToBooleans() === true);
# --instructions--
```
修改`welcomeToBooleans`函数,让它返回`true`而不是`false`
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`welcomeToBooleans()`函数应该返回一个布尔值 (true/false)。
```js
function welcomeToBooleans() {
// Only change code below this line.
return false; // Change this line
// Only change code above this line.
}
assert(typeof welcomeToBooleans() === 'boolean');
```
</div>
### After Test
<div id='js-teardown'>
`welcomeToBooleans()`应该返回 true。
```js
welcomeToBooleans();
assert(welcomeToBooleans() === true);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
function welcomeToBooleans() {
return true; // Change this line
}
```
</section>

View File

@ -1,18 +1,22 @@
---
id: 56533eb9ac21ba0edf2244ab
title: 了解变量名区分大小写
challengeType: 1
videoUrl: 'https://scrimba.com/c/cd6GDcD'
forumTopicId: 18334
title: 了解变量名区分大小写
---
## Description
<section id='description'>
# --description--
在 JavaScript 中所有的变量和函数名都是大小写敏感的。要区别对待大写字母和小写字母。
<code>MYVAR</code><code>MyVar</code><code>myvar</code>是截然不同的变量。这有可能导致出现多个相似名字的的变量。所以强烈地建议你,为了保持代码清晰不要使用这一特性。
`MYVAR``MyVar``myvar`是截然不同的变量。这有可能导致出现多个相似名字的的变量。所以强烈地建议你,为了保持代码清晰不要使用这一特性。
<h4>最佳实践</h4>
使用<dfn>驼峰命名法</dfn>来书写一个 Javascript 变量,在<dfn>驼峰命名法</dfn>中,变量名的第一个单词的首写字母小写,后面的单词的第一个字母大写。
<strong>示例:</strong>
**示例:**
```js
var someVariable;
@ -20,70 +24,49 @@ var anotherVariableName;
var thisVariableNameIsSoLong;
```
</section>
# --instructions--
## Instructions
<section id='instructions'>
修改已声明的变量,让它们的命名符合<dfn>驼峰命名法</dfn>的规范。
</section>
## Tests
<section id='tests'>
# --hints--
```yml
tests:
- text: <code>studlyCapVar</code>应该被定义并且值为<code>10</code>。
testString: assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
- text: <code>properCamelCase</code>应该被定义并且值为<code>"A String"</code>。
testString: assert(typeof properCamelCase !== 'undefined' && properCamelCase === "A String");
- text: <code>titleCaseOver</code>应该被定义并且值为<code>9000</code>。
testString: assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
- text: <code>studlyCapVar</code>在声明和赋值时都应该使用驼峰命名法。
testString: assert(code.match(/studlyCapVar/g).length === 2);
- text: <code>properCamelCase</code> 在声明和赋值时都应该使用驼峰命名法。
testString: assert(code.match(/properCamelCase/g).length === 2);
- text: <code>titleCaseOver</code> 在声明和赋值时都应该使用驼峰命名法。
testString: assert(code.match(/titleCaseOver/g).length === 2);
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`studlyCapVar`应该被定义并且值为`10`
```js
// Declarations
var StUdLyCapVaR;
var properCamelCase;
var TitleCaseOver;
// Assignments
STUDLYCAPVAR = 10;
PRoperCAmelCAse = "A String";
tITLEcASEoVER = 9000;
assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
```
</div>
</section>
## Solution
<section id='solution'>
`properCamelCase`应该被定义并且值为`"A String"`
```js
var studlyCapVar;
var properCamelCase;
var titleCaseOver;
studlyCapVar = 10;
properCamelCase = "A String";
titleCaseOver = 9000;
assert(
typeof properCamelCase !== 'undefined' && properCamelCase === 'A String'
);
```
</section>
`titleCaseOver`应该被定义并且值为`9000`
```js
assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
```
`studlyCapVar`在声明和赋值时都应该使用驼峰命名法。
```js
assert(code.match(/studlyCapVar/g).length === 2);
```
`properCamelCase` 在声明和赋值时都应该使用驼峰命名法。
```js
assert(code.match(/properCamelCase/g).length === 2);
```
`titleCaseOver` 在声明和赋值时都应该使用驼峰命名法。
```js
assert(code.match(/titleCaseOver/g).length === 2);
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 598e8944f009e646fc236146
title: 函数也可以返回 undefined
challengeType: 1
videoUrl: 'https://scrimba.com/c/ce2p7cL'
forumTopicId: 301177
title: 函数也可以返回 undefined
---
## Description
<section id='description'>
函数一般用<code>return</code>语句来返回值,但这不是必须的。在函数没有<code>return</code>语句的情况下,当你调用它时,该函数会执行内部代码,返回的值是<code>undefined</code>
<strong>示例</strong>
# --description--
函数一般用`return`语句来返回值,但这不是必须的。在函数没有`return`语句的情况下,当你调用它时,该函数会执行内部代码,返回的值是`undefined`
**示例**
```js
var sum = 0;
@ -19,74 +20,42 @@ function addSum(num) {
addSum(3); // sum will be modified but returned value is undefined
```
<code>addSum</code>是一个没有<code>return</code>语句的函数。该函数将更改全局变量<code>sum</code>,函数的返回值为<code>undefined</code>
</section>
`addSum`是一个没有`return`语句的函数。该函数将更改全局变量`sum`,函数的返回值为`undefined`
## Instructions
<section id='instructions'>
创建一个没有任何参数的函数<code>addFive</code>。此函数使<code>sum</code>变量加 5但其返回值是<code>undefined</code>
</section>
# --instructions--
## Tests
<section id='tests'>
创建一个没有任何参数的函数`addFive`。此函数使`sum`变量加 5但其返回值是`undefined`
```yml
tests:
- text: <code>addFive</code>应该是一个函数。
testString: assert(typeof addFive === 'function');
- text: <code>sum</code>应该等于 8。
testString: assert(sum === 8);
- text: <code>addFive</code>的返回值应该是<code>undefined</code>。
testString: assert(addFive() === undefined);
- text: 函数给变量 <code>sum</code> 加 5。
testString: assert(addFive.toString().replace(/\s/g, '').match(/sum=sum\+5|sum\+=5/));
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`addFive`应该是一个函数。
```js
// Example
var sum = 0;
function addThree() {
sum = sum + 3;
}
// Only change code below this line
// Only change code above this line
addThree();
addFive();
assert(typeof addFive === 'function');
```
</div>
## Solution
<section id='solution'>
`sum`应该等于 8。
```js
// Example
var sum = 0;
function addThree() {
sum = sum + 3;
}
// Only change code below this line
function addFive() {
sum = sum + 5;
}
// Only change code above this line
addThree();
addFive();
assert(sum === 8);
```
</section>
`addFive`的返回值应该是`undefined`
```js
assert(addFive() === undefined);
```
函数给变量 `sum` 加 5。
```js
assert(
addFive
.toString()
.replace(/\s/g, '')
.match(/sum=sum\+5|sum\+=5/)
);
```
# --solutions--

View File

@ -1,83 +1,48 @@
---
id: 56533eb9ac21ba0edf2244aa
title: 理解未初始化的变量
challengeType: 1
videoUrl: 'https://scrimba.com/c/cBa2JAL'
forumTopicId: 18335
title: 理解未初始化的变量
---
## Description
<section id='description'>
当 JavaScript 中的变量被声明的时候,程序内部会给它一个初始值<code>undefined</code>。当你对一个值为<code>undefined</code>的变量进行运算操作的时候,算出来的结果将会是<code>NaN</code><code>NaN</code>的意思是<dfn>"Not a Number"</dfn>。当你用一个值是<code>undefined</code>的变量来做字符串拼接操作的时候,它会输出字符串<code>"undefined"</code>
</section>
# --description--
## Instructions
<section id='instructions'>
定义 3 个变量<code>a</code><code>b</code><code>c</code>,并且分别给他们赋值:<code>5</code><code>10</code><code>"I am a"</code>,这样它们值就不会是<code>undefined</code>了。
</section>
当 JavaScript 中的变量被声明的时候,程序内部会给它一个初始值`undefined`。当你对一个值为`undefined`的变量进行运算操作的时候,算出来的结果将会是`NaN``NaN`的意思是<dfn>"Not a Number"</dfn>。当你用一个值是`undefined`的变量来做字符串拼接操作的时候,它会输出字符串`"undefined"`
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: <code>a</code>应该被定义,并且值为<code>6</code>。
testString: assert(typeof a === 'number' && a === 6);
- text: <code>b</code>应该被定义,并且值为<code>15</code>。
testString: assert(typeof b === 'number' && b === 15);
- text: <code>c</code>的值不能包含<code>undefined</code>,应该为 "I am a String!"。
testString: assert(!/undefined/.test(c) && c === "I am a String!");
- text: 不要修改第二条注释下的代码。
testString: assert(/a = a \+ 1;/.test(code) && /b = b \+ 5;/.test(code) && /c = c \+ " String!";/.test(code));
定义 3 个变量`a``b``c`,并且分别给他们赋值:`5``10``"I am a"`,这样它们值就不会是`undefined`了。
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`a`应该被定义,并且值为`6`
```js
// Initialize these three variables
var a;
var b;
var c;
// Do not change code below this line
a = a + 1;
b = b + 5;
c = c + " String!";
assert(typeof a === 'number' && a === 6);
```
</div>
### After Test
<div id='js-teardown'>
`b`应该被定义,并且值为`15`
```js
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = '" + c + "'"; })(a,b,c);
assert(typeof b === 'number' && b === 15);
```
</div>
</section>
## Solution
<section id='solution'>
`c`的值不能包含`undefined`,应该为 "I am a String!"。
```js
var a = 5;
var b = 10;
var c = "I am a";
a = a + 1;
b = b + 5;
c = c + " String!";
assert(!/undefined/.test(c) && c === 'I am a String!');
```
</section>
不要修改第二条注释下的代码。
```js
assert(
/a = a \+ 1;/.test(code) &&
/b = b \+ 5;/.test(code) &&
/c = c \+ " String!";/.test(code)
);
```
# --solutions--

View File

@ -1,15 +1,16 @@
---
id: 56bbb991ad1ed5201cd392d1
title: 更新对象属性
challengeType: 1
videoUrl: 'https://scrimba.com/c/c9yEJT4'
forumTopicId: 18336
title: 更新对象属性
---
## Description
<section id='description'>
# --description--
当你创建了一个对象后,你可以用点操作符或中括号操作符来更新对象的属性。
举个例子,让我们看看<code>ourDog</code>:
举个例子,让我们看看`ourDog`:
```js
var ourDog = {
@ -20,86 +21,25 @@ var ourDog = {
};
```
让我们更改它的名称为 "Happy Camper",这有两种方式来更新对象的<code>name</code>属性:
<code>ourDog.name = "Happy Camper";</code>
<code>ourDog["name"] = "Happy Camper";</code>
现在,<code>ourDog.name</code>的值就不再是 "Camper",而是 "Happy Camper"。
</section>
让我们更改它的名称为 "Happy Camper",这有两种方式来更新对象的`name`属性: `ourDog.name = "Happy Camper";``ourDog["name"] = "Happy Camper";` 现在,`ourDog.name`的值就不再是 "Camper",而是 "Happy Camper"。
## Instructions
<section id='instructions'>
更新<code>myDog</code>对象的<code>name</code>属性,让它的名字从 "Coder" 变成 "Happy Coder"。
</section>
# --instructions--
## Tests
<section id='tests'>
更新`myDog`对象的`name`属性,让它的名字从 "Coder" 变成 "Happy Coder"。
```yml
tests:
- text: 更新<code>myDog</code>的<code>"name"</code>属性, 使其等于 "Happy Coder"。
testString: assert(/happy coder/gi.test(myDog.name));
- text: 不要修改<code>myDog</code>的定义。
testString: 'assert(/"name": "Coder"/.test(code));'
# --hints--
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
更新`myDog``"name"`属性, 使其等于 "Happy Coder"。
```js
// Example
var ourDog = {
"name": "Camper",
"legs": 4,
"tails": 1,
"friends": ["everything!"]
};
ourDog.name = "Happy Camper";
// Setup
var myDog = {
"name": "Coder",
"legs": 4,
"tails": 1,
"friends": ["freeCodeCamp Campers"]
};
// Only change code below this line.
assert(/happy coder/gi.test(myDog.name));
```
</div>
### After Test
<div id='js-teardown'>
不要修改`myDog`的定义。
```js
(function(z){return z;})(myDog);
assert(/"name": "Coder"/.test(code));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var myDog = {
"name": "Coder",
"legs": 4,
"tails": 1,
"friends": ["freeCodeCamp Campers"]
};
myDog.name = "Happy Coder";
```
</section>

View File

@ -1,84 +1,39 @@
---
id: bd7123c9c549eddfaeb5bdef
title: 使用方括号查找字符串中的第一个字符
challengeType: 1
videoUrl: 'https://scrimba.com/c/ca8JwhW'
forumTopicId: 18341
title: 使用方括号查找字符串中的第一个字符
---
## Description
<section id='description'>
方括号表示法是一种在字符串中的特定<code>index</code>(索引)处获取字符的方法。
# --description--
方括号表示法是一种在字符串中的特定`index`(索引)处获取字符的方法。
大多数现代编程语言如JavaScript不同于人类从 1 开始计数。它们是从 0 开始计数,这被称为 <dfn>基于零</dfn> 的索引。
例如, 在单词 "Charles" 中索引 0 上的字符为 "C",所以在<code>var firstName = "Charles"</code>中,你可以使用<code>firstName[0]</code>来获得第一个位置上的字符。
</section>
## Instructions
<section id='instructions'>
使用方括号获取变量<code>lastName</code>中的第一个字符,并赋给变量<code>firstLetterOfLastName</code>
<strong>提示</strong><br>如果你遇到困难了,不妨看看变量<code>firstLetterOfFirstName</code>是如何赋值的。
</section>
例如, 在单词 "Charles" 中索引 0 上的字符为 "C",所以在`var firstName = "Charles"`中,你可以使用`firstName[0]`来获得第一个位置上的字符。
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: <code>firstLetterOfLastName</code>的值应该是<code>L</code>。
testString: assert(firstLetterOfLastName === 'L');
- text: 你应该使用中括号。
testString: assert(code.match(/firstLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
使用方括号获取变量`lastName`中的第一个字符,并赋给变量`firstLetterOfLastName`
```
**提示**
如果你遇到困难了,不妨看看变量`firstLetterOfFirstName`是如何赋值的。
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`firstLetterOfLastName`的值应该是`L`
```js
// Example
var firstLetterOfFirstName = "";
var firstName = "Ada";
firstLetterOfFirstName = firstName[0];
// Setup
var firstLetterOfLastName = "";
var lastName = "Lovelace";
// Only change code below this line
firstLetterOfLastName = lastName;
assert(firstLetterOfLastName === 'L');
```
</div>
### After Test
<div id='js-teardown'>
你应该使用中括号。
```js
(function(v){return v;})(firstLetterOfLastName);
assert(code.match(/firstLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var firstLetterOfLastName = "";
var lastName = "Lovelace";
// Only change code below this line
firstLetterOfLastName = lastName[0];
```
</section>

View File

@ -1,80 +1,34 @@
---
id: bd7123c9c451eddfaeb5bdef
title: 使用方括号查找字符串中的最后一个字符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cBZQGcv'
forumTopicId: 18342
title: 使用方括号查找字符串中的最后一个字符
---
## Description
<section id='description'>
# --description--
要获取字符串的最后一个字符,可以用字符串的长度减 1 的索引值。
例如,在<code>var firstName = "Charles"</code>中,你可以这样操作<code>firstName[firstName.length - 1]</code>来得到字符串的最后的一个字符。
</section>
## Instructions
<section id='instructions'>
使用<dfn>方括号<dfn来取得<code>lastName</code>变量中的最后一个字符。
<strong>提示</strong><br>如果你遇到困难了,不妨看看在<code>lastLetterOfFirstName</code>变量上是怎么做的。
</section>
例如,在`var firstName = "Charles"`中,你可以这样操作`firstName[firstName.length - 1]`来得到字符串的最后的一个字符。
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: <code>lastLetterOfLastName</code>应该是"e"。
testString: assert(lastLetterOfLastName === "e");
- text: 你需要使用<code>.length</code>获取最后一个字符。
testString: assert(code.match(/\.length/g).length === 2);
使用<dfn>方括号&lt;dfn来取得<code>lastName变量中的最后一个字符。 <strong>提示</strong><br>如果你遇到困难了,不妨看看在<code>lastLetterOfFirstName</code>变量上是怎么做的。 &lt;/dfn来取得<code></code></code></dfn>
```
# --hints--
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`lastLetterOfLastName`应该是"e"。
```js
// Example
var firstName = "Ada";
var lastLetterOfFirstName = firstName[firstName.length - 1];
// Setup
var lastName = "Lovelace";
// Only change code below this line.
var lastLetterOfLastName = lastName;
assert(lastLetterOfLastName === 'e');
```
</div>
### After Test
<div id='js-teardown'>
你需要使用`.length`获取最后一个字符。
```js
(function(v){return v;})(lastLetterOfLastName);
assert(code.match(/\.length/g).length === 2);
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var firstName = "Ada";
var lastLetterOfFirstName = firstName[firstName.length - 1];
var lastName = "Lovelace";
var lastLetterOfLastName = lastName[lastName.length - 1];
```
</section>

View File

@ -1,77 +1,37 @@
---
id: bd7123c9c450eddfaeb5bdef
title: 使用方括号查找字符串中的第N个字符
challengeType: 1
videoUrl: 'https://scrimba.com/c/cWPVJua'
forumTopicId: 18343
title: 使用方括号查找字符串中的第N个字符
---
## Description
<section id='description'>
# --description--
你也可以使用方括号来获得一个字符串中的其他位置的字符。
请记住,程序是从<code>0</code>开始计数,所以获取第一个字符实际上是[0]。
</section>
## Instructions
<section id='instructions'>
让我们使用方括号,把<code>lastName</code>变量的第三个字符赋值给<code>thirdLetterOfLastName</code>
<strong>提示</strong><br>如果你遇到困难了,看看<code>secondLetterOfFirstName</code>变量是如何做的。
</section>
请记住,程序是从`0`开始计数,所以获取第一个字符实际上是\[0]。
## Tests
<section id='tests'>
# --instructions--
```yml
tests:
- text: <code>thirdLetterOfLastName</code>的值应该是<code>v</code>。
testString: assert(thirdLetterOfLastName === 'v');
- text: 你应该使用方括号。
testString: assert(code.match(/thirdLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
让我们使用方括号,把`lastName`变量的第三个字符赋值给`thirdLetterOfLastName`
```
**提示**
如果你遇到困难了,看看`secondLetterOfFirstName`变量是如何做的。
</section>
# --hints--
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
`thirdLetterOfLastName`的值应该是`v`
```js
// Example
var firstName = "Ada";
var secondLetterOfFirstName = firstName[1];
// Setup
var lastName = "Lovelace";
// Only change code below this line.
var thirdLetterOfLastName = lastName;
assert(thirdLetterOfLastName === 'v');
```
</div>
### After Test
<div id='js-teardown'>
你应该使用方括号。
```js
(function(v){return v;})(thirdLetterOfLastName);
assert(code.match(/thirdLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
```
</div>
# --solutions--
</section>
## Solution
<section id='solution'>
```js
var lastName = "Lovelace";
var thirdLetterOfLastName = lastName[2];
```
</section>

Some files were not shown because too many files have changed in this diff Show More