gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix(i18n): update Chinese translation of basic javascript (#38027)

Browse Source
This commit is contained in:
ZhichengChen
2020-04-29 18:29:13 +08:00
committed by GitHub
parent 18ca64ed4e
commit 39df9d94c9
110 changed files with 4047 additions and 1195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-array-data-with-indexes.chinese.md
View File

@ -2,24 +2,41 @@
id: 56bbb991ad1ed5201cd392ca
title: Access Array Data with Indexes
challengeType: 1
videoUrl: ''
localeTitle: 使用索引访问数组数据
videoUrl: 'https://scrimba.com/c/cBZQbTz'
forumTopicId: 16158
localeTitle: 通过索引访问数组中的数据
---
## Description
<section id="description">我们可以使用<code>indexes</code>访问数组内部的数据。数组索引使用字符串使用的相同括号表示法编写，但不是指定字符，而是指定数组中的条目。与字符串一样，数组使用<dfn>从零开始的</dfn>索引，因此数组中的第一个元素是元素<code>0</code> 。 <strong>例</strong> <blockquote> var array = [50,60,70]; <br>阵列[0]; //等于50 <br> var data = array [1]; //等于60 </blockquote> <strong>注意</strong> <br>数组名称和方括号之间不应有任何空格，如<code>array [0]</code> 。尽管JavaScript能够正确处理，但这可能会让其他程序员在阅读代码时感到困惑。 </section>
<section id='description'>
我们可以使用索引 <code>indexes</code> 来访问数组中的数据。
数组索引与字符串索引一样使用中括号，但字符串索引得到的是一个字符，而数组索引得到的是一个元素。数组索引与字符串索引一样是从 0 开始的，所以数组中第一个元素的索引编号是 0。
<br/>
<strong>示例</strong>
```js
var array = [50,60,70];
array[0]; // equals 50
var data = array[1]; // equals 60
```
<strong>提示</strong><br>数组名称和方括号之间不应有任何空格，如<code>array [0]</code>尽管 JavaScript 能够正确处理，但可能会让看你代码的其他程序员感到困惑
</section>
## Instructions
<section id="instructions">创建一个名为<code>myData</code>的变量，并使用括号表示法将其设置为等于<code>myArray</code>的第一个值。 </section>
<section id='instructions'>
创建一个名为<code>myData</code>的变量，并把<code>myArray</code>的第一个索引上的值赋给它。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 变量<code>myData</code>应该等于<code>myArray</code>的第一个值。
- 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>的数据。
- text: 应使用方括号访问变量<code>myArray</code>中的数据。
testString: assert((function(){if(code.match(/\s*=\s*myArray\[0\]/g)){return true;}else{return false;}})());
```
@ -50,7 +67,7 @@ var myArray = [50,60,70];
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myArray !== "undefined" && typeof myData !== "undefined"){(function(y,z){return 'myArray = ' + JSON.stringify(y) + ', myData = ' + JSON.stringify(z);})(myArray, myData);}
```
</div>
@ -60,7 +77,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [50,60,70];
var myData = myArray[0];
```
</section>

41
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/access-multi-dimensional-arrays-with-indexes.chinese.md
View File

@ -2,25 +2,45 @@
id: 56592a60ddddeae28f7aa8e1
title: Access Multi-Dimensional Arrays With Indexes
challengeType: 1
videoUrl: ''
localeTitle: 访问带索引的多维数组
videoUrl: 'https://scrimba.com/c/ckND4Cq'
forumTopicId: 16159
localeTitle: 使用索引访问多维数组
---
## Description
<section id="description">考虑<dfn>多维</dfn>数组的一种方法是作为<em>数组的数组</em> 。使用括号访问数组时，第一组括号引用最外层（第一级）数组中的条目，另外一对括号引用内部的下一级条目。 <strong>例</strong> <blockquote> var arr = [ <br> [1,2,3]， <br> [4,5,6] <br> [7,8,9] <br> [[10,11,12]，13,14] <br> ]。 <br> ARR [3]; //等于[[10,11,12]，13,14] <br> ARR [3] [0]; //等于[10,11,12] <br> ARR [3] [0] [1]; //等于11 </blockquote> <strong>注意</strong> <br>数组名称和方括号之间不应该有任何空格，如<code>array [0][0]</code> ，甚至不允许使用此<code>array [0] [0]</code> 。尽管JavaScript能够正确处理，但这可能会让其他程序员在阅读代码时感到困惑。 </section>
<section id='description'>
可以把 <dfn>多维</dfn> 数组看作成是一个 <em>数组中的数组</em>。当使用方括号去访问数组的时候，第一个<code>[index]</code>访问的是第 N 个子数组，第二个<code>[index]</code>访问的是第 N 个子数组的第N个元素。
<strong>示例</strong>
```js
var arr = [
[1,2,3],
[4,5,6],
[7,8,9],
[[10,11,12], 13, 14]
];
arr[3]; // equals [[10,11,12], 13, 14]
arr[3][0]; // equals [10,11,12]
arr[3][0][1]; // equals 11
```
<strong>提示</strong><br>数组名称和方括号之间不应该有任何空格，如<code>array [0][0]</code>，甚至<code>array [0] [0]</code>，都是不正确的。尽管 JavaScript 能够处理，但可能会让看你代码的其他程序员感到困惑。
</section>
## Instructions
<section id="instructions">使用括号表示法从<code>myArray</code>选择一个元素，使<code>myData</code>等于<code>8</code> 。 </section>
<section id='instructions'>
使用索引从<code>myArray</code>选择一个元素，使得<code>myData</code>的值为<code>8</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myData</code>应该等于<code>8</code> 。
- text: <code>myData</code>应该等于<code>8</code>。
testString: assert(myData === 8);
- text: 您应该使用括号表示法从<code>myArray</code>读取正确的值。
testString: assert(/myData=myArray\[2\]\[1\]/.test(code.replace(/\s/g, '')));
- text: 你应该使用方括号从<code>myArray</code>中取值。
testString: 'assert(/myArray\[2\]\[1\]/g.test(code) && !/myData\s*=\s*(?:.*[-+*/%]|\d)/g.test(code));'
```
@ -47,7 +67,7 @@ var myData = myArray[0][0];
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myArray !== "undefined"){(function(){return "myData: " + myData + " myArray: " + JSON.stringify(myArray);})();}
```
</div>
@ -57,7 +77,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [[1,2,3],[4,5,6], [7,8,9], [[10,11,12], 13, 14]];
var myData = myArray[2][1];
```
</section>

72
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays.chinese.md
View File

@ -2,24 +2,54 @@
id: 56533eb9ac21ba0edf2244cd
title: Accessing Nested Arrays
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/cLeGDtZ'
forumTopicId: 16160
localeTitle: 访问嵌套数组
---
## Description
<section id="description">正如我们在前面的示例中所看到的，对象可以包含嵌套对象和嵌套数组。与访问嵌套对象类似，可以链接数组括号表示法来访问嵌套数组。以下是如何访问嵌套数组的示例： <blockquote> var ourPets = [ <br> { <br> animalType：“猫”， <br>名称：[ <br> “Meowzer” <br> “蓬松”， <br> “洁猫” <br> ] <br> }， <br> { <br>动物类型：“狗”， <br>名称：[ <br> “点”， <br> “库巴” <br> “羊羊” <br> ] <br> } <br> ]。 <br> ourPets [0] .names [1]; //“蓬松” <br> ourPets [1] .names [0]; //“Spot” </blockquote></section>
<section id='description'>
正如我们在前面的例子所见，对象可以嵌套对象和数组。与访问嵌套对象一样，用中括号操作符同样可以访问嵌套数组。
下面是如何访问嵌套数组的例子：
```js
var ourPets = [
{
animalType: "cat",
names: [
"Meowzer",
"Fluffy",
"Kit-Cat"
]
},
{
animalType: "dog",
names: [
"Spot",
"Bowser",
"Frankie"
]
}
];
ourPets[0].names[1]; // "Fluffy"
ourPets[1].names[0]; // "Spot"
```
</section>
## Instructions
<section id="instructions">使用对象点和数组括号表示法从变量<code>myPlants</code>检索第二个树。 </section>
<section id='instructions'>
使用点操作符和中括号操作符来检索变量<code>myPlants</code>的第二棵树。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>secondTree</code>应该等于“松树”
- text: <code>secondTree</code>应该等于 "pine"。
testString: assert(secondTree === "pine");
- text: 使用点和括号表示法访问<code>myPlants</code>
- text: 使用点操作符和中括号操作符来检索变量<code>myPlants</code>。
testString: assert(/=\s*myPlants\[1\].list\[1\]/.test(code));
```
@ -65,7 +95,12 @@ var secondTree = ""; // Change this line
<div id='js-teardown'>
```js
console.info('after the test');
(function(x) {
if(typeof x != 'undefined') {
return "secondTree = " + x;
}
return "secondTree is undefined";
})(secondTree);
```
</div>
@ -75,7 +110,30 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
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>

56
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-objects.chinese.md
View File

@ -2,24 +2,48 @@
id: 56533eb9ac21ba0edf2244cc
title: Accessing Nested Objects
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/cRnRnfa'
forumTopicId: 16161
localeTitle: 访问嵌套对象
---
## Description
<section id="description">可以通过将点或括号表示法链接在一起来访问对象的子属性。这是一个嵌套对象： <blockquote> var ourStorage = { <br> “桌子”：{ <br> “抽屉”：“订书机” <br> }， <br> “内阁”：{ <br> “顶级抽屉”：{ <br> “folder1”：“一个文件”， <br> “folder2”：“秘密” <br> }， <br> “底部抽屉”：“苏打水” <br> } <br> }; <br> ourStorage.cabinet [“top drawer”]。folder2; //“秘密” <br> ourStorage.desk.drawer; //“订书机” </blockquote></section>
<section id='description'>
通过串联起来的点操作符或中括号操作符来访问对象的嵌套属性。
下面是一个嵌套的对象：
```js
var ourStorage = {
"desk": {
"drawer": "stapler"
},
"cabinet": {
"top drawer": {
"folder1": "a file",
"folder2": "secrets"
},
"bottom drawer": "soda"
}
};
ourStorage.cabinet["top drawer"].folder2; // "secrets"
ourStorage.desk.drawer; // "stapler"
```
</section>
## Instructions
<section id="instructions">访问<code>myStorage</code>对象并将<code>glove box</code>属性的内容分配给<code>gloveBoxContents</code>变量。对于名称中包含空格的属性，请使用括号表示法。 </section>
<section id='instructions'>
读取<code>myStorage</code>对象，将<code>glove box</code>属性的内容赋值给变量<code>gloveBoxContents</code>。在适用的地方使用点操作符来访问属性，否则使用中括号操作符。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>gloveBoxContents</code>应该等于“地图”
- text: <code>gloveBoxContents</code>应该等于"maps"。
testString: assert(gloveBoxContents === "maps");
- text: 使用点和括号表示法访问<code>myStorage</code>
- text: 应使用点操作符和中括号操作符来访问<code>myStorage</code>。
testString: assert(/=\s*myStorage\.car\.inside\[\s*("|')glove box\1\s*\]/g.test(code));
```
@ -56,7 +80,12 @@ var gloveBoxContents = undefined; // Change this line
<div id='js-teardown'>
```js
console.info('after the test');
(function(x) {
if(typeof x != 'undefined') {
return "gloveBoxContents = " + x;
}
return "gloveBoxContents is undefined";
})(gloveBoxContents);
```
</div>
@ -66,7 +95,20 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myStorage = {
"car":{
"inside":{
"glove box":"maps",
"passenger seat":"crumbs"
},
"outside":{
"trunk":"jack"
}
}
};
var gloveBoxContents = myStorage.car.inside["glove box"];
```
</section>

51
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-bracket-notation.chinese.md
View File

@ -2,30 +2,50 @@
id: 56533eb9ac21ba0edf2244c8
title: Accessing Object Properties with Bracket Notation
challengeType: 1
videoUrl: ''
localeTitle: 使用括号表示法访问对象属性
videoUrl: 'https://scrimba.com/c/cBvmEHP'
forumTopicId: 16163
localeTitle: 通过方括号访问对象属性
---
## Description
<section id="description">访问对象属性的第二种方法是括号表示法（ <code>[]</code> ）。如果您尝试访问的对象的属性在其名称中有空格，则需要使用括号表示法。但是，您仍然可以在没有空格的对象属性上使用括号表示法。以下是使用括号表示法读取对象属性的示例： <blockquote> var myObj = { <br> “太空名称”：“柯克”， <br> “更多空间”：“Spock”​​， <br> “NoSpace”：“USS Enterprise” <br> }; <br> myObj [“空间名称”]; //柯克<br> myObj [&#39;更多空间&#39;]; // Spock <br> MyObj中[ “无空间”]; // USS Enterprise </blockquote>请注意，其中包含空格的属性名称必须使用引号（单引号或双引号）。 </section>
<section id='description'>
第二种访问对象的方式就是中括号操作符(<code>[]</code>)，如果你想访问的属性的名称有一个空格，这时你只能使用中括号操作符(<code>[]</code>)。
当然，如果属性名不包含空格，也可以使用中括号操作符。
这是一个使用中括号操作符(<code>[]</code>)读取对象属性的例子：
```js
var myObj = {
"Space Name": "Kirk",
"More Space": "Spock",
"NoSpace": "USS Enterprise"
};
myObj["Space Name"]; // Kirk
myObj['More Space']; // Spock
myObj["NoSpace"]; // USS Enterprise
```
提示：属性名称中如果有空格，必须把属性名称用单引号或双引号包裹起来。
</section>
## Instructions
<section id="instructions">使用括号表示法<code>testObj</code>属性<code>&quot;an entree&quot;</code> <code>testObj</code> <code>&quot;an entree&quot;</code>和<code>&quot;the drink&quot;</code>的<code>testObj</code> ，并分别将它们分配给<code>entreeValue</code>和<code>drinkValue</code> 。 </section>
<section id='instructions'>
用中括号操作符读取对象<code>testObj</code>的<code>an entree</code>属性值和<code>the drink</code>属性值，并分别赋值给<code>entreeValue</code>和<code>drinkValue</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>entreeValue</code>应该是一个字符串
- text: <code>entreeValue</code>应该是一个字符串。
testString: assert(typeof entreeValue === 'string' );
- text: <code>entreeValue</code>的值应该是<code>&quot;hamburger&quot;</code>
- text: <code>entreeValue</code>的值应该是<code>"hamburger"</code>。
testString: assert(entreeValue === 'hamburger' );
- text: <code>drinkValue</code>应该是一个字符串
- text: <code>drinkValue</code>应该是一个字符串。
testString: assert(typeof drinkValue === 'string' );
- text: <code>drinkValue</code>的值应该是<code>&quot;water&quot;</code>
- text: <code>drinkValue</code>的值应该是<code>"water"</code>。
testString: assert(drinkValue === 'water' );
- text: 您应该使用括号表示法两次
- text: 你应该使用中括号两次。
testString: assert(code.match(/testObj\s*?\[('|")[^'"]+\1\]/g).length > 1);
```
@ -49,7 +69,6 @@ var testObj = {
var entreeValue = testObj; // Change this line
var drinkValue = testObj; // Change this line
```
</div>
@ -59,7 +78,7 @@ var drinkValue = testObj; // Change this line
<div id='js-teardown'>
```js
console.info('after the test');
(function(a,b) { return "entreeValue = '" + a + "', drinkValue = '" + b + "'"; })(entreeValue,drinkValue);
```
</div>
@ -69,7 +88,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var testObj = {
"an entree": "hamburger",
"my side": "veggies",
"the drink": "water"
};
var entreeValue = testObj["an entree"];
var drinkValue = testObj['the drink'];
```
</section>

49
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-dot-notation.chinese.md
View File

@ -2,30 +2,47 @@
id: 56533eb9ac21ba0edf2244c7
title: Accessing Object Properties with Dot Notation
challengeType: 1
videoUrl: ''
localeTitle: 使用点表示法访问对象属性
videoUrl: 'https://scrimba.com/c/cGryJs8'
forumTopicId: 16164
localeTitle: 通过点符号访问对象属性
---
## Description
<section id="description">有两种方法可以访问对象的属性：点表示法（ <code>.</code> ）和括号表示法（ <code>[]</code> ），类似于数组。当您知道要提前访问的属性的名称时，使用点符号。以下是使用点表示法（ <code>.</code> ）读取对象属性的示例： <blockquote> var myObj = { <br> prop1：“val1”， <br> prop2：“val2” <br> }; <br> var prop1val = myObj.prop1; // val1 <br> var prop2val = myObj.prop2; // val2 </blockquote></section>
<section id='description'>
有两种方式访问对象属性，一个是点操作符(<code>.</code>)，一个是中括号操作符(<code>[]</code>)。
当你知道所要读取的属性的名称的时候，使用点操作符。
这是一个使用点操作符读取对象属性的例子：
```js
var myObj = {
prop1: "val1",
prop2: "val2"
};
var prop1val = myObj.prop1; // val1
var prop2val = myObj.prop2; // val2
```
</section>
## Instructions
<section id="instructions">使用点表示法读入<code>testObj</code>的属性值。将变量<code>hatValue</code>设置为等于对象的属性<code>hat</code> ，并将变量<code>shirtValue</code>设置为等于对象的属性<code>shirt</code> 。 </section>
<section id='instructions'>
通过点操作符读取对象<code>testObj</code>，把<code>hat</code>的属性值赋给变量<code>hatValue</code>，把<code>shirt</code>的属性值赋给<code>shirtValue</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>hatValue</code>应该是一个字符串
- text: <code>hatValue</code>应该是一个字符串。
testString: assert(typeof hatValue === 'string' );
- text: <code>hatValue</code>的值应该是<code>&quot;ballcap&quot;</code>
- text: <code>hatValue</code>的值应该是<code>"ballcap"</code>。
testString: assert(hatValue === 'ballcap' );
- text: <code>shirtValue</code>应该是一个字符串
- text: <code>shirtValue</code>应该是一个字符串。
testString: assert(typeof shirtValue === 'string' );
- text: <code>shirtValue</code>的值应该是<code>&quot;jersey&quot;</code>
- text: <code>shirtValue</code>的值应该是<code>"jersey"</code>。
testString: assert(shirtValue === 'jersey' );
- text: 你应该使用点符号两次
- text: 你应该使用点操作符两次。
testString: assert(code.match(/testObj\.\w+/g).length > 1);
```
@ -49,7 +66,6 @@ var testObj = {
var hatValue = testObj; // Change this line
var shirtValue = testObj; // Change this line
```
</div>
@ -59,7 +75,7 @@ var shirtValue = testObj; // Change this line
<div id='js-teardown'>
```js
console.info('after the test');
(function(a,b) { return "hatValue = '" + a + "', shirtValue = '" + b + "'"; })(hatValue,shirtValue);
```
</div>
@ -69,7 +85,16 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var testObj = {
"hat": "ballcap",
"shirt": "jersey",
"shoes": "cleats"
};
var hatValue = testObj.hat;
var shirtValue = testObj.shirt;
```
</section>

64
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables.chinese.md
View File

@ -2,32 +2,63 @@
id: 56533eb9ac21ba0edf2244c9
title: Accessing Object Properties with Variables
challengeType: 1
videoUrl: ''
localeTitle: 使用变量访问对象属性
videoUrl: 'https://scrimba.com/c/cnQyKur'
forumTopicId: 16165
localeTitle: 通过变量访问对象属性
---
## Description
<section id="description">对象的括号表示法的另一个用途是访问存储为变量值的属性。这对于迭代对象的属性或访问查找表非常有用。以下是使用变量访问属性的示例： <blockquote> var dogs = { <br> Fido：“Mutt”，Hunter：“Doberman”，Snoopie：“Beagle” <br> }; <br> var myDog =“猎人”; <br> var myBreed = dogs [myDog]; <br>的console.log（myBreed）; //“杜宾犬” </blockquote>另一种可以使用此概念的方法是在程序执行期间动态收集属性的名称，如下所示： <blockquote> var someObj = { <br> propName：“约翰” <br> }; <br> function propPrefix（str）{ <br> var s =“prop”; <br> return s + str; <br> } <br> var someProp = propPrefix（“Name”）; // someProp现在保存值&#39;propName&#39; <br>的console.log（someObj中[someProp]）; // “约翰” </blockquote>请注意，在使用变量名来访问属性时，我们<em>不会</em>使用引号，因为我们使用的是变量的<em>值</em> ，而不是<em>名称</em> 。 </section>
<section id='description'>
中括号操作符的另一个使用方式是访问赋值给变量的属性。当你需要遍历对象的属性列表或访问查找表（lookup tables）时，这种方式极为有用。
这有一个使用变量来访问属性的例子：
```js
var dogs = {
Fido: "Mutt", Hunter: "Doberman", Snoopie: "Beagle"
};
var myDog = "Hunter";
var myBreed = dogs[myDog];
console.log(myBreed); // "Doberman"
```
使用此概念的另一种方法是在程序执行期间动态收集属性名称，如下所示：
```js
var someObj = {
propName: "John"
};
function propPrefix(str) {
var s = "prop";
return s + str;
}
var someProp = propPrefix("Name"); // someProp now holds the value 'propName'
console.log(someObj[someProp]); // "John"
```
提示：当我们通过变量名访问属性的时候，不需要给变量名包裹引号。因为实际上我们使用的是变量的值，而不是变量的名称。
</section>
## Instructions
<section id="instructions">使用<code>playerNumber</code>变量使用括号表示法在<code>testObj</code>查找玩家<code>16</code> 。然后将该名称分配给<code>player</code>变量。 </section>
<section id='instructions'>
使用变量<code>playerNumber</code>，通过中括号操作符找到<code>testObj</code>中<code>playerNumber</code>为<code>16</code>的值。然后把名字赋给变量<code>player</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>playerNumber</code>应该是一个数字
- text: <code>playerNumber</code>应该是一个数字。
testString: assert(typeof playerNumber === 'number');
- text: 变量<code>player</code>应该是一个字符串
- text: 变量<code>player</code>应该是一个字符串。
testString: assert(typeof player === 'string');
- text: <code>player</code>的价值应该是“蒙大拿”
- text: <code>player</code>点值应该是 "Montana"。
testString: assert(player === 'Montana');
- text: 您应该使用括号表示法来访问<code>testObj</code>
- text: 你应该使用中括号访问<code>testObj</code>。
testString: assert(/testObj\s*?\[.*?\]/.test(code));
- text: 您不应该直接将值<code>Montana</code>分配给变量<code>player</code> 。
- text: 你不应该直接将<code>Montana</code>赋给<code>player</code>。
testString: assert(!code.match(/player\s*=\s*"|\'\s*Montana\s*"|\'\s*;/gi));
- text: 您应该在括号表示法中使用变量<code>playerNumber</code>
- text: 你应该在中括号中使用<code>playerNumber</code>变量。
testString: assert(/testObj\s*?\[\s*playerNumber\s*\]/.test(code));
```
@ -51,7 +82,6 @@ var testObj = {
var playerNumber; // Change this Line
var player = testObj; // Change this Line
```
</div>
@ -61,7 +91,7 @@ var player = testObj; // Change this Line
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof player !== "undefined"){(function(v){return v;})(player);}
```
</div>
@ -71,7 +101,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var testObj = {
12: "Namath",
16: "Montana",
19: "Unitas"
};
var playerNumber = 16;
var player = testObj[playerNumber];
```
</section>

36
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-new-properties-to-a-javascript-object.chinese.md
View File

@ -2,25 +2,35 @@
id: 56bbb991ad1ed5201cd392d2
title: Add New Properties to a JavaScript Object
challengeType: 1
videoUrl: ''
localeTitle: 将新属性添加到JavaScript对象
videoUrl: 'https://scrimba.com/c/cQe38UD'
forumTopicId: 301169
localeTitle: 给对象添加新属性
---
## Description
<section id="description">您可以像修改现有JavaScript对象一样向现有JavaScript对象添加新属性。以下是我们如何为<code>ourDog</code>添加<code>&quot;bark&quot;</code>属性： <code>ourDog.bark = &quot;bow-wow&quot;;</code>或者我们的<code>ourDog[&quot;bark&quot;] = &quot;bow-wow&quot;;</code>现在当我们评估我们的<code>ourDog.bark</code> ，我们会得到他的吠声，“低头哇”。 </section>
<section id='description'>
你也可以像更改属性一样给对象添加属性。
看看我们是如何给<code>ourDog</code>添加<code>"bark"</code>属性：
<code>ourDog.bark = "bow-wow";</code>
或者
<code>ourDog["bark"] = "bow-wow";</code>
现在当我们访问<code>ourDog.bark</code>时会得到 ourDog 的 bark 值 "bow-wow".
</section>
## Instructions
<section id="instructions">向<code>myDog</code>添加<code>&quot;bark&quot;</code>属性并将其设置为狗声，例如“woof”。您可以使用点或括号表示法。 </section>
<section id='instructions'>
给<code>myDog</code>添加一个<code>"bark"</code>属性，设置它的值为狗的声音，例如："woof"。你可以使用点或中括号操作符。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 将属性<code>&quot;bark&quot;</code>添加到<code>myDog</code> 。
- text: 给<code>myDog</code>添加<code>"bark"</code>属性。
testString: assert(myDog.bark !== undefined);
- text: 不要在设置部分添加<code>&quot;bark&quot;</code>
testString: assert(!/bark[^\n]:/.test(code));
- text: 不能在初始化 myDog 的时候添加<code>"bark"</code>属性。
testString: 'assert(!/bark[^\n]:/.test(code));'
```
@ -61,7 +71,7 @@ var myDog = {
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return z;})(myDog);
```
</div>
@ -71,7 +81,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myDog = {
"name": "Happy Coder",
"legs": 4,
"tails": 1,
"friends": ["freeCodeCamp Campers"]
};
myDog.bark = "Woof Woof";
```
</section>

31
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/add-two-numbers-with-javascript.chinese.md
View File

@ -2,24 +2,37 @@
id: cf1111c1c11feddfaeb3bdef
title: Add Two Numbers with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript添加两个数字
videoUrl: 'https://scrimba.com/c/cM2KBAG'
forumTopicId: 16650
localeTitle: 加法运算
---
## Description
<section id="description"> <code>Number</code>是JavaScript中的数据类型，表示数字数据。现在让我们尝试使用JavaScript添加两个数字。当放置在两个数字之间时，JavaScript使用<code>+</code>符号作为加法运算。 <strong>例</strong> <blockquote> myVar = 5 + 10; //分配15 </blockquote></section>
<section id='description'>
<code>Number</code>是 JavaScript 中的一种数据类型，表示数值。
现在让我们来尝试在 JavaScript 中做加法运算。
JavaScript 中使用<code>+</code>号进行加法运算。
<strong>示例</strong>
```js
myVar = 5 + 10; // assigned 15
```
</section>
## Instructions
<section id="instructions">更改<code>0</code>使总和等于<code>20</code> 。 </section>
<section id='instructions'>
改变数字<code>0</code>让变量 sum 的值为<code>20</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>sum</code>应该等于<code>20</code>
- text: <code>sum</code>应该等于<code>20</code>。
testString: assert(sum === 20);
- text: 使用<code>+</code>运算符
- text: 要使用<code>+</code>运算符。
testString: assert(/\+/.test(code));
```
@ -43,7 +56,7 @@ var sum = 10 + 0;
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return 'sum = '+z;})(sum);
```
</div>
@ -53,7 +66,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var sum = 10 + 10;
```
</section>

67
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/adding-a-default-option-in-switch-statements.chinese.md
View File

@ -2,36 +2,58 @@
id: 56533eb9ac21ba0edf2244de
title: Adding a Default Option in Switch Statements
challengeType: 1
videoUrl: ''
localeTitle: 在交换机语句中添加默认选项
videoUrl: 'https://scrimba.com/c/c3JvVfg'
forumTopicId: 16653
localeTitle: 在 Switch 语句中添加默认选项
---
## Description
<section id="description">在<code>switch</code>语句中，您可能无法将所有可能的值指定为<code>case</code>语句。相反，您可以添加<code>default</code>语句，如果找不到匹配的<code>case</code>语句，将执行该语句。可以把它想象成<code>if/else</code>链中的最后一个<code>else</code>语句。 <code>default</code>语句应该是最后一种情况。 <blockquote> switch（num）{ <br>案例值1： <br>语句1; <br>打破; <br>案例值2： <br>语句2; <br>打破; <br> ... <br>默认： <br> defaultStatement; <br>打破; <br> } </blockquote></section>
<section id='description'>
在<code>switch</code>语句中你可能无法用 case 来指定所有情况，这时你可以添加 default 语句。当再也找不到 case 匹配的时候 default 语句会执行，非常类似于 if/else 组合中的 else 语句。
<code>default</code>语句应该是最后一个 case。
```js
switch (num) {
case value1:
statement1;
break;
case value2:
statement2;
break;
...
default:
defaultStatement;
break;
}
```
</section>
## Instructions
<section id="instructions">写一个switch语句来设置以下条件的<code>answer</code> ： <br> <code>&quot;a&quot;</code> - “苹果” <br> <code>&quot;b&quot;</code> - “鸟” <br> <code>&quot;c&quot;</code> - “猫” <br> <code>default</code> - “东西” </section>
<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>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>switchOfStuff(&quot;a&quot;)</code>的值应为“apple”
- text: <code>switchOfStuff("a")</code>应该有一个值为 "apple"。
testString: assert(switchOfStuff("a") === "apple");
- text: <code>switchOfStuff(&quot;b&quot;)</code>的值应为“bird”
- text: <code>switchOfStuff("b")</code>应该有一个值为 "bird"。
testString: assert(switchOfStuff("b") === "bird");
- text: <code>switchOfStuff(&quot;c&quot;)</code>的值应为“cat”
- text: <code>switchOfStuff("c")</code>应该有一个值为 "cat"。
testString: assert(switchOfStuff("c") === "cat");
- text: <code>switchOfStuff(&quot;d&quot;)</code>的值应为“stuff”
- text: <code>switchOfStuff("d")</code>应该有一个值为 "stuff"。
testString: assert(switchOfStuff("d") === "stuff");
- text: <code>switchOfStuff(4)</code>的值应为“stuff”
- text: <code>switchOfStuff(4)</code>应该有一个值为 "stuff"。
testString: assert(switchOfStuff(4) === "stuff");
- text: 您不应该使用任何<code>if</code>或<code>else</code>语句
- text: 不能使用任何<code>if</code>或<code>else</code>表达式。
testString: assert(!/else/g.test(code) || !/if/g.test(code));
- text: 您应该使用<code>default</code>语句
- text: 你应该有一个<code>default</code>表达式。
testString: assert(switchOfStuff("string-to-trigger-default-case") === "stuff");
- text: 你应该至少有3个<code>break</code>语句
- text: 你应该有至少 3 个<code>break</code>表达式。
testString: assert(code.match(/break/g).length > 2);
```
@ -68,7 +90,26 @@ switchOfStuff(1);
## Solution
<section id='solution'>
```js
// solution required
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;
}
```
</section>

40
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/appending-variables-to-strings.chinese.md
View File

@ -2,24 +2,29 @@
id: 56533eb9ac21ba0edf2244ed
title: Appending Variables to Strings
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/cbQmZfa'
forumTopicId: 16656
localeTitle: 将变量附加到字符串
---
## Description
<section id="description">正如我们可以在字符串<dfn>文字中</dfn>构建多行的字符串一样，我们也可以使用加号等于（ <code>+=</code> ）运算符将变量附加到字符串。 </section>
<section id='description'>
我们不仅可以创建出多行的字符串，还可以使用加等号(<code>+=</code>)运算符来将变量追加到字符串。
</section>
## Instructions
<section id="instructions">设置<code>someAdjective</code>并使用<code>+=</code>运算符将其附加到<code>myStr</code> 。 </section>
<section id='instructions'>
设置变量<code>someAdjective</code>的值，并使用<code>+=</code>运算符把它追加到变量<code>myStr</code>上。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>someAdjective</code>应设置为至少3个字符长的字符串
- text: <code>someAdjective</code>应该是一个至少包含三个字符的字符串。
testString: assert(typeof someAdjective !== 'undefined' && someAdjective.length > 2);
- text: 使用<code>+=</code>运算符将<code>someAdjective</code>附加到<code>myStr</code>
- text: 使用<code>+=</code>操作符把<code>someAdjective</code>追加到<code>myStr</code>的后面。
testString: assert(code.match(/myStr\s*\+=\s*someAdjective\s*/).length > 0);
```
@ -51,7 +56,20 @@ var myStr = "Learning to code is ";
<div id='js-teardown'>
```js
console.info('after the test');
(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');
})();
```
</div>
@ -61,7 +79,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var anAdjective = "awesome!";
var ourStr = "freeCodeCamp is ";
ourStr += anAdjective;
var someAdjective = "neat";
var myStr = "Learning to code is ";
myStr += someAdjective;
```
</section>

35
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/assignment-with-a-returned-value.chinese.md
View File

@ -2,25 +2,33 @@
id: 56533eb9ac21ba0edf2244c3
title: Assignment with a Returned Value
challengeType: 1
videoUrl: ''
localeTitle: 具有返回值的分配
videoUrl: 'https://scrimba.com/c/ce2pEtB'
forumTopicId: 16658
localeTitle: 用返回值来赋值
---
## Description
<section id="description">如果您从我们对<a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank">使用赋值运算符存储值</a>的讨论中回忆起来<a href="/learn/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>17</code>并将其分配给<code>ourSum</code>变量。 </section>
<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>
## Instructions
<section id="instructions">使用参数<code>7</code>调用<code>processArg</code>函数，并将其返回值分配给已<code>processed</code>的变量。 </section>
<section id='instructions'>
调用<code>processArg</code>函数并给参数一个值<code>7</code>，然后把返回的值赋值给变量<code>processed</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>processed</code>的值应为<code>2</code>
- 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*\)/.test(code));
- text: 你应该把<code>processArg</code>的返回值赋给<code>processed</code>。
testString: assert(/processed\s*=\s*processArg\(\s*7\s*\)\s*;/.test(code));
```
@ -50,6 +58,7 @@ function processArg(num) {
// Only change code below this line
```
</div>
@ -59,7 +68,7 @@ function processArg(num) {
<div id='js-teardown'>
```js
console.info('after the test');
(function(){return "processed = " + processed})();
```
</div>
@ -69,7 +78,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var processed = 0;
function processArg(num) {
return (num + 3) / 5;
}
processed = processArg(7);
```
</section>

60
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/build-javascript-objects.chinese.md
View File

@ -2,30 +2,60 @@
id: 56bbb991ad1ed5201cd392d0
title: Build JavaScript Objects
challengeType: 1
videoUrl: ''
localeTitle: 构建JavaScript对象
videoUrl: 'https://scrimba.com/c/cWGkbtd'
forumTopicId: 16769
localeTitle: 新建 JavaScript 对象
---
## Description
<section id="description">您之前可能听说过<code>object</code>这个术语。对象类似于<code>arrays</code> ，除了不使用索引访问和修改数据，您可以通过所谓的<code>properties</code>访问对象中的数据。对象对于以结构化方式存储数据很有用，并且可以表示真实世界对象，如猫。这是一个示例cat对象： <blockquote> var cat = { <br> “名字”：“胡须”， <br> “腿”：4， <br> “尾巴”：1， <br> “敌人”：[“水”，“狗”] <br> }; </blockquote>在此示例中，所有属性都存储为字符串，例如 - <code>&quot;name&quot;</code> ， <code>&quot;legs&quot;</code>和<code>&quot;tails&quot;</code> 。但是，您也可以使用数字作为属性。您甚至可以省略单字符串属性的引号，如下所示： <blockquote> var anotherObject = { <br>制作：“福特”， <br> 5：“五”， <br> “模特”：“焦点” <br> }; </blockquote>但是，如果您的对象具有任何非字符串属性，JavaScript将自动将它们作为字符串进行类型转换。 </section>
<section id='description'>
你之前可能听说过对象<code>object</code>。
对象和数组很相似，数组是通过索引来访问和修改数据，而对象是通过属性来访问和修改数据。
对象适合用来存储结构化数据，就和真实世界的对象一模一样，比如一只猫。
这是一个对象的示例：
```js
var cat = {
"name": "Whiskers",
"legs": 4,
"tails": 1,
"enemies": ["Water", "Dogs"]
};
```
在这个示例中所有的属性以字符串的形式储存，例如，<code>"name"</code>、<code>"legs"</code>和<code>"tails"</code>。但是，你也可以使用数字作为属性，你甚至可以省略字符串属性的引号，如下所示：
```js
var anotherObject = {
make: "Ford",
5: "five",
"model": "focus"
};
```
但是，如果你的对象具有任何非字符串属性，JavaScript 将自动将它们转换为字符串类型。
</section>
## Instructions
<section id="instructions">创建一个代表名为<code>myDog</code>的狗的对象，其中包含属性<code>&quot;name&quot;</code> （字符串）， <code>&quot;legs&quot;</code> ， <code>&quot;tails&quot;</code>和<code>&quot;friends&quot;</code> 。您可以将这些对象属性设置为您想要的任何值，因为<code>&quot;name&quot;</code>是一个字符串， <code>&quot;legs&quot;</code>和<code>&quot;tails&quot;</code>是数字， <code>&quot;friends&quot;</code>是一个数组。 </section>
<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>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myDog</code>应该包含属性<code>name</code> ，它应该是一个<code>string</code> 。
- 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> 。
- 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> 。
- 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> 。
- 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>应该只包含所有给定的属性。
- text: <code>myDog</code>应该只包含给出的属性。
testString: assert((function(z){return Object.keys(z).length === 4;})(myDog));
```
@ -54,7 +84,6 @@ var myDog = {
};
```
</div>
@ -64,7 +93,7 @@ var myDog = {
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return z;})(myDog);
```
</div>
@ -74,7 +103,14 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myDog = {
"name": "Camper",
"legs": 4,
"tails": 1,
"friends": ["everything!"]
};
```
</section>

71
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/chaining-if-else-statements.chinese.md
View File

@ -2,46 +2,66 @@
id: 56533eb9ac21ba0edf2244dc
title: Chaining If Else Statements
challengeType: 1
videoUrl: ''
localeTitle: 链接如果其他声明
videoUrl: 'https://scrimba.com/c/caeJgsw'
forumTopicId: 16772
localeTitle: 多个 if else 语句
---
## Description
<section id="description"> <code>if/else</code>语句可以链接在一起以用于复杂的逻辑。这是多个链式<code>if</code> / <code>else if</code>语句的<dfn>伪代码</dfn> ： <blockquote> if（ <em>condition1</em> ）{ <br> <em>语句1</em> <br> } else if（ <em>condition2</em> ）{ <br> <em>语句2</em> <br> } else if（ <em>condition3</em> ）{ <br> <em>声明3</em> <br> 。 。 。 <br> } else { <br> <em>statementN</em> <br> } </blockquote></section>
<section id='description'>
<code>if/else</code>语句串联在一起可以实现复杂的逻辑，这是多个<code>if/else if</code>语句串联在一起的伪代码：
```js
if (condition1) {
statement1
} else if (condition2) {
statement2
} else if (condition3) {
statement3
. . .
} else {
statementN
}
```
</section>
## Instructions
<section id="instructions">写入链接<code>if</code> / <code>else if</code>语句以满足以下条件： <code>num &lt; 5</code> - return“Tiny” <br> <code>num &lt; 10</code> - 返回“Small” <br> <code>num &lt; 15</code> - 返回“中” <br> <code>num &lt; 20</code> - 返回“Large” <br> <code>num &gt;= 20</code> - 返回“巨大” </section>
<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>
## Tests
<section id='tests'>
```yml
tests:
- text: 你应该至少有四个<code>else</code>语句
- text: 你应该有至少 4 个<code>else</code>表达式。
testString: assert(code.match(/else/g).length > 3);
- text: 你应该至少有四个<code>if</code>语句
- text: 你应该有至少 4 个<code>if</code>表达式。
testString: assert(code.match(/if/g).length > 3);
- text: 你应该至少有一个<code>return</code>语句
- text: 你应该有至少 1 个<code>return</code>表达式。
testString: assert(code.match(/return/g).length >= 1);
- text: <code>testSize(0)</code>应该返回“Tiny”
- text: <code>testSize(0)</code>应该返回 "Tiny"。
testString: assert(testSize(0) === "Tiny");
- text: <code>testSize(4)</code>应该返回“Tiny”
- text: <code>testSize(4)</code>应该返回 "Tiny"。
testString: assert(testSize(4) === "Tiny");
- text: <code>testSize(5)</code>应返回“Small”
- text: <code>testSize(5)</code>应该返回 "Small"。
testString: assert(testSize(5) === "Small");
- text: <code>testSize(8)</code>应该返回“Small”
- text: <code>testSize(8)</code>应该返回 "Small"。
testString: assert(testSize(8) === "Small");
- text: <code>testSize(10)</code>应该返回“Medium”
- text: <code>testSize(10)</code>应该返回 "Medium"。
testString: assert(testSize(10) === "Medium");
- text: <code>testSize(14)</code>应返回“Medium”
- text: <code>testSize(14)</code>应该返回 "Medium"。
testString: assert(testSize(14) === "Medium");
- text: <code>testSize(15)</code>应该返回“Large”
- text: <code>testSize(15)</code>应该返回 "Large"。
testString: assert(testSize(15) === "Large");
- text: <code>testSize(17)</code>应该返回“Large”
- text: <code>testSize(17)</code>应该返回 "Large"。
testString: assert(testSize(17) === "Large");
- text: <code>testSize(20)</code>应该返回“巨大”
- text: <code>testSize(20)</code>应该返回 "Huge"。
testString: assert(testSize(20) === "Huge");
- text: <code>testSize(25)</code>应该返回“巨大”
- text: <code>testSize(25)</code>应该返回 "Huge"。
testString: assert(testSize(25) === "Huge");
```
@ -64,7 +84,6 @@ function testSize(num) {
// Change this value to test
testSize(7);
```
</div>
@ -76,7 +95,21 @@ testSize(7);
## Solution
<section id='solution'>
```js
// solution required
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";
}
}
```
</section>

37
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comment-your-javascript-code.chinese.md
View File

@ -2,24 +2,44 @@
id: bd7123c9c441eddfaeb4bdef
title: Comment Your JavaScript Code
challengeType: 1
videoUrl: ''
localeTitle: 评论您的JavaScript代码
videoUrl: 'https://scrimba.com/c/c7ynnTp'
forumTopicId: 16783
localeTitle: 给代码添加注释
---
## Description
<section id="description">注释是JavaScript有意忽略的代码行。注释是一种很好的方式，可以将注释留给自己和其他人，这些人稍后需要弄清楚代码的作用。在JavaScript中编写注释有两种方法：使用<code>//</code>将告诉JavaScript忽略当前行上的其余文本： <blockquote> //这是一个内嵌评论。 </blockquote>您可以使用<code>/*</code>开头并以<code>*/</code>结尾的多行注释： <blockquote> /* 这是一个<br>多行评论* / </blockquote> <strong>最佳实践</strong> <br>在编写代码时，应定期添加注释以阐明代码部分的功能。良好的评论可以帮助传达您的代码的意图 - 包括他人<em>和</em>未来的自我。 </section>
<section id='description'>
被注释的代码块在 JavaScript 之中是不会执行的。在代码中写注释是一个非常好的方式让你自己和其他人理解代码。
JavaScript 中的注释方式有以下两种：
使用<code>//</code>注释掉当前行的代码
```js
// This is an in-line comment.
```
你也可以使用多行注释来注释你的代码，以<code>/*</code>开始，用<code>*/</code>来结束，就像下面这样：
```js
/* This is a
multi-line comment */
```
<strong>最佳实践</strong><br>写代码的时候，要定期添加注释对部分代码块进行解释。适当的注释能让别人和你自己更容易看懂代码。
</section>
## Instructions
<section id="instructions">尝试创建每种评论类型之一。 </section>
<section id='instructions'>
尝试创建这两种类型的注释。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 创建一个包含至少五个字母的<code>//</code>样式注释。
- text: 创建一个<code>//</code>样式的注释, 被注释的文本至少要包含 5 个字符。
testString: assert(code.match(/(\/\/)...../g));
- text: 创建包含至少五个字母的<code>/* */</code>样式注释。
- text: 创建一个<code>/* */</code>样式的注释, 被注释的文本至少要包含 5 个字符。
testString: assert(code.match(/(\/\*)([^\/]{5,})(?=\*\/)/gm));
```
@ -44,7 +64,10 @@ tests:
## Solution
<section id='solution'>
```js
// solution required
// Fake Comment
/* Another Comment */
```
</section>

52
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-equality-operator.chinese.md
View File

@ -2,28 +2,54 @@
id: 56533eb9ac21ba0edf2244d0
title: Comparison with the Equality Operator
challengeType: 1
videoUrl: ''
localeTitle: 与平等算子的比较
videoUrl: 'https://scrimba.com/c/cKyVMAL'
forumTopicId: 16784
localeTitle: 相等运算符
---
## Description
<section id="description">有很多<dfn>比较运算符</dfn>在JavaScript中。所有这些运算符都返回布尔值<code>true</code>或<code>false</code>值。最基本的运算符是等于运算符<code>==</code> 。等于运算符比较两个值，如果它们是等价的则返回<code>true</code>否则返回<code>false</code> 。请注意，相等性与赋值（ <code>=</code> ）不同，后者将运算符右侧的值分配给左侧的变量。 <blockquote> function equalityTest（myVal）{ <br> if（myVal == 10）{ <br>返回“平等”; <br> } <br>返回“不等于”; <br> } </blockquote>如果<code>myVal</code>等于<code>10</code> ，则等于运算符返回<code>true</code> ，因此大括号中的代码将执行，函数将返回<code>&quot;Equal&quot;</code> 。否则，该函数将返回<code>&quot;Not Equal&quot;</code> 。为了使JavaScript能够比较两种不同的<code>data types</code> （例如， <code>numbers</code>和<code>strings</code> ），它必须将一种类型转换为另一种类型。这被称为“类型强制”。但是，一旦它完成，它可以比较如下术语： <blockquote> 1 == 1 //是的<br> 1 == 2 //假<br> 1 ==&#39;1&#39;//是的<br> “3”== 3 //是的</blockquote></section>
<section id='description'>
在 JavaScript 中，有很多<dfn>相互比较的操作</dfn>。所有这些操作符都返回一个<code>true</code>或<code>false</code>值。
最基本的运算符是相等运算符：<code>==</code>。相等运算符比较两个值，如果它们是同等，返回<code>true</code>，如果它们不等，返回<code>false</code>。值得注意的是相等运算符不同于赋值运算符（<code>=</code>），赋值运算符是把等号右边的值赋给左边的变量。
```js
function equalityTest(myVal) {
if (myVal == 10) {
return "Equal";
}
return "Not Equal";
}
```
如果<code>myVal</code>等于<code>10</code>，相等运算符会返回<code>true</code>，因此大括号里面的代码会被执行，函数将返回<code>"Equal"</code>。否则，函数返回<code>"Not Equal"</code>。
在 JavaScript 中，为了让两个不同的<code>数据类型</code>（例如<code>数字</code>和<code>字符串</code>）的值可以作比较，它必须把一种类型转换为另一种类型。然而一旦这样做，它可以像下面这样来比较：
```js
1 == 1 // true
1 == 2 // false
1 == '1' // true
"3" == 3 // true
```
</section>
## Instructions
<section id="instructions">将<code>equality operator</code>添加到指示的行，以便当<code>val</code>等于<code>12</code>时，函数将返回“Equal” </section>
<section id='instructions'>
把<code>相等运算符</code>添加到指定的行，这样当<code>val</code>的值为<code>12</code>的时候，函数会返回"Equal"。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>testEqual(10)</code>应该返回“Not Equal”
- text: <code>testEqual(10)</code>应该返回 "Not Equal"。
testString: assert(testEqual(10) === "Not Equal");
- text: <code>testEqual(12)</code>应返回“Equal”
- text: <code>testEqual(12)</code>应该返回 "Equal"。
testString: assert(testEqual(12) === "Equal");
- text: <code>testEqual(&quot;12&quot;)</code>应返回“Equal”
- text: <code>testEqual("12")</code>应该返回 "Equal"。
testString: assert(testEqual("12") === "Equal");
- text: 您应该使用<code>==</code>运算符
- text: 你应该使用<code>==</code>运算符。
testString: assert(code.match(/==/g) && !code.match(/===/g));
```
@ -46,7 +72,6 @@ function testEqual(val) {
// Change this value to test
testEqual(10);
```
</div>
@ -58,7 +83,14 @@ testEqual(10);
## Solution
<section id='solution'>
```js
// solution required
function testEqual(val) {
if (val == 12) {
return "Equal";
}
return "Not Equal";
}
```
</section>

52
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-operator.chinese.md
View File

@ -2,36 +2,51 @@
id: 56533eb9ac21ba0edf2244d4
title: Comparison with the Greater Than Operator
challengeType: 1
videoUrl: ''
localeTitle: 与大于运营商的比较
videoUrl: 'https://scrimba.com/c/cp6GbH4'
forumTopicId: 16786
localeTitle: 大于运算符
---
## Description
<section id="description">大于运算符（ <code>&gt;</code> ）比较两个数字的值。如果左边的数字大于右边的数字，则返回<code>true</code> 。否则，它返回<code>false</code> 。与等于运算符一样，大于运算符将在比较时转换数据类型的值。 <strong>例子</strong> <blockquote> 5&gt; 3 //是的<br> 7&gt;&#39;3&#39;//是的<br> 2&gt; 3 //假<br> &#39;1&#39;&gt; 9 //假</blockquote></section>
<section id='description'>
使用大于运算符（<code>&gt;</code>）来比较两个数字。如果大于运算符左边的数字大于右边的数字，将会返回<code>true</code>。否则，它返回<code>false</code>。
与相等运算符一样，大于运算符在比较的时候，会转换值的数据类型。
<strong>例如</strong>
```js
5 > 3 // true
7 > '3' // true
2 > 3 // false
'1' > 9 // false
```
</section>
## Instructions
<section id="instructions">将<code>greater than</code>运算符添加到指示的行，以便返回语句有意义。 </section>
<section id='instructions'>
添加<code>大于</code>运算符到指定的行，使得返回的语句是有意义的。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>testGreaterThan(0)</code>应返回“10或Under”
- text: <code>testGreaterThan(0)</code>应该返回 "10 or Under"。
testString: assert(testGreaterThan(0) === "10 or Under");
- text: <code>testGreaterThan(10)</code>应返回“10或Under”
- text: <code>testGreaterThan(10)</code>应该返回 "10 or Under"。
testString: assert(testGreaterThan(10) === "10 or Under");
- text: <code>testGreaterThan(11)</code>应该返回“Over 10”
- text: <code>testGreaterThan(11)</code>应该返回 "Over 10"。
testString: assert(testGreaterThan(11) === "Over 10");
- text: <code>testGreaterThan(99)</code>应该返回“Over 10”
- text: <code>testGreaterThan(99)</code>应该返回 "Over 10"。
testString: assert(testGreaterThan(99) === "Over 10");
- text: <code>testGreaterThan(100)</code>应该返回“Over 10”
- text: <code>testGreaterThan(100)</code>应该返回 "Over 10"。
testString: assert(testGreaterThan(100) === "Over 10");
- text: <code>testGreaterThan(101)</code>应返回“超过100”
- text: <code>testGreaterThan(101)</code>应该返回 "Over 100"。
testString: assert(testGreaterThan(101) === "Over 100");
- text: <code>testGreaterThan(150)</code>应该返回“超过100”
- text: <code>testGreaterThan(150)</code>应该返回 "Over 100"。
testString: assert(testGreaterThan(150) === "Over 100");
- text: 您应该至少使用<code>&gt;</code>运算符两次
- text: 你应该使用<code>&gt;</code>运算符至少两次。
testString: assert(code.match(/val\s*>\s*('|")*\d+('|")*/g).length > 1);
```
@ -58,7 +73,6 @@ function testGreaterThan(val) {
// Change this value to test
testGreaterThan(10);
```
</div>
@ -70,7 +84,17 @@ testGreaterThan(10);
## Solution
<section id='solution'>
```js
// solution required
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";
}
```
</section>

54
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-greater-than-or-equal-to-operator.chinese.md
View File

@ -2,36 +2,51 @@
id: 56533eb9ac21ba0edf2244d5
title: Comparison with the Greater Than Or Equal To Operator
challengeType: 1
videoUrl: ''
localeTitle: 与大于或等于运算符的比较
videoUrl: 'https://scrimba.com/c/c6KBqtV'
forumTopicId: 16785
localeTitle: 大于或等于运算符
---
## Description
<section id="description"> <code>greater than or equal to</code>运算符（ <code>&gt;=</code> ）比较两个数字的值。如果左边的数字大于或等于右边的数字，则返回<code>true</code> 。否则，它返回<code>false</code> 。与等于运算符一样， <code>greater than or equal to</code>运算符将在比较时转换数据类型。 <strong>例子</strong> <blockquote> 6&gt; = 6 //是的<br> 7&gt; =&#39;3&#39;//是的<br> 2&gt; = 3 //假<br> &#39;7&#39;&gt; = 9 //假</blockquote></section>
<section id='description'>
使用<code>大于等于</code>运算符（<code>&gt;=</code>）来比较两个数字的大小。如果大于等于运算符左边的数字比右边的数字大或者相等，它会返回<code>true</code>。否则，它会返回<code>false</code>。
与相等运算符相似，<code>大于等于</code>运算符在比较的时候会转换值的数据类型。
<strong>例如</strong>
```js
6 >= 6 // true
7 >= '3' // true
2 >= 3 // false
'7' >= 9 // false
```
</section>
## Instructions
<section id="instructions">将<code>greater than or equal to</code>运算符添加到指示的行，以便返回语句有意义。 </section>
<section id='instructions'>
添加<code>大于等于</code>运算符到指定行，使得函数的返回语句有意义。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>testGreaterOrEqual(0)</code>应返回“小于10”
- text: <code>testGreaterOrEqual(0)</code>应该返回 "Less than 10"。
testString: assert(testGreaterOrEqual(0) === "Less than 10");
- text: <code>testGreaterOrEqual(9)</code>应返回“小于10”
- text: <code>testGreaterOrEqual(9)</code>应该返回 "Less than 10"。
testString: assert(testGreaterOrEqual(9) === "Less than 10");
- text: <code>testGreaterOrEqual(10)</code>应返回“10或Over”
- text: <code>testGreaterOrEqual(10)</code>应该返回 "10 or Over"。
testString: assert(testGreaterOrEqual(10) === "10 or Over");
- text: <code>testGreaterOrEqual(11)</code>应返回“10或Over”
- text: <code>testGreaterOrEqual(11)</code>应该返回 "10 or Over"。
testString: assert(testGreaterOrEqual(11) === "10 or Over");
- text: <code>testGreaterOrEqual(19)</code>应返回“10或Over”
- text: <code>testGreaterOrEqual(19)</code>应该返回 "10 or Over"。
testString: assert(testGreaterOrEqual(19) === "10 or Over");
- text: <code>testGreaterOrEqual(100)</code>应该返回“20或Over”
- text: <code>testGreaterOrEqual(100)</code>应该返回 "20 or Over"。
testString: assert(testGreaterOrEqual(100) === "20 or Over");
- text: <code>testGreaterOrEqual(21)</code>应返回“20或Over”
- text: <code>testGreaterOrEqual(21)</code>应该返回 "20 or Over"。
testString: assert(testGreaterOrEqual(21) === "20 or Over");
- text: 您应该使用<code>&gt;=</code>运算符至少两次
- text: 你应该使用<code>&gt;=</code>运算符至少两次。
testString: assert(code.match(/val\s*>=\s*('|")*\d+('|")*/g).length > 1);
```
@ -58,7 +73,6 @@ function testGreaterOrEqual(val) {
// Change this value to test
testGreaterOrEqual(10);
```
</div>
@ -70,7 +84,19 @@ testGreaterOrEqual(10);
## Solution
<section id='solution'>
```js
// solution required
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";
}
```
</section>

45
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-inequality-operator.chinese.md
View File

@ -2,32 +2,47 @@
id: 56533eb9ac21ba0edf2244d2
title: Comparison with the Inequality Operator
challengeType: 1
videoUrl: ''
localeTitle: 与不等式算子的比较
videoUrl: 'https://scrimba.com/c/cdBm9Sr'
forumTopicId: 16787
localeTitle: 不等运算符
---
## Description
<section id="description">不等运算符（ <code>!=</code> ）与等于运算符相反。它意味着“不等于”并返回<code>false</code> ，其中相等性将返回<code>true</code> ， <em>反之亦然</em> 。与等式运算符一样，不等式运算符将在比较时转换数据类型的值。 <strong>例子</strong> <blockquote> 1！= 2 //是的<br> 1！=“1”//假<br> 1！=&#39;1&#39;//假<br> 1！= true // false <br> 0！= false // false </blockquote></section>
<section id='description'>
不相等运算符（<code>!=</code>）与相等运算符是相反的。这意味着不相等运算符中，如果“不为真”并且返回<code>false</code>的地方，在相等运算符中会返回<code>true</code>，<em>反之亦然</em>。与相等运算符类似，不相等运算符在比较的时候也会转换值的数据类型。
<strong>例如</strong>
```js
1 != 2 // true
1 != "1" // false
1 != '1' // false
1 != true // false
0 != false // false
```
</section>
## Instructions
<section id="instructions">在<code>if</code>语句中添加不等式运算符<code>!=</code> ，以便当<code>val</code>不等于<code>99</code>时函数将返回“Not Equal” </section>
<section id='instructions'>
在<code>if</code>语句中，添加不相等运算符<code>!=</code>，这样函数在当<code>val</code>不等于 <code>99</code>的时候，会返回 "Not Equal"。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>testNotEqual(99)</code>应返回“Equal”
- text: <code>testNotEqual(99)</code>应该返回 "Equal"。
testString: assert(testNotEqual(99) === "Equal");
- text: <code>testNotEqual(&quot;99&quot;)</code>应该返回“Equal”
- text: <code>testNotEqual("99")</code>应该返回 "Equal"。
testString: assert(testNotEqual("99") === "Equal");
- text: <code>testNotEqual(12)</code>应该返回“Not Equal”
- text: <code>testNotEqual(12)</code>应该返回 "Not Equal"。
testString: assert(testNotEqual(12) === "Not Equal");
- text: <code>testNotEqual(&quot;12&quot;)</code>应该返回“Not Equal”
- text: <code>testNotEqual("12")</code>应该返回 "Not Equal"。
testString: assert(testNotEqual("12") === "Not Equal");
- text: <code>testNotEqual(&quot;bob&quot;)</code>应返回“Not Equal”
- text: <code>testNotEqual("bob")</code>应该返回 "Not Equal"。
testString: assert(testNotEqual("bob") === "Not Equal");
- text: 你应该使用<code>!=</code>运算符
- text: 你应该使用<code>!=</code>运算符。
testString: assert(code.match(/(?!!==)!=/));
```
@ -50,7 +65,6 @@ function testNotEqual(val) {
// Change this value to test
testNotEqual(10);
```
</div>
@ -62,7 +76,14 @@ testNotEqual(10);
## Solution
<section id='solution'>
```js
// solution required
function testNotEqual(val) {
if (val != 99) {
return "Not Equal";
}
return "Equal";
}
```
</section>

52
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-operator.chinese.md
View File

@ -2,34 +2,49 @@
id: 56533eb9ac21ba0edf2244d6
title: Comparison with the Less Than Operator
challengeType: 1
videoUrl: ''
localeTitle: 与小于算子的比较
videoUrl: 'https://scrimba.com/c/cNVRWtB'
forumTopicId: 16789
localeTitle: 小于运算符
---
## Description
<section id="description"> <dfn>小于</dfn>运算符（ <code>&lt;</code> ）比较两个数字的值。如果左边的数字小于右边的数字，则返回<code>true</code> 。否则，它返回<code>false</code> 。与等于运算符一样， <dfn>少于</dfn>运算符在比较时转换数据类型。 <strong>例子</strong> <blockquote> 2 &lt;5 //是的<br> &#39;3&#39;&lt;7 //是的<br> 5 &lt;5 //假<br> 3 &lt;2 //假<br> &#39;8&#39;&lt;4 //假</blockquote></section>
<section id='description'>
使用<dfn>小于</dfn>运算符（<code>&lt;</code>）比较两个数字的大小。如果小于运算符左边的数字比右边的数字小，它会返回<code>true</code>。否则会返回<code>false</code>。与相等运算符类似，<dfn>小于</dfn> 运算符在做比较的时候会转换值的数据类型。
<strong>例如</strong>
```js
2 < 5 // true
'3' < 7 // true
5 < 5 // false
3 < 2 // false
'8' < 4 // false
```
</section>
## Instructions
<section id="instructions">将<code>less than</code>运算符添加到指示的行，以便返回语句有意义。 </section>
<section id='instructions'>
添加<code>小于</code>运算符到指定行，使得函数的返回语句有意义。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>testLessThan(0)</code>应该返回“25岁以下”
- text: <code>testLessThan(0)</code>应该返回 "Under 25"。
testString: assert(testLessThan(0) === "Under 25");
- text: <code>testLessThan(24)</code>应该返回“25岁以下”
- text: <code>testLessThan(24)</code>应该返回 "Under 25"。
testString: assert(testLessThan(24) === "Under 25");
- text: <code>testLessThan(25)</code>应该返回“55岁以下”
- text: <code>testLessThan(25)</code>应该返回 "Under 55"。
testString: assert(testLessThan(25) === "Under 55");
- text: <code>testLessThan(54)</code>应该返回“55岁以下”
- text: <code>testLessThan(54)</code>应该返回 "Under 55"。
testString: assert(testLessThan(54) === "Under 55");
- text: <code>testLessThan(55)</code>应返回“55或以上”
- text: <code>testLessThan(55)</code>应该返回 "55 or Over"。
testString: assert(testLessThan(55) === "55 or Over");
- text: <code>testLessThan(99)</code>应返回“55或以上”
- text: <code>testLessThan(99)</code>应该返回 "55 or Over"。
testString: assert(testLessThan(99) === "55 or Over");
- text: 您应该至少使用<code>&lt;</code>运算符两次
- text: 你应该使用<code>&lt;</code>运算符至少两次。
testString: assert(code.match(/val\s*<\s*('|")*\d+('|")*/g).length > 1);
```
@ -56,7 +71,6 @@ function testLessThan(val) {
// Change this value to test
testLessThan(10);
```
</div>
@ -68,7 +82,19 @@ testLessThan(10);
## Solution
<section id='solution'>
```js
// solution required
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";
}
```
</section>

53
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-less-than-or-equal-to-operator.chinese.md
View File

@ -2,36 +2,51 @@
id: 56533eb9ac21ba0edf2244d7
title: Comparison with the Less Than Or Equal To Operator
challengeType: 1
videoUrl: ''
localeTitle: 与小于或等于运算符的比较
videoUrl: 'https://scrimba.com/c/cNVR7Am'
forumTopicId: 16788
localeTitle: 小于或等于运算符
---
## Description
<section id="description"> <code>less than or equal to</code>运算符（ <code>&lt;=</code> ）比较两个数字的值。如果左边的数字小于或等于右边的数字，则返回<code>true</code> 。如果左侧的数字大于右侧的数字，则返回<code>false</code> 。与等于运算符一样， <code>less than or equal to</code>转换数据类型。 <strong>例子</strong> <blockquote> 4 &lt;= 5 //是的<br> &#39;7&#39;&lt;= 7 //是的<br> 5 &lt;= 5 //是的<br> 3 &lt;= 2 //假<br> &#39;8&#39;&lt;= 4 //假</blockquote></section>
<section id='description'>
使用<code>小于等于</code>运算符（<code>&lt;=</code>）比较两个数字的大小。如果在小于等于运算符左边的数字小于或者等于右边的数字，它会返回<code>true</code>。如果在小于等于运算符左边的数字大于右边的数字，它会返回<code>false</code>。与相等运算符类似，<code>小于等于</code>运算符会转换数据类型。
<strong>例如</strong>
```js
4 <= 5 // true
'7' <= 7 // true
5 <= 5 // true
3 <= 2 // false
'8' <= 4 // false
```
</section>
## Instructions
<section id="instructions">将<code>less than or equal to</code>运算符添加到指示的行，以便返回语句有意义。 </section>
<section id='instructions'>
添加<code>小于等于</code>运算符到指定行，使得函数的返回语句有意义。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>testLessOrEqual(0)</code>应该返回“小于或等于12”
- 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>应返回“小于或等于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>应返回“小于或等于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>应返回“小于或等于24”
- 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>应返回“小于或等于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>应该返回“超过24”
- text: <code>testLessOrEqual(25)</code>应该返回 "More Than 24"。
testString: assert(testLessOrEqual(25) === "More Than 24");
- text: <code>testLessOrEqual(55)</code>应该返回“超过24”
- text: <code>testLessOrEqual(55)</code>应该返回 "More Than 24"。
testString: assert(testLessOrEqual(55) === "More Than 24");
- text: 你应该至少使用<code>&lt;=</code>运算符两次
- text: 你应该使用<code>&lt;=</code>运算符至少两。
testString: assert(code.match(/val\s*<=\s*('|")*\d+('|")*/g).length > 1);
```
@ -70,7 +85,19 @@ testLessOrEqual(10);
## Solution
<section id='solution'>
```js
// solution required
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";
}
```
</section>

40
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-equality-operator.chinese.md
View File

@ -2,28 +2,42 @@
id: 56533eb9ac21ba0edf2244d1
title: Comparison with the Strict Equality Operator
challengeType: 1
videoUrl: ''
localeTitle: 与严格平等算子的比较
videoUrl: 'https://scrimba.com/c/cy87atr'
forumTopicId: 16790
localeTitle: 严格相等运算符
---
## Description
<section id="description">严格相等（ <code>===</code> ）是相等运算符（ <code>==</code> ）的对应物。但是，与尝试将两个值转换为常见类型的等式运算符不同，严格相等运算符不执行类型转换。如果要比较的值具有不同的类型，则认为它们不相等，并且严格相等运算符将返回false。 <strong>例子</strong> <blockquote> 3 === 3 //是的<br> 3 ===&#39;3&#39;//假</blockquote>在第二个示例中， <code>3</code>是<code>Number</code>类型， <code>&#39;3&#39;</code>是<code>String</code>类型。 </section>
<section id='description'>
严格相等运算符（<code>===</code>）是相对相等操作符（<code>==</code>）的另一种比较操作符。与相等操作符不同的是，它会同时比较元素的值和<code>数据类型</code>。
如果比较的值类型不同，那么在严格相等运算符比较下它们是不相等的，会返回 false 。
<strong>示例</strong>
```js
3 === 3 // true
3 === '3' // false
```
<code>3</code>是一个<code>数字</code>类型的，而<code>'3'</code>是一个<code>字符串</code>类型的，所以 3 不全等于 '3'。
</section>
## Instructions
<section id="instructions">在<code>if</code>语句中使用strict equality运算符，因此当<code>val</code>严格等于<code>7</code>时，函数将返回“Equal” </section>
<section id='instructions'>
在<code>if</code>语句值使用严格相等运算符，这样当<code>val</code>严格等于7的时候，函数会返回"Equal"。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>testStrict(10)</code>应返回“Not Equal”
- text: <code>testStrict(10)</code>应该返回 "Not Equal"。
testString: assert(testStrict(10) === "Not Equal");
- text: <code>testStrict(7)</code>应返回“Equal”
- text: <code>testStrict(7)</code>应该返回 "Equal"。
testString: assert(testStrict(7) === "Equal");
- text: <code>testStrict(&quot;7&quot;)</code>应返回“Not Equal”
- text: <code>testStrict("7")</code>应该返回 "Not Equal"。
testString: assert(testStrict("7") === "Not Equal");
- text: 您应该使用<code>===</code>运算符
- text: 你应该使用<code>===</code>运算符。
testString: assert(code.match(/(val\s*===\s*\d+)|(\d+\s*===\s*val)/g).length > 0);
```
@ -46,7 +60,6 @@ function testStrict(val) {
// Change this value to test
testStrict(10);
```
</div>
@ -58,7 +71,14 @@ testStrict(10);
## Solution
<section id='solution'>
```js
// solution required
function testStrict(val) {
if (val === 7) {
return "Equal";
}
return "Not Equal";
}
```
</section>

48
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparison-with-the-strict-inequality-operator.chinese.md
View File

@ -2,30 +2,43 @@
id: 56533eb9ac21ba0edf2244d3
title: Comparison with the Strict Inequality Operator
challengeType: 1
videoUrl: ''
localeTitle: 与严格不等式算子的比较
videoUrl: 'https://scrimba.com/c/cKekkUy'
forumTopicId: 16791
localeTitle: 严格不等运算符
---
## Description
<section id="description">严格不等式运算符（ <code>!==</code> ）与严格相等运算符的逻辑相反。它意味着“严格不等于”并返回<code>false</code> ，其中严格相等将返回<code>true</code> ， <em>反之亦然</em> 。严格的不等式不会转换数据类型。 <strong>例子</strong> <blockquote> 3！== 3 //假<br> 3！==&#39;3&#39;//是的<br> 4！== 3 //是的</blockquote></section>
<section id='description'>
严格不相等运算符（<code>!==</code>）与全等运算符是相反的。这意味着严格不相等并返回<code>false</code>的地方，用严格相等运算符会返回<code>true</code>，<em>反之亦然</em>。严格不相等运算符不会转换值的数据类型。
<strong>示例</strong>
```js
3 !== 3 // false
3 !== '3' // true
4 !== 3 // true
```
</section>
## Instructions
<section id="instructions">将<code>strict inequality operator</code>添加到<code>if</code>语句，以便当<code>val</code>不严格等于<code>17</code>时，函数将返回“Not Equal” </section>
<section id='instructions'>
在<code>if</code>语句中，添加严格不相等运算符<code>!==</code>，这样如果<code>val</code>与<code>17</code>严格不相等的时候，函数会返回 "Not Equal"。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>testStrictNotEqual(17)</code>应返回“Equal”
- text: <code>testStrictNotEqual(17)</code>应该返回 "Equal"。
testString: assert(testStrictNotEqual(17) === "Equal");
- text: <code>testStrictNotEqual(&quot;17&quot;)</code>应返回“Not Equal”
- text: <code>testStrictNotEqual("17")</code>应该返回 "Not Equal"。
testString: assert(testStrictNotEqual("17") === "Not Equal");
- text: <code>testStrictNotEqual(12)</code>应该返回“Not Equal”
- text: <code>testStrictNotEqual(12)</code>应该返回 "Not Equal"。
testString: assert(testStrictNotEqual(12) === "Not Equal");
- text: <code>testStrictNotEqual(&quot;bob&quot;)</code>应返回“Not Equal”
- text: <code>testStrictNotEqual("bob")</code>应该返回 "Not Equal"。
testString: assert(testStrictNotEqual("bob") === "Not Equal");
- text: 你应该使用<code>!==</code>运算符
- text: 应该使用 <code>!==</code> 运算符。
testString: assert(code.match(/(val\s*!==\s*\d+)|(\d+\s*!==\s*val)/g).length > 0);
```
@ -40,12 +53,7 @@ tests:
```js
// Setup
function testStrictNotEqual(val) {
// Only Change Code Below this Line
if (val) {
// Only Change Code Above this Line
if (val) { // Change this line
return "Not Equal";
}
return "Equal";
@ -53,7 +61,6 @@ function testStrictNotEqual(val) {
// Change this value to test
testStrictNotEqual(10);
```
</div>
@ -65,7 +72,14 @@ testStrictNotEqual(10);
## Solution
<section id='solution'>
```js
// solution required
function testStrictNotEqual(val) {
if (val !== 17) {
return "Not Equal";
}
return "Equal";
}
```
</section>

65
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-and-operator.chinese.md
View File

@ -2,40 +2,65 @@
id: 56533eb9ac21ba0edf2244d8
title: Comparisons with the Logical And Operator
challengeType: 1
videoUrl: ''
localeTitle: 与逻辑和运算符的比较
videoUrl: 'https://scrimba.com/c/cvbRVtr'
forumTopicId: 16799
localeTitle: 逻辑与运算符
---
## Description
<section id="description">有时你需要一次测试多个东西。当且仅当其左侧和右侧的<dfn>操作数</dfn>为<code>true</code>时， <dfn>逻辑和</dfn>运算符（ <code>&amp;&amp;</code> ）才返回true。如果将if语句嵌套在另一个语句中，则可以实现相同的效果： <blockquote> if（num&gt; 5）{ <br> if（num &lt;10）{ <br>返回“是”; <br> } <br> } <br>返回“否”; </blockquote>如果<code>num</code>大于<code>5</code>且小于<code>10</code>则仅返回“Yes”。相同的逻辑可以写成： <blockquote> if（num&gt; 5 &amp;&amp; num &lt;10）{ <br>返回“是”; <br> } <br>返回“否”; </blockquote></section>
<section id='description'>
有时你需要在一次判断中做多个操作。当且仅当运算符的左边和右边都是<code>true</code>，<dfn>逻辑与</dfn> 运算符（<code>&&</code>）才会返回<code>true</code>。
同样的效果可以通过 if 语句的嵌套来实现：
```js
if (num > 5) {
if (num < 10) {
return "Yes";
}
}
return "No";
```
只有当<code>num</code>的值在 6 和 9 之间（包括 6 和 9）才会返回 "Yes"。相同的逻辑可被写为：
```js
if (num > 5 && num < 10) {
return "Yes";
}
return "No";
```
</section>
## Instructions
<section id="instructions">将两个if语句合并为一个语句，如果<code>val</code>小于或等于<code>50</code>且大于或等于<code>25</code> ，则返回<code>&quot;Yes&quot;</code> 。否则，将返回<code>&quot;No&quot;</code> 。 </section>
<section id='instructions'>
请使用逻辑与运算符把两个 if 语句合并为一个 if 语句，如果<code>val</code>小于或等于<code>50</code>并且大于或等于<code>25</code>，返回<code>"Yes"</code>。否则，将返回<code>"No"</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 你应该使用一次<code>&amp;&amp;</code>运算符
testString: assert(code.match(/&&/g).length === 1);
- text: 你应该只有一个<code>if</code>语句
- 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>应返回“否”
- text: <code>testLogicalAnd(0)</code>应该返回 "No"。
testString: assert(testLogicalAnd(0) === "No");
- text: <code>testLogicalAnd(24)</code>应返回“否”
- text: <code>testLogicalAnd(24)</code>应该返回 "No"。
testString: assert(testLogicalAnd(24) === "No");
- text: <code>testLogicalAnd(25)</code>应返回“是”
- text: <code>testLogicalAnd(25)</code>应该返回 "Yes"。
testString: assert(testLogicalAnd(25) === "Yes");
- text: <code>testLogicalAnd(30)</code>应该返回“是”
- text: <code>testLogicalAnd(30)</code>应该返回 "Yes"。
testString: assert(testLogicalAnd(30) === "Yes");
- text: <code>testLogicalAnd(50)</code>应该返回“是”
- text: <code>testLogicalAnd(50)</code>应该返回 "Yes"。
testString: assert(testLogicalAnd(50) === "Yes");
- text: <code>testLogicalAnd(51)</code>应返回“否”
- text: <code>testLogicalAnd(51)</code>应该返回 "No"。
testString: assert(testLogicalAnd(51) === "No");
- text: <code>testLogicalAnd(75)</code>应返回“否”
- text: <code>testLogicalAnd(75)</code>应该返回 "No"。
testString: assert(testLogicalAnd(75) === "No");
- text: <code>testLogicalAnd(80)</code>应返回“否”
- text: <code>testLogicalAnd(80)</code>应该返回 "No"。
testString: assert(testLogicalAnd(80) === "No");
```
@ -63,7 +88,6 @@ function testLogicalAnd(val) {
// Change this value to test
testLogicalAnd(10);
```
</div>
@ -75,7 +99,14 @@ testLogicalAnd(10);
## Solution
<section id='solution'>
```js
// solution required
function testLogicalAnd(val) {
if (val >= 25 && val <= 50) {
return "Yes";
}
return "No";
}
```
</section>

65
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/comparisons-with-the-logical-or-operator.chinese.md
View File

@ -2,40 +2,67 @@
id: 56533eb9ac21ba0edf2244d9
title: Comparisons with the Logical Or Operator
challengeType: 1
videoUrl: ''
localeTitle: 与逻辑或运算符的比较
videoUrl: 'https://scrimba.com/c/cEPrGTN'
forumTopicId: 16800
localeTitle: 逻辑或运算符
---
## Description
<section id="description"> <dfn>逻辑OR</dfn>运算符（ <code>||</code> ）返回<code>true</code> ，如果任一<dfn>操作数</dfn>为<code>true</code> 。否则，它返回<code>false</code> 。 <dfn>逻辑或</dfn>运算符由两个管道符号（ <code>|</code> ）组成。这通常可以在Backspace和Enter键之间找到。以下模式应该从以前的方法点看起来很熟悉： <blockquote> if（num&gt; 10）{ <br>返回“否”; <br> } <br> if（num &lt;5）{ <br>返回“否”; <br> } <br>返回“是”; </blockquote>仅当<code>num</code>介于<code>5</code>和<code>10</code>之间（包括5和10）时，才会返回“Yes”。相同的逻辑可以写成： <blockquote> if（num&gt; 10 || num &lt;5）{ <br>返回“否”; <br> } <br>返回“是”; </blockquote></section>
<section id='description'>
只要<dfn>逻辑或</dfn>运算符<code>||</code>两边任何一个为<code>true</code>，那么它就返回<code>true</code>；否则返回<code>false</code>。
<dfn>逻辑或</dfn>运算符由两个管道符号（|）组成。这个按键位于退格键和回车键之间。
下面这样的语句你应该很熟悉：
```js
if (num > 10) {
return "No";
}
if (num < 5) {
return "No";
}
return "Yes";
```
只有当<code>num</code>大于等于 5 或小于等于 10 时，函数返回"Yes"。相同的逻辑可以简写成：
```js
if (num > 10 || num < 5) {
return "No";
}
return "Yes";
```
</section>
## Instructions
<section id="instructions">将两个<code>if</code>语句组合成一个语句，如果<code>val</code>不在<code>10</code>和<code>20</code>之间（包括<code>10</code>和<code>20</code> ，则返回<code>&quot;Outside&quot;</code> 。否则，返回<code>&quot;Inside&quot;</code> 。 </section>
<section id='instructions'>
请使用逻辑或运算符把两个 if 语句合并为一个 if 语句，如果<code>val</code>不在 10 和 20 之间(包括 10 和 20)，返回<code>"Outside"</code>。反之，返回<code>"Inside"</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 你应该使用<code>||</code>操作员一次
- text: 你应该使用一次<code>||</code>操作符。
testString: assert(code.match(/\|\|/g).length === 1);
- text: 你应该只有一个<code>if</code>语句
- text: 你应该只有一个<code>if</code>表达式。
testString: assert(code.match(/if/g).length === 1);
- text: <code>testLogicalOr(0)</code>应返回“Outside”
- text: <code>testLogicalOr(0)</code>应该返回 "Outside"。
testString: assert(testLogicalOr(0) === "Outside");
- text: <code>testLogicalOr(9)</code>应返回“Outside”
- text: <code>testLogicalOr(9)</code>应该返回 "Outside"。
testString: assert(testLogicalOr(9) === "Outside");
- text: <code>testLogicalOr(10)</code>应返回“Inside”
- text: <code>testLogicalOr(10)</code>应该返回 "Inside"。
testString: assert(testLogicalOr(10) === "Inside");
- text: <code>testLogicalOr(15)</code>应返回“Inside”
- text: <code>testLogicalOr(15)</code>应该返回 "Inside"。
testString: assert(testLogicalOr(15) === "Inside");
- text: <code>testLogicalOr(19)</code>应该返回“Inside”
- text: <code>testLogicalOr(19)</code>应该返回 "Inside"。
testString: assert(testLogicalOr(19) === "Inside");
- text: <code>testLogicalOr(20)</code>应该返回“Inside”
- text: <code>testLogicalOr(20)</code>应该返回 "Inside"。
testString: assert(testLogicalOr(20) === "Inside");
- text: <code>testLogicalOr(21)</code>应该返回“Outside”
- text: <code>testLogicalOr(21)</code>应该返回 "Outside"。
testString: assert(testLogicalOr(21) === "Outside");
- text: <code>testLogicalOr(25)</code>应返回“Outside”
- text: <code>testLogicalOr(25)</code>应该返回 "Outside"。
testString: assert(testLogicalOr(25) === "Outside");
```
@ -65,7 +92,6 @@ function testLogicalOr(val) {
// Change this value to test
testLogicalOr(15);
```
</div>
@ -77,7 +103,14 @@ testLogicalOr(15);
## Solution
<section id='solution'>
```js
// solution required
function testLogicalOr(val) {
if (val < 10 || val > 20) {
return "Outside";
}
return "Inside";
}
```
</section>

45
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-addition.chinese.md
View File

@ -2,30 +2,45 @@
id: 56533eb9ac21ba0edf2244af
title: Compound Assignment With Augmented Addition
challengeType: 1
videoUrl: ''
localeTitle: 具有增强加法的复合赋值
videoUrl: 'https://scrimba.com/c/cDR6LCb'
forumTopicId: 16661
localeTitle: 复合赋值之 +=
---
## Description
<section id="description">在编程中，通常使用赋值来修改变量的内容。请记住，首先评估等号右侧的所有内容，因此我们可以说： <code>myVar = myVar + 5;</code>添加<code>5</code>到<code>myVar</code> 。由于这是一种常见的模式，因此存在一步完成数学运算和赋值的运算符。一个这样的运算符是<code>+=</code>运算符。 <blockquote> var myVar = 1; <br> myVar + = 5; <br>的console.log（myVar的）; //返回6 </blockquote></section>
<section id='description'>
在编程当中，通常通过赋值来修改变量的内容。记住，赋值时 Javascript 会先计算<code>=</code>右边的内容，所以我们可以写这样的语句：
<code>myVar = myVar + 5;</code>
以上是最常见的运算赋值语句，即先运算、再赋值。还有一类操作符是一步到位既做运算也赋值的。
其中一种就是<code>+=</code>运算符。
```js
var myVar = 1;
myVar += 5;
console.log(myVar); // Returns 6
```
</section>
## Instructions
<section id="instructions">转换<code>a</code> ， <code>b</code>和<code>c</code>的赋值以使用<code>+=</code>运算符。 </section>
<section id='instructions'>
使用<code>+=</code>操作符实现同样的效果。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>a</code>应该等于<code>15</code>
- text: <code>a</code>应该等于<code>15</code>。
testString: assert(a === 15);
- text: <code>b</code>应该等于<code>26</code>
- text: <code>b</code>应该等于<code>26</code>。
testString: assert(b === 26);
- text: <code>c</code>应该等于<code>19</code>
- text: <code>c</code>应该等于<code>19</code>。
testString: assert(c === 19);
- text: 您应该为每个变量使用<code>+=</code>运算符
- text: 你应该对每个变量使用<code>+=</code>操作符。
testString: assert(code.match(/\+=/g).length === 3);
- text: 不要修改行上方的代码
- text: 不要修改注释上面的代码。
testString: assert(/var a = 3;/.test(code) && /var b = 17;/.test(code) && /var c = 12;/.test(code));
```
@ -57,7 +72,7 @@ c = c + 7;
<div id='js-teardown'>
```js
console.info('after the test');
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
```
</div>
@ -67,7 +82,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var a = 3;
var b = 17;
var c = 12;
a += 12;
b += 9;
c += 7;
```
</section>

38
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-division.chinese.md
View File

@ -2,30 +2,38 @@
id: 56533eb9ac21ba0edf2244b2
title: Compound Assignment With Augmented Division
challengeType: 1
videoUrl: ''
localeTitle: 具有增广划分的复合赋值
videoUrl: 'https://scrimba.com/c/c2QvKT2'
forumTopicId: 16659
localeTitle: 复合赋值之 /=
---
## Description
<section id="description"> <code>/=</code>运算符将变量除以另一个数字。 <code>myVar = myVar / 5;</code>将<code>myVar</code>除以<code>5</code> 。这可以改写为： <code>myVar /= 5;</code> </section>
<section id='description'>
<code>/=</code>操作符是让变量与另一个数相除并赋值。
<code>myVar = myVar / 5;</code>
变量<code>myVar</code>等于自身除以<code>5</code>的值。等价于:
<code>myVar /= 5;</code>
</section>
## Instructions
<section id="instructions">转换<code>a</code> ， <code>b</code>和<code>c</code>的赋值以使用<code>/=</code>运算符。 </section>
<section id='instructions'>
使用<code>/=</code>操作符实现同样的效果。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>a</code>应该等于<code>4</code>
- text: <code>a</code>应该等于<code>4</code>。
testString: assert(a === 4);
- text: <code>b</code>应该等于<code>27</code>
- text: <code>b</code>应该等于<code>27</code>。
testString: assert(b === 27);
- text: <code>c</code>应该等于<code>3</code>
- text: <code>c</code>应该等于<code>3</code>。
testString: assert(c === 3);
- text: 您应该为每个变量使用<code>/=</code>运算符
- text: 应该对每个变量使用<code>/=</code>操作符。
testString: assert(code.match(/\/=/g).length === 3);
- text: 不要修改行上方的代码
- text: 不要修改注释上面的代码。
testString: assert(/var a = 48;/.test(code) && /var b = 108;/.test(code) && /var c = 33;/.test(code));
```
@ -57,7 +65,7 @@ c = c / 11;
<div id='js-teardown'>
```js
console.info('after the test');
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
```
</div>
@ -67,7 +75,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var a = 48;
var b = 108;
var c = 33;
a /= 12;
b /= 4;
c /= 11;
```
</section>

39
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-multiplication.chinese.md
View File

@ -2,30 +2,38 @@
id: 56533eb9ac21ba0edf2244b1
title: Compound Assignment With Augmented Multiplication
challengeType: 1
videoUrl: ''
localeTitle: 具有增广乘法的复合赋值
videoUrl: 'https://scrimba.com/c/c83vrfa'
forumTopicId: 16662
localeTitle: 复合赋值之 *=
---
## Description
<section id="description"> <code>*=</code>运算符将变量乘以数字。 <code>myVar = myVar * 5;</code>将<code>myVar</code>乘以<code>5</code> 。这可以改写为： <code>myVar *= 5;</code> </section>
<section id='description'>
<code>*=</code>操作符是让变量与一个数相乘并赋值。
<code>myVar = myVar * 5;</code>
变量<code>myVar</code>等于自身与数值<code>5</code>相乘的值。也可以写作这样的形式:
<code>myVar *= 5;</code>
</section>
## Instructions
<section id="instructions">转换<code>a</code> ， <code>b</code>和<code>c</code>的赋值以使用<code>*=</code>运算符。 </section>
<section id='instructions'>
使用<code>*=</code>操作符实现同样的效果。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>a</code>应该等于<code>25</code>
- text: <code>a</code>应该等于<code>25</code>。
testString: assert(a === 25);
- text: <code>b</code>应该等于<code>36</code>
- text: <code>b</code>应该等于<code>36</code>。
testString: assert(b === 36);
- text: <code>c</code>应该等于<code>46</code>
- text: <code>c</code>应该等于<code>46</code>。
testString: assert(c === 46);
- text: 您应该为每个变量使用<code>*=</code>运算符
- text: 应该对每个变量使用<code>*=</code>操作符。
testString: assert(code.match(/\*=/g).length === 3);
- text: 不要修改行上方的代码
- text: 不要修改注释上面的代码。
testString: assert(/var a = 5;/.test(code) && /var b = 12;/.test(code) && /var c = 4\.6;/.test(code));
```
@ -48,6 +56,7 @@ a = a * 5;
b = 3 * b;
c = c * 10;
```
</div>
@ -57,7 +66,7 @@ c = c * 10;
<div id='js-teardown'>
```js
console.info('after the test');
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
```
</div>
@ -67,7 +76,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var a = 5;
var b = 12;
var c = 4.6;
a *= 5;
b *= 3;
c *= 10;
```
</section>

41
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/compound-assignment-with-augmented-subtraction.chinese.md
View File

@ -2,30 +2,38 @@
id: 56533eb9ac21ba0edf2244b0
title: Compound Assignment With Augmented Subtraction
challengeType: 1
videoUrl: ''
localeTitle: 具有增广减法的复合赋值
videoUrl: 'https://scrimba.com/c/c2Qv7AV'
forumTopicId: 16660
localeTitle: 复合赋值之 -=
---
## Description
<section id="description">与<code>+=</code>运算符一样， <code>-=</code>从变量中减去一个数字。 <code>myVar = myVar - 5;</code>将从<code>myVar</code>减去<code>5</code> 。这可以改写为： <code>myVar -= 5;</code> </section>
<section id='description'>
与<code>+=</code>操作符类似，<code>-=</code>操作符用来对一个变量进行减法赋值操作。
<code>myVar = myVar - 5;</code>
变量<code>myVar</code>等于自身减去<code>5</code>的值。也可以写成这种形式：
<code>myVar -= 5;</code>
</section>
## Instructions
<section id="instructions">转换<code>a</code> ， <code>b</code>和<code>c</code>的赋值以使用<code>-=</code>运算符。 </section>
<section id='instructions'>
使用<code>-=</code>操作符实现同样的效果。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>a</code>应该等于<code>5</code>
- text: <code>a</code>应该等于<code>5</code>。
testString: assert(a === 5);
- text: <code>b</code>应该等于<code>-6</code>
- text: <code>b</code>应该等于<code>-6</code>。
testString: assert(b === -6);
- text: <code>c</code>应该等于<code>2</code>
- text: <code>c</code>应该等于<code>2</code>。
testString: assert(c === 2);
- text: 您应该为每个变量使用<code>-=</code>运算符
- text: 应该对每个变量使用<code>-=</code>操作符。
testString: assert(code.match(/-=/g).length === 3);
- text: 不要修改行上方的代码
- text: 不要修改注释上面的代码。
testString: assert(/var a = 11;/.test(code) && /var b = 9;/.test(code) && /var c = 3;/.test(code));
```
@ -48,6 +56,7 @@ a = a - 6;
b = b - 15;
c = c - 1;
```
</div>
@ -57,7 +66,7 @@ c = c - 1;
<div id='js-teardown'>
```js
console.info('after the test');
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = " + c; })(a,b,c);
```
</div>
@ -67,7 +76,17 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var a = 11;
var b = 9;
var c = 3;
a -= 6;
b -= 15;
c -= 1;
```
</section>

42
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-plus-operator.chinese.md
View File

@ -2,28 +2,40 @@
id: 56533eb9ac21ba0edf2244b7
title: Concatenating Strings with Plus Operator
challengeType: 1
videoUrl: ''
localeTitle: 用Plus运算符连接字符串
videoUrl: 'https://scrimba.com/c/cNpM8AN'
forumTopicId: 16802
localeTitle: 用加号运算符连接字符串
---
## Description
<section id="description">在JavaScript中，当<code>+</code>运算符与<code>String</code>值一起使用时，它被称为<dfn>连接</dfn>运算符。您可以通过<dfn>将</dfn>它们<dfn>连接</dfn>在一起来构建其他字符串中的新字符串。 <strong>例</strong> <blockquote> “我叫艾伦，&#39;+&#39;我连接起来。” </blockquote> <strong>注意</strong> <br>留意空间。连接不会在连接字符串之间添加空格，因此您需要自己添加它们。 </section>
<section id='description'>
在 JavaScript 中，当对一个<code>String</code>类型的值使用<code>+</code>操作符的时候，它被称作 <dfn>拼接操作符</dfn>。你可以通过<dfn>拼接</dfn>其他字符串来创建一个新的字符串。
<strong>示例</strong>
```js
'My name is Alan,' + ' I concatenate.'
```
<strong>提示</strong><br>注意空格。拼接操作不会在两个字符串之间添加空格，所以想加上空格的话，你需要自己在字符串里面添加。
</section>
## Instructions
<section id="instructions">从字符串构建<code>myStr</code> <code>&quot;This is the start. &quot;</code>和<code>&quot;This is the end.&quot;</code>使用<code>+</code>运算符。 </section>
<section id='instructions'>
使用<code>+</code>操作符，把字符串<code>"This is the start. "</code>和<code>"This is the end."</code>连接起来并赋值给变量<code>myStr</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myStr</code>应该有一个值<code>This is the start. This is the end.</code>
- 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>
- text: 使用<code>+</code>操作符构建<code>myStr</code>。
testString: assert(code.match(/(["']).*(["'])\s*\+\s*(["']).*(["'])/g).length > 1);
- text: 应使用<code>var</code>关键字创建<code>myStr</code> 。
- text: <code>myStr</code>应该被<code>var</code>关键字声明。
testString: assert(/var\s+myStr/.test(code));
- text: 确保将结果分配给<code>myStr</code>变量。
- text: 确保有给<code>myStr</code>赋值。
testString: assert(/myStr\s*=/.test(code));
```
@ -43,6 +55,7 @@ var ourStr = "I come first. " + "I come second.";
var myStr;
```
</div>
@ -52,7 +65,13 @@ var myStr;
<div id='js-teardown'>
```js
console.info('after the test');
(function(){
if(typeof myStr === 'string') {
return 'myStr = "' + myStr + '"';
} else {
return 'myStr is not a string';
}
})();
```
</div>
@ -62,7 +81,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var ourStr = "I come first. " + "I come second.";
var myStr = "This is the start. " + "This is the end.";
```
</section>

35
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/concatenating-strings-with-the-plus-equals-operator.chinese.md
View File

@ -2,24 +2,30 @@
id: 56533eb9ac21ba0edf2244b8
title: Concatenating Strings with the Plus Equals Operator
challengeType: 1
videoUrl: ''
localeTitle: 使用Plus Equals运算符连接字符串
videoUrl: 'https://scrimba.com/c/cbQmmC4'
forumTopicId: 16803
localeTitle: 用 += 运算符连接字符串
---
## Description
<section id="description">我们还可以使用<code>+=</code>运算符将字符串<dfn>连接</dfn>到现有字符串变量的末尾。这对于在多行上打破长字符串非常有帮助。 <strong>注意</strong> <br>留意空间。连接不会在连接字符串之间添加空格，因此您需要自己添加它们。 </section>
<section id='description'>
我们还可以使用<code>+=</code>运算符来<dfn>concatenate</dfn>（拼接）字符串到现有字符串的结尾。对于那些被分割成几段的长的字符串来说，这一操作是非常有用的。
<strong>提示</strong><br>注意空格。拼接操作不会在两个字符串之间添加空格，所以如果想要加上空格的话，你需要自己在字符串里面添加。
</section>
## Instructions
<section id="instructions">通过连接这两个字符串来构建<code>myStr</code>几行： <code>&quot;This is the first sentence. &quot;</code>和<code>&quot;This is the second sentence.&quot;</code>使用<code>+=</code>运算符。使用<code>+=</code>运算符，类似于它在编辑器中的显示方式。首先将第一个字符串分配给<code>myStr</code> ，然后添加第二个字符串。 </section>
<section id='instructions'>
通过使用<code>+=</code>操作符来连接这两个字符串：<br><code>"This is the first sentence. "</code>和<code>"This is the second sentence."</code>并赋给变量<code>myStr</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myStr</code>应该有一个值<code>This is the first sentence. This is the second sentence.</code>
- 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>
- text: 使用<code>+=</code>操作符创建<code>myStr</code>变量。
testString: assert(code.match(/\w\s*\+=\s*["']/g).length > 1 && code.match(/\w\s*\=\s*["']/g).length > 1);
```
@ -40,6 +46,7 @@ ourStr += "I come second.";
var myStr;
```
</div>
@ -49,7 +56,13 @@ var myStr;
<div id='js-teardown'>
```js
console.info('after the test');
(function(){
if(typeof myStr === 'string') {
return 'myStr = "' + myStr + '"';
} else {
return 'myStr is not a string';
}
})();
```
</div>
@ -59,7 +72,13 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var ourStr = "I come first. ";
ourStr += "I come second.";
var myStr = "This is the first sentence. ";
myStr += "This is the second sentence.";
```
</section>

36
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/constructing-strings-with-variables.chinese.md
View File

@ -2,24 +2,29 @@
id: 56533eb9ac21ba0edf2244b9
title: Constructing Strings with Variables
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/cqk8rf4'
forumTopicId: 16805
localeTitle: 用变量构造字符串
---
## Description
<section id="description">有时您需要构建一个字符串， <a href="https://en.wikipedia.org/wiki/Mad_Libs" target="_blank">Mad Libs</a>样式。通过使用连接运算符（ <code>+</code> ），您可以将一个或多个变量插入到正在构建的字符串中。 </section>
<section id='description'>
有时候你需要创建一个类似<a href="https://en.wikipedia.org/wiki/Mad_Libs" target="_blank">Mad Libs</a>(填词游戏）风格的字符串。通过使用连接运算符<code> + </code>，你可以插入一个或多个变量来组成一个字符串。
</section>
## Instructions
<section id="instructions">将<code>myName</code>设置为等于您的名字的字符串，并在字符串<code>&quot;My name is &quot;</code>和<code>&quot; and I am well!&quot;</code>之间用<code>myName</code>构建<code>myStr</code> <code>&quot; and I am well!&quot;</code> </section>
<section id='instructions'>
把你的名字赋值给变量<code>myName</code>，然后把变量<code>myName</code>插入到字符串<code>"My name is "</code>和<code>" and I am well!"</code>之间，并把连接后的结果赋值给变量<code>myStr</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myName</code>应设置为至少3个字符长的字符串
- text: <code>myName</code>至少要包含三个字符。
testString: assert(typeof myName !== 'undefined' && myName.length > 2);
- text: 使用两个<code>+</code>运算符在其中构建<code>myStr</code> with <code>myName</code>
- text: 使用两个<code>+</code>操作符创建包含<code>myName</code>的<code>myStr</code>变量。
testString: assert(code.match(/["']\s*\+\s*myName\s*\+\s*["']/g).length > 0);
```
@ -40,6 +45,7 @@ var ourStr = "Hello, our name is " + ourName + ", how are you?";
var myName;
var myStr;
```
</div>
@ -49,7 +55,20 @@ var myStr;
<div id='js-teardown'>
```js
console.info('after the test');
(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');
})();
```
</div>
@ -59,7 +78,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myName = "Bob";
var myStr = "My name is " + myName + " and I am well!";
```
</section>

45
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/count-backwards-with-a-for-loop.chinese.md
View File

@ -2,26 +2,43 @@
id: 56105e7b514f539506016a5e
title: Count Backwards With a For Loop
challengeType: 1
videoUrl: ''
localeTitle: 用For循环向后计数
videoUrl: 'https://scrimba.com/c/c2R6BHa'
forumTopicId: 16808
localeTitle: 使用 For 循环反向遍历数组
---
## Description
<section id="description">只要我们可以定义正确的条件，for循环也可以向后计数。为了向后计数两次，我们需要更改<code>initialization</code> ， <code>condition</code>和<code>final-expression</code> 。我们将从<code>i = 10</code>开始并在<code>i &gt; 0</code>循环。我们将递减<code>i</code> 2每个回路与<code>i -= 2</code> 。 <blockquote> var ourArray = []; <br> for（var i = 10; i&gt; 0; i- = 2）{ <br> ourArray.push（ⅰ）; <br> } </blockquote> <code>ourArray</code>现在包含<code>[10,8,6,4,2]</code> 。让我们改变<code>initialization</code>和<code>final-expression</code>这样我们就可以向后计数两位奇数。 </section>
<section id='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。
```js
var ourArray = [];
for (var i=10; i > 0; i-=2) {
ourArray.push(i);
}
```
循环结束后，<code>ourArray</code>的值为<code>[10,8,6,4,2]</code>。
让我们改变<code>初始化</code>和<code>计数器</code>，这样我们就可以按照奇数从后往前两两倒着数。
</section>
## Instructions
<section id="instructions">使用<code>for</code>循环将奇数从9到1推送到<code>myArray</code> 。 </section>
<section id='instructions'>
使用一个<code>for</code>循环，把 9 到 1 的奇数添加进<code>myArray</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 你应该为此使用<code>for</code>循环。
- text: 你应该使用<code>for</code>循环。
testString: assert(code.match(/for\s*\(/g).length > 1);
- text: 你应该使用数组方法<code>push</code> 。
- text: 你应该使用数组方法<code>push</code>。
testString: assert(code.match(/myArray.push/));
- text: '<code>myArray</code>应该等于<code>[9,7,5,3,1]</code> 。'
- text: <code>myArray</code>应该等于<code>[9,7,5,3,1]</code>。
testString: assert.deepEqual(myArray, [9,7,5,3,1]);
```
@ -46,6 +63,7 @@ var myArray = [];
// Only change code below this line.
```
</div>
@ -55,7 +73,7 @@ var myArray = [];
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
```
</div>
@ -65,7 +83,16 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
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);
}
```
</section>

60
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/counting-cards.chinese.md
View File

@ -2,15 +2,26 @@
id: 565bbe00e9cc8ac0725390f4
title: Counting Cards
challengeType: 1
videoUrl: ''
localeTitle: 计数卡
videoUrl: 'https://scrimba.com/c/c6KE7ty'
forumTopicId: 16809
localeTitle: 21点游戏
---
## Description
<section id="description">在赌场游戏Blackjack中，玩家可以通过跟踪牌组中剩余的高牌和低牌的相对数量来获得优势。这称为<a href="https://en.wikipedia.org/wiki/Card_counting" target="_blank">卡计数</a> 。在牌组中剩下更多高牌有利于玩家。根据下表为每张卡分配一个值。当计数为正数时，玩家应该下注。当计数为零或负数时，玩家应该下注低。 <table class="table table-striped"><thead><tr><th>计数变化</th><th>牌</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，&#39;J&#39;，&#39;Q&#39;，&#39;K&#39;，&#39;A&#39; </td></tr></tbody></table>你会写一个卡计数功能。它将接收一个<code>card</code>参数，可以是数字或字符串，并根据卡的值递增或递减全局<code>count</code>变量（参见表格）。然后，该函数将返回一个包含当前计数的字符串，如果计数为正则返回字符串<code>Bet</code> ，如果计数为零或为负，则返回<code>Hold</code> 。当前计数和玩家的决定（ <code>Bet</code>或<code>Hold</code> ）应该由一个空格分隔。 <strong>示例输出</strong> <br> <code>-3 Hold</code> <br> <code>5 Bet</code> <strong>提示</strong> <br>当值为7,8或9时，请勿将<code>count</code>重置为0。 <br>不要返回数组。 <br>不要在输出中包含引号（单引号或双引号）。 </section>
<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>应该用空格分开。
<strong>例如：</strong><br><code>-3 Hold<br>5 Bet</code>
<strong>提示</strong><br>既然 card 的值为 7、8、9 时，count 值不变，那我们就可以忽略这种情况。
</section>
## Instructions
<section id="instructions">
<section id='instructions'>
</section>
## Tests
@ -18,19 +29,19 @@ localeTitle: 计数卡
```yml
tests:
- text: 牌序列<code>5 Bet</code>应该返回<code>5 Bet</code>
- 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: '卡片序列7,8,9应返回<code>0 Hold</code>'
- 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: 卡序列10，J，Q，K，A应返回<code>-5 Hold</code>
- 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: '卡序列3,7，Q，8，A应返回<code>-1 Hold</code>'
- 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: 牌序列2，J， <code>1 Bet</code>应该返回<code>1 Bet</code>
- 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: 牌序列<code>1 Bet</code>应该返回<code>1 Bet</code>
- 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: '卡序列3,2，A，10，K应返回<code>-1 Hold</code>'
- 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; })());
```
@ -56,7 +67,6 @@ function cc(card) {
// Add/remove calls to test your function.
// Note: Only the last will display
cc(2); cc(3); cc(7); cc('K'); cc('A');
```
</div>
@ -68,7 +78,31 @@ cc(2); cc(3); cc(7); cc('K'); cc('A');
## Solution
<section id='solution'>
```js
// solution required
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";
}
}
```
</section>

25
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/create-decimal-numbers-with-javascript.chinese.md
View File

@ -2,15 +2,21 @@
id: cf1391c1c11feddfaeb4bdef
title: Create Decimal Numbers with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript创建十进制数
videoUrl: 'https://scrimba.com/c/ca8GEuW'
forumTopicId: 16826
localeTitle: 创建一个小数
---
## Description
<section id="description">我们也可以在变量中存储十进制数。十进制数有时称为<dfn>浮点数</dfn>或<dfn>浮点数</dfn> 。 <strong>注意</strong> <br>并非所有实数都可以准确地以<dfn>浮点</dfn>表示。这可能导致舍入错误。 <a href="https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems" target="_blank">细节在这里</a> 。 </section>
<section id='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.7</code> ）。 </section>
<section id='instructions'>
创建一个变量<code>myDecimal</code>并给它赋值一个浮点数。(例如<code>5.21</code>)。
</section>
## Tests
<section id='tests'>
@ -19,8 +25,8 @@ localeTitle: 使用JavaScript创建十进制数
tests:
- text: <code>myDecimal</code>应该是一个数字。
testString: assert(typeof myDecimal === "number");
- text: <code>myDecimal</code>应该有一个小数点
testString: assert(myDecimal % 1 != 0);
- text: <code>myDecimal</code>应该包含小数点。
testString: assert(myDecimal % 1 != 0);
```
@ -36,6 +42,7 @@ var ourDecimal = 5.7;
// Only change code below this line
```
</div>
@ -45,7 +52,7 @@ var ourDecimal = 5.7;
<div id='js-teardown'>
```js
console.info('after the test');
(function(){if(typeof myDecimal !== "undefined"){return myDecimal;}})();
```
</div>
@ -55,7 +62,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myDecimal = 9.9;
```
</section>

35
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/declare-javascript-variables.chinese.md
View File

@ -2,23 +2,40 @@
id: bd7123c9c443eddfaeb5bdef
title: Declare JavaScript Variables
challengeType: 1
videoUrl: ''
localeTitle: 声明JavaScript变量
videoUrl: 'https://scrimba.com/c/cNanrHq'
forumTopicId: 17556
localeTitle: 声明变量
---
## 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>strings</code> （例如<code>&quot;12&quot;</code> ， <code>&quot;dog&quot;</code>或<code>&quot;123 cats&quot;</code> ，它们是字符集合。计算机可以对数字执行数学运算，但不能对字符串执行数学运算。 <dfn>变量</dfn>允许计算机以动态方式存储和操作数据。他们通过使用“标签”指向数据而不是使用数据本身来做到这一点。七种数据类型中的任何一种都可以存储在变量中。 <code>Variables</code>类似于您在数学中使用的x和y变量，这意味着它们是表示我们想要引用的数据的简单名称。计算机<code>variables</code>与数学<code>variables</code>不同之处在于它们可以在不同时间存储不同的值。我们告诉JavaScript通过将关键字<code>var</code>放在它前面来创建或<dfn>声明</dfn>变量，如下所示： <blockquote> var ourName; </blockquote>创建一个名为<code>ourName</code>的<code>variable</code> 。在JavaScript中，我们以分号结束语句。 <code>Variable</code>名可以由数字，字母和<code>$</code>或<code>_</code> ，但不能包含空格或以数字开头。 </section>
<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>。计算机可以对数字执行数学运算，但不能对字符串执行数学运算。
<dfn>变量</dfn>允许计算机以一种动态的形式来存储和操作数据，通过操作指向数据的指针而不是数据本身来避免了内存泄露，以上的七种数据类型都可以存储到一个变量中。
<code>变量</code>非常类似于你在数学中使用的 x，y 变量，都是以一个简单命名的名称来代替我们赋值给它的数据。计算机中的<code>变量</code>与数学中的变量不同的是，计算机可以在不同的时间存储不同类型的变量。
通过在变量的前面使用关键字<code>var</code>，声明一个变量，例如：
```js
var ourName;
```
上面代码的意思是创建一个名为<code>ourName</code>的<code>变量</code>，在 JavaScript 中我们以分号结束语句。
<code>变量</code>名称可以由数字、字母、美元符号<code>$</code> 或者 下划线<code>_</code>组成，但是不能包含空格或者以数字为开头。
</section>
## Instructions
<section id="instructions">使用<code>var</code>关键字创建名为<code>myName</code>的变量。 <strong>暗示</strong> <br>如果你遇到<code>ourName</code>查看我们的<code>ourName</code>示例。 </section>
<section id='instructions'>
使用<code>var</code> 关键字来创建一个名为<code>myName</code>的变量。
<strong>提示</strong><br>如果遇到困难了，请看下<code>ourName</code>的例子是怎么写的。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 您应该使用<code>var</code>关键字声明<code>myName</code> ，以分号结尾
testString: assert(/var\s+myName\s*;/.test(code));
- text: 你需要使用<code>var</code>关键字定义一个变量<code>myName</code>，并使用分号结尾。
testString: assert(/var\s+myName\s*;/.test(code), '你需要使用<code>var</code>关键字定义一个变量<code>myName</code>。并使用分号结尾。');
```
@ -44,7 +61,7 @@ var ourName;
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myName !== "undefined"){(function(v){return v;})(myName);}
```
</div>
@ -54,7 +71,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myName;
```
</section>

25
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/declare-string-variables.chinese.md
View File

@ -2,24 +2,31 @@
id: bd7123c9c444eddfaeb5bdef
title: Declare String Variables
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/c2QvWU6'
forumTopicId: 17557
localeTitle: 声明字符串变量
---
## Description
<section id="description">以前我们使用过代码<code>var myName = &quot;your name&quot;;</code> <code>&quot;your name&quot;</code>被称为<dfn>字符串</dfn> <dfn>文字</dfn> 。它是一个字符串，因为它是用单引号或双引号括起来的一系列零个或多个字符。 </section>
<section id='description'>
之前我们写过这样的代码：
<code>var myName = "your name";</code>
<code>"your name"</code>被称作<dfn>字符串变量</dfn>。字符串是用单引号或双引号包裹起来的一连串的零个或多个字符。
</section>
## Instructions
<section id="instructions">创建两个新的<code>string</code>变量： <code>myFirstName</code>和<code>myLastName</code>并分别为它们分配<code>myFirstName</code>和<code>myLastName</code>的值。 </section>
<section id='instructions'>
创建两个新的<code>字符串变量</code>：<code>myFirstName</code>和<code>myLastName</code>，并用你的姓和名分别为它们赋值。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myFirstName</code>应该是一个至少包含一个字符的字符串。
- 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>应该是一个至少包含一个字符的字符串。
- text: <code>myLastName</code>应该是一个字符串,并且至少包含一个字符。
testString: assert((function(){if(typeof myLastName !== "undefined" && typeof myLastName === "string" && myLastName.length > 0){return true;}else{return false;}})());
```
@ -38,6 +45,7 @@ var lastName = "Turing";
// Only change code below this line
```
</div>
@ -47,7 +55,7 @@ var lastName = "Turing";
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myFirstName !== "undefined" && typeof myLastName !== "undefined"){(function(){return myFirstName + ', ' + myLastName;})();}
```
</div>
@ -57,7 +65,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myFirstName = "Alan";
var myLastName = "Turing";
```
</section>

32
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/decrement-a-number-with-javascript.chinese.md
View File

@ -2,28 +2,37 @@
id: 56533eb9ac21ba0edf2244ad
title: Decrement a Number with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript减少数字
videoUrl: 'https://scrimba.com/c/cM2KeS2'
forumTopicId: 17558
localeTitle: 数字递减
---
## Description
<section id="description">您可以使用<code>--</code>运算符轻松地将变量<dfn>减1</dfn>或减1。 <code>i--;</code>相当于<code>i = i - 1;</code> <strong>注意</strong> <br>整条线变成了<code>i--;</code> ，消除了对等号的需要。 </section>
<section id='description'>
使用自减符号<code>--</code>，你可以很方便地对一个变量执行<dfn>自减</dfn>或者<code>-1</code>运算。
<code>i--;</code>
等效于
<code>i = i - 1;</code>
<strong>提示</strong><br><code>i--;</code>这种写法，省去了书写<code>=</code>符号的必要。
</section>
## Instructions
<section id="instructions">更改代码以在<code>myVar</code>上使用<code>--</code>运算符。 </section>
<section id='instructions'>
重写代码，使用<code>--</code>符号对<code>myVar</code>执行自减操作。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myVar</code>应该等于<code>10</code>
- text: <code>myVar</code>应该等于<code>10</code>。
testString: assert(myVar === 10);
- text: <code>myVar = myVar - 1;</code>应该改变
- 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>运算符
- text: 对<code>myVar</code>使用<code>--</code>运算符。
testString: assert(/[-]{2}\s*myVar|myVar\s*[-]{2}/.test(code));
- text: 不要更改行上方的代码
- text: 不要修改注释上面的代码。
testString: assert(/var myVar = 11;/.test(code));
```
@ -50,7 +59,7 @@ myVar = myVar - 1;
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return 'myVar = ' + z;})(myVar);
```
</div>
@ -60,7 +69,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myVar = 11;
myVar--;
```
</section>

39
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/delete-properties-from-a-javascript-object.chinese.md
View File

@ -2,24 +2,30 @@
id: 56bbb991ad1ed5201cd392d3
title: Delete Properties from a JavaScript Object
challengeType: 1
videoUrl: ''
localeTitle: 从JavaScript对象中删除属性
videoUrl: 'https://scrimba.com/c/cDqKdTv'
forumTopicId: 17560
localeTitle: 删除对象的属性
---
## Description
<section id="description">我们还可以删除对象中的属性，如下所示： <code>delete ourDog.bark;</code> </section>
<section id='description'>
我们同样可以删除对象的属性，例如：
<code>delete ourDog.bark;</code>
</section>
## Instructions
<section id="instructions">从<code>myDog</code>删除<code>&quot;tails&quot;</code>属性。您可以使用点或括号表示法。 </section>
<section id='instructions'>
删除<code>myDog</code>对象的<code>"tails"</code>属性。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 从<code>myDog</code>删除属性<code>&quot;tails&quot;</code> 。
- text: 从<code>myDog</code>中删除<code>"tails"</code>属性。
testString: assert(typeof myDog === "object" && myDog.tails === undefined);
- text: 不要修改<code>myDog</code>设置
- text: 不要修改<code>myDog</code>的初始化。
testString: 'assert(code.match(/"tails": 1/g).length > 1);'
```
@ -54,6 +60,7 @@ var myDog = {
// Only change code below this line.
```
</div>
@ -63,7 +70,7 @@ var myDog = {
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return z;})(myDog);
```
</div>
@ -73,7 +80,23 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
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>

25
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-decimal-by-another-with-javascript.chinese.md
View File

@ -2,26 +2,31 @@
id: bd7993c9ca9feddfaeb7bdef
title: Divide One Decimal by Another with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript将另一个十进制除以另一个
videoUrl: 'https://scrimba.com/c/cBZe9AW'
forumTopicId: 18255
localeTitle: 两个小数相除
---
## Description
<section id="description">现在让我们将一位小数除以另一位小数。 </section>
<section id='description'>
现在让我们将一个小数除以另一个小数。
</section>
## Instructions
<section id="instructions">更改<code>0.0</code>使<code>quotient</code>等于<code>2.2</code> 。 </section>
<section id='instructions'>
改变数值<code>0.0</code>的值让变量<code>quotient</code>的值等于<code>2.2</code>.
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 变<code>quotient</code>应该等于<code>2.2</code>
- text: <code>quotient</code>的值应该等于<code>2.2</code>。
testString: assert(quotient === 2.2);
- text: 您应该使用<code>/</code>运算符将4.4除以2
- text: 使用<code>/</code>运算符将 4.4 除以 2。
testString: assert(/4\.40*\s*\/\s*2\.*0*/.test(code));
- text: 商数变量只应分配一次
- text: quotient 变量应该只被赋值一次。
testString: assert(code.match(/quotient/g).length === 1);
```
@ -35,7 +40,6 @@ tests:
```js
var quotient = 0.0 / 2.0; // Fix this line
```
</div>
@ -45,7 +49,7 @@ var quotient = 0.0 / 2.0; // Fix this line
<div id='js-teardown'>
```js
console.info('after the test');
(function(y){return 'quotient = '+y;})(quotient);
```
</div>
@ -56,6 +60,7 @@ console.info('after the test');
<section id='solution'>
```js
// solution required
var quotient = 4.4 / 2.0;
```
</section>

33
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/divide-one-number-by-another-with-javascript.chinese.md
View File

@ -2,24 +2,38 @@
id: cf1111c1c11feddfaeb6bdef
title: Divide One Number by Another with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 用JavaScript划分一个号码
videoUrl: 'https://scrimba.com/c/cqkbdAr'
forumTopicId: 17566
localeTitle: 除法运算
---
## Description
<section id="description">我们也可以将一个数字除以另一个数字。 JavaScript使用<code>/</code>符号进行除法。 <p> <strong>例</strong> </p><blockquote> myVar = 16/2; //分配8 </blockquote></section>
<section id='description'>
我们可以在 JavaScript 中做除法运算。
JavaScript 中使用<code>/</code>符号做除法运算。
<strong>示例</strong>
```js
myVar = 16 / 2; // assigned 8
```
</section>
## Instructions
<section id="instructions">更改<code>0</code> ，使<code>quotient</code>等于<code>2</code> 。 </section>
<section id='instructions'>
改变数值<code>0</code>来让变量<code>quotient</code>的值等于<code>2</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 使变量<code>quotient</code>等于2。
- text: 要使<code>quotient</code>的值等于 2。
testString: assert(quotient === 2);
- text: 使用<code>/</code>运算符
- text: 使用<code>/</code>运算符。
testString: assert(/\d+\s*\/\s*\d+/.test(code));
```
@ -34,6 +48,7 @@ tests:
```js
var quotient = 66 / 0;
```
</div>
@ -43,7 +58,7 @@ var quotient = 66 / 0;
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return 'quotient = '+z;})(quotient);
```
</div>
@ -53,7 +68,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var quotient = 66 / 33;
```
</section>

52
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/escape-sequences-in-strings.chinese.md
View File

@ -2,33 +2,46 @@
id: 56533eb9ac21ba0edf2244b6
title: Escape Sequences in Strings
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/cvmqRh6'
forumTopicId: 17567
localeTitle: 字符串中的转义序列
---
## Description
<section id="description">引号不是可以在字符串中<dfn>转义</dfn>的唯一字符。使用转义字符有两个原因：首先是允许您使用您可能无法输入的字符，例如退格。其次是允许你在一个字符串中表示多个引号，而不会误解你的意思。我们在之前的挑战中学到了这一点。 <table class="table table-striped"><thead><tr><th>码</th><th>产量</th></tr></thead><tbody><tr><td> <code>\&#39;</code> </td> <td>单引号</td></tr><tr><td> <code>\&quot;</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>
<section id='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>第一行<br> \第二行<br> ThirdLine </blockquote>您将需要使用转义序列正确插入特殊字符。您还需要按照上面的间距来跟踪，在转义序列或单词之间没有空格。这是写出转义序列的文本。 <q>FirstLine <code>newline</code> <code>tab</code> <code>backslash</code> SecondLine <code>newline</code> ThirdLine</q> </section>
<section id='instructions'>
使用转义字符将下面三行文本字符串赋给变量<code>myStr</code>。
<blockquote>FirstLine<br/>&nbsp;&nbsp;&nbsp;&nbsp;\SecondLine<br/>ThirdLine</blockquote>
你需要使用转义字符正确地插入特殊字符，确保间距与上面文本一致并且单词或转义字符之间没有空格。
像这样用转义字符写出来：
<q>FirstLine<code>换行符</code><code>制表符</code><code>反斜杠</code>SecondLine<code>换行符</code>ThirdLine</q>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myStr</code>不应包含任何空格
testString: 'assert(!/ /.test(myStr), "<code>myStr</code> should not contain any spaces");'
- text: <code>myStr</code>应包含的字符串<code>FirstLine</code> ， <code>SecondLine</code>和<code>ThirdLine</code> （记住区分大小写）
testString: 'assert(/FirstLine/.test(myStr) && /SecondLine/.test(myStr) && /ThirdLine/.test(myStr), "<code>myStr</code> should contain the strings <code>FirstLine</code>, <code>SecondLine</code> and <code>ThirdLine</code> (remember case sensitivity)");'
- text: <code>FirstLine</code>后面应跟换行符<code>\n</code>
testString: 'assert(/FirstLine\n/.test(myStr), "<code>FirstLine</code> should be followed by the newline character <code>\n</code>");'
- text: <code>myStr</code>应该包含一个制表字符<code>\t</code> ，它跟在换行符后面
testString: 'assert(/\n\t/.test(myStr), "<code>myStr</code> should contain a tab character <code>\t</code> which follows a newline character");'
- text: <code>SecondLine</code>应该以反斜杠字符<code>\\</code>开头
testString: 'assert(/\SecondLine/.test(myStr), "<code>SecondLine</code> should be preceded by the backslash character <code>\\</code>");'
- text: <code>SecondLine</code>和<code>ThirdLine</code>之间应该有换行符
testString: 'assert(/SecondLine\nThirdLine/.test(myStr), "There should be a newline character between <code>SecondLine</code> and <code>ThirdLine</code>");'
- 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');
```
@ -42,6 +55,7 @@ tests:
```js
var myStr; // Change this line
```
</div>
@ -51,7 +65,9 @@ var myStr; // Change this line
<div id='js-teardown'>
```js
console.info('after the test');
(function(){
if (myStr !== undefined){
console.log('myStr:\n' + myStr);}})();
```
</div>
@ -61,7 +77,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myStr = "FirstLine\n\t\\SecondLine\nThirdLine";
```
</section>

37
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/escaping-literal-quotes-in-strings.chinese.md
View File

@ -2,25 +2,35 @@
id: 56533eb9ac21ba0edf2244b5
title: Escaping Literal Quotes in Strings
challengeType: 1
videoUrl: ''
localeTitle: 逃避字符串中的字面引用
videoUrl: 'https://scrimba.com/c/c2QvgSr'
forumTopicId: 17568
localeTitle: 转义字符串中的引号
---
## Description
<section id="description">在定义字符串时，必须以单引号或双引号开头和结尾。当你需要一个文字报价会发生什么： <code>&quot;</code>还是<code>&#39;</code> ？你的字符串里面在JavaScript中，你可以放置一个<dfn>反斜杠</dfn> （从考虑到它作为字符串报价的最终<dfn>逃脱</dfn>报价<code>\</code>在引号前）。 <code>var sampleStr = &quot;Alan said, \&quot;Peter is learning JavaScript\&quot;.&quot;;</code>这告诉JavaScript，以下引用不是字符串的结尾，而是应该出现在字符串中。所以如果要将它打印到控制台，你会得到： <code>Alan said, &quot;Peter is learning JavaScript&quot;.</code> </section>
<section id='description'>
定义一个字符串必须要用单引号或双引号来包裹它。那么当你的字符串里面包含：<code>"</code>或者<code>'</code>时该怎么办呢?
在 JavaScript 中，你可以通过在引号前面使用<dfn>反斜杠</dfn>（<code>\</code>）来转义引号。
<code>var sampleStr = "Alan said, \"Peter is learning JavaScript\".";</code>
有了转义符号，JavaScript 就知道这个单引号或双引号并不是字符串的结尾，而是字符串内的字符。所以，上面的字符串打印到控制台的结果为：
<code>Alan said, "Peter is learning JavaScript".</code>
</section>
## Instructions
<section id="instructions">使用<dfn>反斜杠</dfn>将字符串分配给<code>myStr</code>变量，这样如果要将其打印到控制台，您会看到： <code>I am a &quot;double quoted&quot; string inside &quot;double quotes&quot;.</code> </section>
<section id='instructions'>
使用<dfn>反斜杠</dfn>将一个字符串赋值给变量<code>myStr</code>，打印到控制台，输出为：
<code>I am a "double quoted" string inside "double quotes".</code>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 您应该使用两个双引号（ <code>&quot;</code> ）和四个转义双引号（ <code>\&quot;</code> ）。
- 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 &quot;double quoted&quot; string inside &quot;double quotes&quot;.</code>
testString: 'assert(myStr === "I am a \"double quoted\" string inside \"double quotes\".");'
- 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\".");
```
@ -34,6 +44,7 @@ tests:
```js
var myStr = ""; // Change this line
```
</div>
@ -43,7 +54,13 @@ var myStr = ""; // Change this line
<div id='js-teardown'>
```js
console.info('after the test');
(function(){
if(typeof myStr === 'string') {
console.log("myStr = \"" + myStr + "\"");
} else {
console.log("myStr is undefined");
}
})();
```
</div>
@ -53,7 +70,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myStr = "I am a \"double quoted\" string inside \"double quotes\".";
```
</section>

44
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/find-the-length-of-a-string.chinese.md
View File

@ -2,25 +2,34 @@
id: bd7123c9c448eddfaeb5bdef
title: Find the Length of a String
challengeType: 1
videoUrl: ''
localeTitle: 找到字符串的长度
videoUrl: 'https://scrimba.com/c/cvmqEAd'
forumTopicId: 18182
localeTitle: 查找字符串的长度
---
## Description
<section id="description">您可以通过在字符串变量或字符串文字后面写<code>.length</code>来查找<code>String</code>值的长度。 <code>&quot;Alan Peter&quot;.length; // 10</code>例如，如果我们创建了一个变量<code>var firstName = &quot;Charles&quot;</code> ，我们可以通过使用<code>firstName.length</code>属性找出字符串<code>&quot;Charles&quot;</code>长度。 </section>
<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>
## Instructions
<section id="instructions">使用<code>.length</code>属性计算<code>lastName</code>变量中的字符数，并将其分配给<code>lastNameLength</code> 。 </section>
<section id='instructions'>
使用<code>.length</code>属性来获得变量<code>lastName</code>的长度，并把它赋值给变量<code>lastNameLength</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>lastNameLength</code>应该等于8。
testString: 'assert((function(){if(typeof lastNameLength !== "undefined" && typeof lastNameLength === "number" && lastNameLength === 8){return true;}else{return false;}})(), "<code>lastNameLength</code> should be equal to eight.");'
- text: 您应该使用<code>.length</code>来获取<code>lastName</code>的长度，如下所示： <code>lastName.length</code> 。
testString: 'assert((function(){if(code.match(/\.length/gi) && code.match(/\.length/gi).length >= 2 && code.match(/var lastNameLength \= 0;/gi) && code.match(/var lastNameLength \= 0;/gi).length >= 1){return true;}else{return false;}})(), "You should be getting the length of <code>lastName</code> by using <code>.length</code> like this: <code>lastName.length</code>.");'
- 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/));
```
@ -46,16 +55,7 @@ var lastName = "Lovelace";
lastNameLength = lastName;
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
@ -65,7 +65,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var firstNameLength = 0;
var firstName = "Ada";
firstNameLength = firstName.length;
var lastNameLength = 0;
var lastName = "Lovelace";
lastNameLength = lastName.length;
```
</section>

30
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/finding-a-remainder-in-javascript.chinese.md
View File

@ -2,26 +2,36 @@
id: 56533eb9ac21ba0edf2244ae
title: Finding a Remainder in JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 在JavaScript中查找剩余内容
videoUrl: 'https://scrimba.com/c/cWP24Ub'
forumTopicId: 18184
localeTitle: 求余运算
---
## Description
<section id="description"> <dfn>余数</dfn>运算符<code>%</code>给出了两个数的除法的余数。 <strong>例</strong> <blockquote> 5％2 = 1因为<br> Math.floor（5/2）= 2（商数） <br> 2 * 2 = 4 <br> 5 - 4 = 1（剩余） </blockquote> <strong>用法</strong> <br>在数学中，通过检查数字除以<code>2</code>的余数，可以检查数字是偶数还是奇数。 <blockquote> 17％2 = 1（17为奇数） <br> 48％2 = 0（48为偶数） </blockquote> <strong>注意</strong> <br> <dfn>余数</dfn>运算符有时被错误地称为“模数”运算符。它与模数非常相似，但在负数下不能正常工作。 </section>
<section id='description'>
<dfn>remainder</dfn>求余运算符<code>%</code>返回两个数相除得到的余数
<strong>示例</strong>
<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。
<blockquote>17 % 2 = 1（17 是奇数）<br>48 % 2 = 0（48 是偶数）</blockquote>
<strong>提示<strong><br>余数运算符(<dfn>remainder</dfn>)有时被错误地称为“模数”运算符。它与模数非常相似，但不能用于负数的运算。
</section>
## Instructions
<section id="instructions">使用<dfn>余数</dfn> （ <code>%</code> ）运算符将<code>remainder</code>设置为等于<code>11</code>的余数除以<code>3</code> 。 </section>
<section id='instructions'>
使用<code>%</code>运算符，计算 11 除以 3 的余数，并把余数赋给变量 remainder。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 应该初始化变量<code>remainder</code>
- text: 变量<code>remainder</code>应该被初始化。
testString: assert(/var\s+?remainder/.test(code));
- text: <code>remainder</code>的值应为<code>2</code>
- text: <code>remainder</code>的值应该等于<code>2</code>。
testString: assert(remainder === 2);
- text: 您应该使用<code>%</code>运算符
- text: 你应该使用<code>%</code>运算符。
testString: assert(/\s+?remainder\s*?=\s*?.*%.*;/.test(code));
```
@ -47,7 +57,7 @@ var remainder;
<div id='js-teardown'>
```js
console.info('after the test');
(function(y){return 'remainder = '+y;})(remainder);
```
</div>
@ -57,7 +67,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var remainder = 11 % 3;
```
</section>

28
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-fractions-with-javascript.chinese.md
View File

@ -2,15 +2,22 @@
id: cf1111c1c11feddfaeb9bdef
title: Generate Random Fractions with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript生成随机分数
videoUrl: 'https://scrimba.com/c/cyWJJs3'
forumTopicId: 18185
localeTitle: 使用 JavaScript 生成随机分数
---
## Description
<section id="description">随机数对于创建随机行为很有用。 JavaScript有一个<code>Math.random()</code>函数，它生成一个介于<code>0</code> （含）和不高达<code>1</code> （独占）之间的随机十进制数。因此<code>Math.random()</code>可以返回<code>0</code>但永远不会返回<code>1</code> <strong>Note</strong> <br> <a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank">与使用Equal运算符存储值</a>一样，所有函数调用将在<code>return</code>执行之前解析，因此我们可以<code>return</code> <code>Math.random()</code>函数的值。 </section>
<section id='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>
<section id='instructions'>
更改<code>randomFraction</code>使其返回一个随机数而不是<code>0</code>。
</section>
## Tests
<section id='tests'>
@ -19,9 +26,9 @@ localeTitle: 使用JavaScript生成随机分数
tests:
- text: <code>randomFraction</code>应该返回一个随机数。
testString: assert(typeof randomFraction() === "number");
- text: <code>randomFraction</code>返回的<code>randomFraction</code>应该是小数。
- text: <code>randomFraction</code>应该返回一个小数。
testString: assert((randomFraction()+''). match(/\./g));
- text: 您应该使用<code>Math.random</code>来生成随机十进制数。
- text: 需要使用<code>Math.random</code>生成随机的小数。
testString: assert(code.match(/Math\.random/g).length >= 0);
```
@ -42,7 +49,6 @@ function randomFraction() {
// Only change code above this line.
}
```
</div>
@ -52,7 +58,7 @@ function randomFraction() {
<div id='js-teardown'>
```js
console.info('after the test');
(function(){return randomFraction();})();
```
</div>
@ -62,7 +68,11 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
function randomFraction() {
return Math.random();
}
```
</section>

36
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-with-javascript.chinese.md
View File

@ -2,28 +2,38 @@
id: cf1111c1c12feddfaeb1bdef
title: Generate Random Whole Numbers with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript生成随机整数
videoUrl: 'https://scrimba.com/c/cRn6bfr'
forumTopicId: 18186
localeTitle: 使用 JavaScript 生成随机整数
---
## Description
<section id="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>20</code> 。这项技术将给我们一个<code>0</code>到<code>19</code>之间的整数。将所有内容放在一起，这就是我们的代码： <code>Math.floor(Math.random() * 20);</code>我们调用<code>Math.random()</code> ，将结果乘以20，然后将值传递给<code>Math.floor()</code>函数，将值向下舍入到最接近的整数。 </section>
<section id='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之间的整数。
把操作连缀起来，代码类似于下面：
<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>
<section id='instructions'>
生成一个<code>0</code>到<code>9</code>之间的随机整数。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>randomWholeNum</code>的结果应该是整数。
- text: <code>myFunction</code>的结果应该是一个整数。
testString: assert(typeof randomWholeNum() === "number" && (function(){var r = randomWholeNum();return Math.floor(r) === r;})());
- text: 您应该使用<code>Math.random</code>来生成随机数。
- text: 需要使用<code>Math.random</code>生成随机数字。
testString: assert(code.match(/Math.random/g).length > 1);
- text: 您应该将<code>Math.random</code>的结果乘以10，使其成为介于0和9之间的数字。
- 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>删除数字的小数部分。
- text: 你需要使用<code>Math.floor</code>移除数字中的小数部分。
testString: assert(code.match(/Math.floor/g).length > 1);
```
@ -44,7 +54,6 @@ function randomWholeNum() {
return Math.random();
}
```
</div>
@ -54,7 +63,7 @@ function randomWholeNum() {
<div id='js-teardown'>
```js
console.info('after the test');
(function(){return randomWholeNum();})();
```
</div>
@ -64,7 +73,12 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var randomNumberBetween0and19 = Math.floor(Math.random() * 20);
function randomWholeNum() {
return Math.floor(Math.random() * 10);
}
```
</section>

46
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/generate-random-whole-numbers-within-a-range.chinese.md
View File

@ -2,28 +2,36 @@
id: cf1111c1c12feddfaeb2bdef
title: Generate Random Whole Numbers within a Range
challengeType: 1
videoUrl: ''
localeTitle: 生成范围内的随机整数
videoUrl: 'https://scrimba.com/c/cm83yu6'
forumTopicId: 18187
localeTitle: 生成某个范围内的随机整数
---
## Description
<section id="description">我们可以生成一个落在两个特定数字范围内的随机数，而不是像我们之前那样在零和给定数字之间生成一个随机数。为此，我们将定义最小数量<code>min</code>和最大数量<code>max</code> 。这是我们将使用的公式。花一点时间阅读它并尝试理解这段代码在做什么： <code>Math.floor(Math.random() * (max - min + 1)) + min</code> </section>
<section id='description'>
我们之前生成的随机数是在0到某个数之间，现在我们要生成的随机数是在两个指定的数之间。
我们需要定义一个最小值和一个最大值。
下面是我们将要使用的方法，仔细看看并尝试理解这行代码到底在干嘛：
<code>Math.floor(Math.random() * (max - min + 1)) + min</code>
</section>
## Instructions
<section id="instructions">创建一个名为<code>randomRange</code>的函数，它接受一个范围<code>myMin</code>和<code>myMax</code>并返回一个大于或等于<code>myMin</code>的随机数，并且小于或等于<code>myMax</code> （包括<code>myMax</code> ）。 </section>
<section id='instructions'>
创建一个叫<code>randomRange</code>的函数，参数为 myMin 和 myMax，返回一个在<code>myMin</code>（包括 myMin）和<code>myMax</code>（包括 myMax）之间的随机数。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>randomRange</code>可以生成的最低随机数应该等于你的最小数量<code>myMin</code> 。
- text: <code>randomRange</code>返回的随机数应该大于或等于<code>myMin</code>。
testString: assert(calcMin === 5);
- text: <code>randomRange</code>可以生成的最高随机数应该等于最大数量<code>myMax</code> 。
- text: <code>randomRange</code>返回的随机数应该小于或等于<code>myMax</code>。
testString: assert(calcMax === 15);
- text: <code>randomRange</code>生成的随机数应该是整数，而不是小数。
- text: <code>randomRange</code>应该返回一个随机整数, 而不是小数。
testString: assert(randomRange(0,1) % 1 === 0 );
- text: <code>randomRange</code>应该同时使用<code>myMax</code>和<code>myMin</code> ，并在你的范围内返回一个随机数。
- 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;}})());
```
@ -54,7 +62,6 @@ function randomRange(myMin, myMax) {
// Change these values to test your function
var myRandom = randomRange(5, 15);
```
</div>
@ -64,7 +71,20 @@ var myRandom = randomRange(5, 15);
<div id='js-teardown'>
```js
console.info('after the test');
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";
}
})()
```
</div>
@ -74,7 +94,11 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
function randomRange(myMin, myMax) {
return Math.floor(Math.random() * (myMax - myMin + 1)) + myMin;
}
```
</section>

52
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/global-scope-and-functions.chinese.md
View File

@ -2,28 +2,35 @@
id: 56533eb9ac21ba0edf2244be
title: Global Scope and Functions
challengeType: 1
videoUrl: ''
localeTitle: 全球范围和职能
videoUrl: 'https://scrimba.com/c/cQM7mCN'
forumTopicId: 18193
localeTitle: 全局作用域和函数
---
## Description
<section id="description">在JavaScript中， <dfn>范围</dfn>是指变量的可见性。在功能块之外定义的变量具有<dfn>全局</dfn>范围。这意味着，它们可以在JavaScript代码中随处可见。在没有<code>var</code>关键字的情况下使用的变量将在<code>global</code>范围内自动创建。这可能会在代码中的其他位置或再次运行函数时产生意外后果。您应该始终使用<code>var</code>声明变量。 </section>
<section id='description'>
在 JavaScript 中，<dfn>作用域</dfn>涉及到变量的作用范围。在函数外定义的变量具有 <dfn>全局</dfn> 作用域。这意味着，具有全局作用域的变量可以在代码的任何地方被调用。
这些没有使用<code>var</code>关键字定义的变量，会被自动创建在全局作用域中，形成全局变量。当在代码其他地方无意间定义了一个变量，刚好变量名与全局变量相同，这时会产生意想不到的后果。因此你应该总是使用var关键字来声明你的变量。
</section>
## Instructions
<section id="instructions">使用<code>var</code> ，在任何函数之外声明一个<code>global</code>变量<code>myGlobal</code> 。使用值<code>10</code>初始化它。在函数<code>fun1</code>内部，在<strong><em>不</em></strong>使用<code>var</code>关键字的<strong><em>情况下</em></strong>为<code>oopsGlobal</code>分配<code>5</code> 。 </section>
<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>
## Tests
<section id='tests'>
```yml
tests:
- text: 应该定义<code>myGlobal</code>
- text: 应定义<code>myGlobal</code>。
testString: assert(typeof myGlobal != "undefined");
- text: <code>myGlobal</code>的值应为<code>10</code>
- text: <code>myGlobal</code>的值应为<code>10</code>。
testString: assert(myGlobal === 10);
- text: 应使用<code>var</code>关键字声明<code>myGlobal</code>
- text: 应使用<code>var</code>关键字定义<code>myGlobal</code>。
testString: assert(/var\s+myGlobal/.test(code));
- text: <code>oopsGlobal</code>应该是一个全局变量，其值为<code>5</code>
- text: <code>oopsGlobal</code>应为全局变量且值为<code>5</code>。
testString: assert(typeof oopsGlobal != "undefined" && oopsGlobal === 5);
```
@ -55,7 +62,6 @@ function fun2() {
}
console.log(output);
}
```
</div>
@ -84,7 +90,6 @@ function uncapture() {
}
var oopsGlobal;
capture();
```
</div>
@ -93,7 +98,10 @@ capture();
<div id='js-teardown'>
```js
console.info('after the test');
fun1();
fun2();
uncapture();
(function() { return logOutput || "console.log never called"; })();
```
</div>
@ -103,7 +111,27 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
// 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);
}
```
</section>

39
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/global-vs.-local-scope-in-functions.chinese.md
View File

@ -2,26 +2,42 @@
id: 56533eb9ac21ba0edf2244c0
title: Global vs. Local Scope in Functions
challengeType: 1
videoUrl: ''
localeTitle: 功能中的全局与局部范围
videoUrl: 'https://scrimba.com/c/c2QwKH2'
forumTopicId: 18194
localeTitle: 函数中的全局作用域和局部作用域
---
## Description
<section id="description">可以使<dfn>本地</dfn>变量和<dfn>全局</dfn>变量具有相同的名称。执行此操作时， <code>local</code>变量优先于<code>global</code>变量。在这个例子中： <blockquote> var someVar =“帽子”; <br> function myFun（）{ <br> var someVar =“Head”; <br>返回someVar; <br> } </blockquote>函数<code>myFun</code>将返回<code>&quot;Head&quot;</code>因为存在变量的<code>local</code>版本。 </section>
<section id='description'>
一个程序中有可能具有相同名称的<dfn>局部</dfn>变量 和<dfn>全局</dfn>变量。在这种情况下，<code>局部</code>变量将会优先于<code>全局</code>变量。
下面为例：
```js
var someVar = "Hat";
function myFun() {
var someVar = "Head";
return someVar;
}
```
函数<code>myFun</code>将会返回<code>"Head"</code>，因为<code>局部变量</code>优先级更高。
</section>
## Instructions
<section id="instructions">将一个局部变量添加到<code>myOutfit</code>函数，以使用<code>&quot;sweater&quot;</code>覆盖<code>outerWear</code>的值。 </section>
<section id='instructions'>
给<code>myOutfit</code>添加一个局部变量来覆盖<code>outerWear</code>的值为<code>"sweater"</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 不要更改全局<code>outerWear</code>的值
- text: 不要修改全局变量<code>outerWear</code>的值。
testString: assert(outerWear === "T-Shirt");
- text: <code>myOutfit</code>应该返回<code>&quot;sweater&quot;</code>
- text: <code>myOutfit</code>应该返回<code>"sweater"</code>。
testString: assert(myOutfit() === "sweater");
- text: 不要更改return语句
- text: 不要修改<code>return</code>语句。
testString: assert(/return outerWear/.test(code));
```
@ -47,7 +63,6 @@ function myOutfit() {
}
myOutfit();
```
</div>
@ -59,7 +74,13 @@ myOutfit();
## Solution
<section id='solution'>
```js
// solution required
var outerWear = "T-Shirt";
function myOutfit() {
var outerWear = "sweater";
return outerWear;
}
```
</section>

68
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/golf-code.chinese.md
View File

@ -2,15 +2,22 @@
id: 5664820f61c48e80c9fa476c
title: Golf Code
challengeType: 1
videoUrl: ''
localeTitle: 高尔夫码
videoUrl: 'https://scrimba.com/c/c9ykNUR'
forumTopicId: 18195
localeTitle: 高尔夫代码
---
## Description
<section id="description">在<a href="https://en.wikipedia.org/wiki/Golf" target="_blank">高尔夫</a>比赛中，每个洞都具有<code>par</code>意义，即高尔夫球手为了将球沉入洞中以完成比赛所期望的平均<code>strokes</code>次数。根据你的<code>strokes</code>高出或低于<code>par</code>的距离，有一个不同的昵称。您的函数将通过<code>par</code>和<code>strokes</code>参数。根据此表返回正确的字符串，该表按优先级顺序列出笔划;顶部（最高）到底部（最低）： <table class="table table-striped"><thead><tr><th>笔画</th><th>返回</th></tr></thead><tbody><tr><td> 1 </td><td> “一杆进洞！” </td></tr><tr><td> &lt;= par - 2 </td><td> “鹰” </td></tr><tr><td> par - 1 </td><td> “小鸟” </td></tr><tr><td>平价</td><td> “相提并论” </td></tr><tr><td> par + 1 </td><td> “柏忌” </td></tr><tr><td> par + 2 </td><td> “双柏忌” </td></tr><tr><td> &gt; = par + 3 </td><td> “回家！” </td></tr></tbody></table> <code>par</code>和<code>strokes</code>将始终为数字和正数。为方便起见，我们添加了所有名称的数组。 </section>
<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>
## Instructions
<section id="instructions">
<section id='instructions'>
</section>
## Tests
@ -18,27 +25,27 @@ localeTitle: 高尔夫码
```yml
tests:
- text: '<code>golfScore(4, 1)</code>应该返回“Hole-in-one！”'
- text: <code>golfScore(4, 1)</code>应该返回 "Hole-in-one!"。
testString: assert(golfScore(4, 1) === "Hole-in-one!");
- text: '<code>golfScore(4, 2)</code>应该返回“Eagle”'
- text: <code>golfScore(4, 2)</code>应该返回 "Eagle"。
testString: assert(golfScore(4, 2) === "Eagle");
- text: '<code>golfScore(5, 2)</code>应该返回“Eagle”'
- text: <code>golfScore(5, 2)</code>应该返回 "Eagle"。
testString: assert(golfScore(5, 2) === "Eagle");
- text: '<code>golfScore(4, 3)</code>应该返回“Birdie”'
- text: <code>golfScore(4, 3)</code>应该返回 "Birdie"。
testString: assert(golfScore(4, 3) === "Birdie");
- text: '<code>golfScore(4, 4)</code>应该返回“Par”'
- text: <code>golfScore(4, 4)</code>应该返回 "Par"。
testString: assert(golfScore(4, 4) === "Par");
- text: '<code>golfScore(1, 1)</code>应该返回“Hole-in-one！”'
- text: <code>golfScore(1, 1)</code>应该返回 "Hole-in-one!"。
testString: assert(golfScore(1, 1) === "Hole-in-one!");
- text: '<code>golfScore(5, 5)</code>应该返回“Par”'
- text: <code>golfScore(5, 5)</code>应该返回 "Par"。
testString: assert(golfScore(5, 5) === "Par");
- text: '<code>golfScore(4, 5)</code>应该返回“Bogey”'
- text: <code>golfScore(4, 5)</code>应该返回 "Bogey"。
testString: assert(golfScore(4, 5) === "Bogey");
- text: '<code>golfScore(4, 6)</code>应该返回“Double Bogey”'
- text: <code>golfScore(4, 6)</code>应该返回 "Double Bogey"。
testString: assert(golfScore(4, 6) === "Double Bogey");
- text: '<code>golfScore(4, 7)</code>应该返回“Go Home！”'
- text: <code>golfScore(4, 7)</code>应该返回 "Go Home!"。
testString: assert(golfScore(4, 7) === "Go Home!");
- text: '<code>golfScore(5, 9)</code>应该返回“Go Home！”'
- text: <code>golfScore(5, 9)</code>应该返回 "Go Home!"。
testString: assert(golfScore(5, 9) === "Go Home!");
```
@ -62,7 +69,6 @@ function golfScore(par, strokes) {
// Change these values to test
golfScore(5, 4);
```
</div>
@ -74,7 +80,35 @@ golfScore(5, 4);
## Solution
<section id='solution'>
```js
// solution required
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!";
}
```
</section>

35
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/increment-a-number-with-javascript.chinese.md
View File

@ -2,28 +2,38 @@
id: 56533eb9ac21ba0edf2244ac
title: Increment a Number with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript增加数字
videoUrl: 'https://scrimba.com/c/ca8GLT9'
forumTopicId: 18201
localeTitle: 数字递增
---
## Description
<section id="description">您可以轻松地<dfn>增加</dfn>或添加一个变量与<code>++</code>运算符。 <code>i++;</code>相当于<code>i = i + 1;</code> <strong>注意</strong> <br>整行成为<code>i++;</code> ，消除了对等号的需要。 </section>
<section id='description'>
使用<code>++</code>，我们可以很容易地对变量进行自增或者<code>+1</code>运算。
<code>i++;</code>
等效于
<code>i = i + 1;</code>
<strong>注意</strong><br><code>i++;</code>这种写法，省去了书写<code>=</code>符号的必要。
</section>
## Instructions
<section id="instructions">更改代码以在<code>myVar</code>上使用<code>++</code>运算符。 <strong>暗示</strong> <br>了解有关<a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment_()" target="_blank">算术运算符的</a>更多信息<a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment_()" target="_blank">- 增量（++）</a> 。 </section>
<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>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myVar</code>应该等于<code>88</code>
- 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*([+]{2}\s*myVar|myVar\s*[+]{2});/.test(code));
- text: 使用<code>++</code>运算符
- 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: 不要更改行上方的代码
- text: 不要修改注释上方的代码。
testString: assert(/var myVar = 87;/.test(code));
```
@ -50,7 +60,7 @@ myVar = myVar + 1;
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return 'myVar = ' + z;})(myVar);
```
</div>
@ -60,7 +70,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myVar = 87;
myVar++;
```
</section>

21
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/initializing-variables-with-the-assignment-operator.chinese.md
View File

@ -2,22 +2,29 @@
id: 56533eb9ac21ba0edf2244a9
title: Initializing Variables with the Assignment Operator
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/cWJ4Bfb'
forumTopicId: 301171
localeTitle: 使用赋值运算符初始化变量
---
## Description
<section id="description">通常将变量<dfn>初始化</dfn>为与声明的同一行中的初始值。 <code>var myVar = 0;</code>创建一个名为<code>myVar</code>的新变量，并为其指定初始值<code>0</code> 。 </section>
<section id='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>
<section id='instructions'>
通过关键字<code>var</code>定义一个变量<code>a</code>并且给它一个初始值<code>9</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 将<code>a</code>初始化为值<code>9</code>
- text: 你需要初始化<code>a</code>的值为<code>9</code>。
testString: assert(/var\s+a\s*=\s*9\s*/.test(code));
```
@ -44,7 +51,7 @@ var ourVar = 19;
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof a !== 'undefined') {(function(a){return "a = " + a;})(a);} else { (function() {return 'a is undefined';})(); }
```
</div>
@ -54,7 +61,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var a = 9;
```
</section>

54
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-if-statements.chinese.md
View File

@ -2,36 +2,52 @@
id: 56533eb9ac21ba0edf2244db
title: Introducing Else If Statements
challengeType: 1
videoUrl: ''
localeTitle: 如果声明引入Else
videoUrl: 'https://scrimba.com/c/caeJ2hm'
forumTopicId: 18206
localeTitle: 介绍 else if 语句
---
## Description
<section id="description">如果您有多个需要解决的条件，可以将<code>if</code>语句与<code>else if</code>语句链接在一起。 <blockquote> if（num&gt; 15）{ <br>返回“大于15”; <br> } else if（num &lt;5）{ <br>返回“小于5”; <br> } else { <br>返回“5到15之间”; <br> } </blockquote></section>
<section id='description'>
如果你有多个条件语句，你可以通过<code>else if</code>语句把<code>if</code>语句链起来。
```js
if (num > 15) {
return "Bigger than 15";
} else if (num < 5) {
return "Smaller than 5";
} else {
return "Between 5 and 15";
}
```
</section>
## Instructions
<section id="instructions">转换逻辑以使用<code>else if</code>语句。 </section>
<section id='instructions'>
使用<code>if else</code>实现同样的效果。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 你应该至少有两个<code>else</code>语句
- text: 你应该至少有两个<code>else</code>表达式。
testString: assert(code.match(/else/g).length > 1);
- text: 你应该至少有两个<code>if</code>语句
- text: 你应该至少有两个<code>if</code>表达式。
testString: assert(code.match(/if/g).length > 1);
- text: 您应该为每个条件关闭并打开花括号
testString: assert(code.match(/if\s*\((.+)\)\s*\{[\s\S]+\}\s*else if\s*\((.+)\)\s*\{[\s\S]+\}\s*else\s*\{[\s\S]+\s*\}/));
- text: <code>testElseIf(0)</code>应返回“小于5”
- text: <code>testElseIf(0)</code>应该返回 "Smaller than 5"。
testString: assert(testElseIf(0) === "Smaller than 5");
- text: <code>testElseIf(5)</code>应该返回“5到10之间”
- text: <code>testElseIf(5)</code>应该返回 "Between 5 and 10"。
testString: assert(testElseIf(5) === "Between 5 and 10");
- text: <code>testElseIf(7)</code>应返回“5到10之间”
- text: <code>testElseIf(7)</code>应该返回 "Between 5 and 10"。
testString: assert(testElseIf(7) === "Between 5 and 10");
- text: <code>testElseIf(10)</code>应返回“5到10之间”
- text: <code>testElseIf(10)</code>应该返回 "Between 5 and 10"。
testString: assert(testElseIf(10) === "Between 5 and 10");
- text: <code>testElseIf(12)</code>应返回“大于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");
```
@ -70,7 +86,17 @@ testElseIf(7);
## Solution
<section id='solution'>
```js
// solution required
function testElseIf(val) {
if(val > 10) {
return "Greater than 10";
} else if(val < 5) {
return "Smaller than 5";
} else {
return "Between 5 and 10";
}
}
```
</section>

48
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/introducing-else-statements.chinese.md
View File

@ -2,34 +2,48 @@
id: 56533eb9ac21ba0edf2244da
title: Introducing Else Statements
challengeType: 1
videoUrl: ''
localeTitle: 介绍其他声明
videoUrl: 'https://scrimba.com/c/cek4Efq'
forumTopicId: 18207
localeTitle: 介绍 else 语句
---
## Description
<section id="description">当<code>if</code>语句的条件为真时，将执行其后面的代码块。当那个条件是假的时候怎么办？通常什么都不会发生。使用<code>else</code>语句，可以执行备用代码块。 <blockquote> if（num&gt; 10）{ <br>返回“大于10”; <br> } else { <br>返回“10或更少”; <br> } </blockquote></section>
<section id='description'>
当<code>if</code>语句的条件为真，大括号里的代码执行，那如果条件为假呢？正常情况下什么也不会发生。使用else语句，可以执行当条件为假时相应的代码。
```js
if (num > 10) {
return "Bigger than 10";
} else {
return "10 or Less";
}
```
</section>
## Instructions
<section id="instructions">将<code>if</code>语句组合到单个<code>if/else</code>语句中。 </section>
<section id='instructions'>
请把多个<code>if</code>语句合并为一个<code>if/else</code>语句。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 您应该只在编辑器中有一个<code>if</code>语句
- text: 你应该只有一个<code>if</code>表达式。
testString: assert(code.match(/if/g).length === 1);
- text: 你应该使用<code>else</code>语句
- text: 你应该使用一个<code>else</code>表达式。
testString: assert(/else/g.test(code));
- text: <code>testElse(4)</code>应返回“5或更小”
- text: <code>testElse(4)</code>应该返回 "5 or Smaller"。
testString: assert(testElse(4) === "5 or Smaller");
- text: <code>testElse(5)</code>应返回“5或更小”
- text: <code>testElse(5)</code>应该返回 "5 or Smaller"。
testString: assert(testElse(5) === "5 or Smaller");
- text: <code>testElse(6)</code>应该返回“大于5”
- text: <code>testElse(6)</code>应该返回 "Bigger than 5"。
testString: assert(testElse(6) === "Bigger than 5");
- text: <code>testElse(10)</code>应该返回“大于5”
- text: <code>testElse(10)</code>应该返回 "Bigger than 5"。
testString: assert(testElse(10) === "Bigger than 5");
- text: 请勿更改行上方或下方的代码。
- text: 不要修改上面和下面的代码。
testString: assert(/var result = "";/.test(code) && /return result;/.test(code));
```
@ -72,7 +86,17 @@ testElse(4);
## Solution
<section id='solution'>
```js
// solution required
function testElse(val) {
var result = "";
if(val > 5) {
result = "Bigger than 5";
} else {
result = "5 or Smaller";
}
return result;
}
```
</section>

43
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-odd-numbers-with-a-for-loop.chinese.md
View File

@ -2,24 +2,41 @@
id: 56104e9e514f539506016a5c
title: Iterate Odd Numbers With a For Loop
challengeType: 1
videoUrl: ''
localeTitle: 使用For循环迭代奇数
videoUrl: 'https://scrimba.com/c/cm8n7T9'
forumTopicId: 18212
localeTitle: 使用 For 循环遍历数组的奇数
---
## Description
<section id="description"> For循环不必一次迭代一个循环。通过改变我们的<code>final-expression</code> ，我们可以计算偶数。我们将从<code>i = 0</code>开始并在<code>i &lt; 10</code>循环。我们会增加<code>i</code>的2每个回路与<code>i += 2</code> 。 <blockquote> var ourArray = []; <br> for（var i = 0; i &lt;10; i + = 2）{ <br> ourArray.push（ⅰ）; <br> } </blockquote> <code>ourArray</code>现在包含<code>[0,2,4,6,8]</code> 。让我们改变<code>initialization</code>这样我们就可以用奇数来计算。 </section>
<section id='description'>
for循环可以按照我们指定的顺序来迭代，通过更改我们的<code>计数器</code>，我们可以按照偶数顺序来迭代。
初始化<code>i = 0</code>，当<code>i < 10</code>的时候继续循环。
<code>i += 2</code>让<code>i</code>每次循环之后增加2。
```js
var ourArray = [];
for (var i = 0; i < 10; i += 2) {
ourArray.push(i);
}
```
循环结束后，<code>ourArray</code>的值为<code>[0,2,4,6,8]</code>。
改变<code>计数器</code>，这样我们可以用奇数来数。
</section>
## Instructions
<section id="instructions">使用<code>for</code>循环将奇数从1到9推送到<code>myArray</code> 。 </section>
<section id='instructions'>
写一个<code>for</code>循环，把从 1 到 9 的奇数添加到<code>myArray</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 你应该为此使用<code>for</code>循环。
- text: 你应该使用<code>for</code>循环。
testString: assert(code.match(/for\s*\(/g).length > 1);
- text: '<code>myArray</code>应该等于<code>[1,3,5,7,9]</code> 。'
- text: <code>myArray</code>应该等于<code>[1,3,5,7,9]</code>。
testString: assert.deepEqual(myArray, [1,3,5,7,9]);
```
@ -44,6 +61,7 @@ var myArray = [];
// Only change code below this line.
```
</div>
@ -53,7 +71,7 @@ var myArray = [];
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
```
</div>
@ -63,7 +81,16 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
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>

55
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-through-an-array-with-a-for-loop.chinese.md
View File

@ -2,37 +2,49 @@
id: 5675e877dbd60be8ad28edc6
title: Iterate Through an Array with a For Loop
challengeType: 1
videoUrl: ''
localeTitle: 使用For循环遍历数组
videoUrl: 'https://scrimba.com/c/caeR3HB'
forumTopicId: 18216
localeTitle: 使用 For 循环遍历数组
---
## Description
<section id="description"> JavaScript中的一个常见任务是遍历数组的内容。一种方法是使用<code>for</code>循环。此代码将数组<code>arr</code>每个元素输出到控制台： <blockquote> var arr = [10,9,8,7,6]; <br> for（var i = 0; i &lt;arr.length; i ++）{ <br> （ARR [I]）的console.log; <br> } </blockquote>请记住，数组具有从零开始的编号，这意味着数组的最后一个索引是长度 - 1.我们对此循环的<dfn>条件</dfn>是<code>i &lt; arr.length</code> ，当<code>i</code>长度为1时停止。 </section>
<section id='description'>
迭代输出一个数组的每个元素是 JavaScript 中的常见需求，<code>for</code>循环可以做到这一点。下面的代码将输出数组 <code>arr</code>的每个元素到控制台：
```js
var arr = [10, 9, 8, 7, 6];
for (var i = 0; i < arr.length; i++) {
console.log(arr[i]);
}
```
记住数组的索引从零开始的，这意味着数组的最后一个元素的下标是：数组的长度 -1。我们这个循环的 <dfn>条件</dfn>是<code>i < arr.length</code>，当<code>i</code>的值为 长度 -1 的时候循环就停止了。在这个例子中，最后一个循环是 i === 4，也就是说，当i的值等于arr.length时，结果输出 6。
</section>
## Instructions
<section id="instructions">声明并将变量<code>total</code>初始化为<code>0</code> 。使用<code>for</code>循环将<code>myArr</code>数组的每个元素的值添加到<code>total</code> 。 </section>
<section id='instructions'>
声明并初始化一个变量<code>total</code>为<code>0</code>。使用<code>for</code>循环，使得<code>total</code>的值为<code>myArr</code>的数组中的每个元素的值的总和。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 应声明<code>total</code>并初始化为0
testString: assert(code.match(/(var|let|const)\s*?total\s*=\s*0.*?;?/));
- text: <code>total</code>应该等于20
- 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>
- 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.replace(/\s/g, '').match(/total[=+-]0*[1-9]+/gm));
- text: 不能直接把<code>total</code>设置成 20。
testString: assert(!code.match(/total[\s\+\-]*=\s*(\d(?!\s*[;,])|[1-9])/g));
```
</section>
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```js
@ -53,12 +65,12 @@ var myArr = [ 2, 3, 4, 5, 6];
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
(function(){if(typeof total !== 'undefined') { return "total = " + total; } else { return "total is undefined";}})()
```
</div>
@ -69,6 +81,19 @@ console.info('after the test');
<section id='solution'>
```js
// solution required
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];
}
```
</section>

72
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-do...while-loops.chinese.md
View File

@ -2,15 +2,57 @@
id: 5a2efd662fb457916e1fe604
title: Iterate with JavaScript Do...While Loops
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript迭代...循环
videoUrl: 'https://scrimba.com/c/cDqWGcp'
forumTopicId: 301172
localeTitle: do...while 循环
---
## Description
<section id="description">您可以使用循环多次运行相同的代码。你将学习的下一个类型的循环称为“ <code>do...while</code> ”循环，因为它首先将“ <code>do</code> ”循环内部代码的一次传递，无论如何，然后它运行“ <code>while</code> ”指定条件为真一旦这种情况不再真实就停止。我们来看一个例子。 <blockquote> var ourArray = []; <br> var i = 0; <br>做{ <br> ourArray.push（ⅰ）; <br>我++; <br> } while（i &lt;5）; </blockquote>这与任何其他类型的循环一样正常，结果数组看起来像<code>[0, 1, 2, 3, 4]</code> 。然而，什么使得<code>do...while</code>与其他循环不同，但是当条件在第一次检查时失败时它的行为如何。让我们看看这个在行动。这是一个常规的while循环，只要<code>i &lt; 5</code> ，它就会在循环中运行代码。 <blockquote> var ourArray = []; <br> var i = 5; <br>而（i &lt;5）{ <br> ourArray.push（ⅰ）; <br>我++; <br> } </blockquote>请注意，我们将<code>i</code>的值初始化为5.当我们执行下一行时，我们注意到<code>i</code>不小于5.所以我们不执行循环内的代码。结果是<code>ourArray</code>最终没有添加任何内容，因此当上面示例中的所有代码完成运行时，它仍然看起来像这个<code>[]</code> 。现在，看一下<code>do...while</code>循环。 <blockquote> var ourArray = []; <br> var i = 5; <br>做{ <br> ourArray.push（ⅰ）; <br>我++; <br> } while（i &lt;5）; </blockquote>在这种情况下，我们将<code>i</code>的值初始化为5，就像我们使用while循环一样。当我们到达下一行时，没有检查<code>i</code>的值，所以我们转到花括号内的代码并执行它。我们将在数组中添加一个元素并在进行条件检查之前递增<code>i</code> 。然后，当我们检查<code>i &lt; 5</code>看到<code>i</code>现在是6，这不符合条件检查。所以我们退出循环并完成。在上面的例子的末尾， <code>ourArray</code>的值是<code>[5]</code> 。本质上， <code>do...while</code>循环确保循环内的代码至少运行一次。让我们尝试通过将值推送到数组来实现<code>do...while</code>循环。 </section>
<section id='description'>
这一节我们将要学习的是<code>do...while</code>循环，它会先执行<code>do</code>里面的代码，如果<code>while</code>表达式为真则重复执行，反之则停止执行。我们来看一个例子。
```js
var ourArray = [];
var i = 0;
do {
ourArray.push(i);
i++;
} while (i < 5);
```
这看起来和其他循环语句差不多，返回的结果是<code>[0, 1, 2, 3, 4]</code>，<code>do...while</code>与其他循环不同点在于，初始条件为假时的表现，让我们通过实际的例子来看看。
这是一个普通的 while 循环，只要<code>i < 5</code>，它就会在循环中运行代码。
```js
var ourArray = [];
var i = 5;
while (i < 5) {
ourArray.push(i);
i++;
}
```
注意，我们首先将<code>i</code>的值初始化为 5。执行下一行时，注意到<code>i</code>不小于 5，循环内的代码将不会执行。所以<code>ourArray</code>最终没有添加任何内容，因此示例中的所有代码执行完时，<code>ourArray</code>仍然是<code>[]</code>。
现在，看一下<code>do...while</code>循环。
```js
var ourArray = [];
var i = 5;
do {
ourArray.push(i);
i++;
} 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>
## Instructions
<section id="instructions">将代码中的<code>while</code>循环更改为<code>do...while</code>循环，以便循环将数字10推送到<code>myArray</code> ，当代码完成运行时， <code>i</code>将等于<code>11</code> 。 </section>
<section id='instructions'>
将代码中的<code>while</code>循环更改为<code>do...while</code>循环，实现数字 10 添加到<code>myArray</code>中，代码执行完时，<code>i</code>等于<code>11</code>。
</section>
## Tests
<section id='tests'>
@ -19,11 +61,10 @@ localeTitle: 使用JavaScript迭代...循环
tests:
- text: 你应该使用<code>do...while</code>循环。
testString: assert(code.match(/do/g));
- text: '<code>myArray</code>应该等于<code>[10]</code> 。'
- text: <code>myArray</code>应该等于<code>[10]</code>。
testString: assert.deepEqual(myArray, [10]);
- text: <code>i</code>应该等于<code>11</code>
testString: assert.equal(i, 11);
- text: <code>i</code>应该等于<code>11</code>。
testString: assert.deepEqual(i, 11);
```
</section>
@ -38,13 +79,11 @@ tests:
var myArray = [];
var i = 10;
// Only change code below this line.
// Only change code below this line
while (i < 5) {
myArray.push(i);
i++;
}
```
</div>
@ -54,7 +93,7 @@ while (i < 5) {
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
```
</div>
@ -64,7 +103,14 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [];
var i = 10;
do {
myArray.push(i);
i++;
} while (i < 5)
```
</section>

47
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-for-loops.chinese.md
View File

@ -2,24 +2,45 @@
id: cf1111c1c11feddfaeb5bdef
title: Iterate with JavaScript For Loops
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript迭代循环
videoUrl: 'https://scrimba.com/c/c9yNVCe'
forumTopicId: 18219
localeTitle: for 循环
---
## Description
<section id="description">您可以使用循环多次运行相同的代码。最常见的JavaScript循环类型称为“ <code>for loop</code> ”，因为它“运行”特定次数。 For循环用三个可选表达式声明，用分号分隔： <code>for ([initialization]; [condition]; [final-expression])</code> <code>initialization</code>语句仅在循环开始之前执行一次。它通常用于定义和设置循环变量。 <code>condition</code>语句在每次循环迭代开始时进行计算，并且只要计算结果为<code>true</code>就会继续。当迭代开始时<code>condition</code>为<code>false</code>时，循环将停止执行。这意味着如果<code>condition</code>以<code>false</code>开头，则循环将永远不会执行。 <code>final-expression</code>在每次循环迭代结束时执行，在下一次<code>condition</code>检查之前执行，通常用于递增或递减循环计数器。在下面的示例中，我们使用<code>i = 0</code>初始化并迭代，而条件<code>i &lt; 5</code>为真。我们将在每个循环迭代中将<code>i</code>递增<code>1</code> ，并使用<code>i++</code>作为<code>final-expression</code> 。 <blockquote> var ourArray = []; <br> for（var i = 0; i &lt;5; i ++）{ <br> ourArray.push（ⅰ）; <br> } </blockquote> <code>ourArray</code>现在包含<code>[0,1,2,3,4]</code> 。 </section>
<section id='description'>
你可以使用循环多次执行相同的代码。
JavaScript 中最常见的循环就是 “<code>for循环</code>”。
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>的值，条件判断，就这样依次执行下去，直到条件判断为假，整个循环结束。
```js
var ourArray = [];
for (var i = 0; i < 5; i++) {
ourArray.push(i);
}
```
最终<code>ourArray</code>的值为<code>[0,1,2,3,4]</code>.
</section>
## Instructions
<section id="instructions">使用<code>for</code>循环将值1到5推送到<code>myArray</code> 。 </section>
<section id='instructions'>
使用<code>for</code>循环把从 1 到 5 添加进<code>myArray</code>中。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 你应该为此使用<code>for</code>循环。
- text: 你应该使用<code>for</code>循环。
testString: assert(code.match(/for\s*\(/g).length > 1);
- text: '<code>myArray</code>应该等于<code>[1,2,3,4,5]</code> 。'
- text: <code>myArray</code>应该等于<code>[1,2,3,4,5]</code>。
testString: assert.deepEqual(myArray, [1,2,3,4,5]);
```
@ -44,6 +65,7 @@ var myArray = [];
// Only change code below this line.
```
</div>
@ -53,7 +75,7 @@ var myArray = [];
<div id='js-teardown'>
```js
console.info('after the test');
if (typeof myArray !== "undefined"){(function(){return myArray;})();}
```
</div>
@ -63,7 +85,16 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
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>

43
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/iterate-with-javascript-while-loops.chinese.md
View File

@ -2,15 +2,34 @@
id: cf1111c1c11feddfaeb1bdef
title: Iterate with JavaScript While Loops
challengeType: 1
videoUrl: ''
localeTitle: 在循环时使用JavaScript进行迭代
videoUrl: 'https://scrimba.com/c/c8QbnCM'
forumTopicId: 18220
localeTitle: while 循环
---
## Description
<section id="description">您可以使用循环多次运行相同的代码。我们将学习的第一种类型的循环称为“ <code>while</code> ”循环，因为它在“while”运行时指定的条件为true，并且一旦该条件不再为真就停止。 <blockquote> var ourArray = []; <br> var i = 0; <br>而（i &lt;5）{ <br> ourArray.push（ⅰ）; <br>我++; <br> } </blockquote>让我们尝试通过将值推送到数组来实现while循环。 </section>
<section id='description'>
你可以使用循环多次执行相同的代码。
我们将学习的第一种类型的循环称为 "<code>while</code>" 循环，因为它规定，当 "while" 条件为真，循环才会执行，反之不执行。
```js
var ourArray = [];
var i = 0;
while(i < 5) {
ourArray.push(i);
i++;
}
```
在上面的代码里，<code>while</code> 循环执行 5 次把 0 到 4 的数字添加到 <code>ourArray</code> 数组里。
让我们通过 while 循环将值添加到数组中。
</section>
## Instructions
<section id="instructions">使用<code>while</code>循环将数字0到4推送到<code>myArray</code> 。 </section>
<section id='instructions'>
通过一个<code>while</code>循环，把从 0 到 4 的值添加到<code>myArray</code>中。
</section>
## Tests
<section id='tests'>
@ -19,8 +38,8 @@ localeTitle: 在循环时使用JavaScript进行迭代
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, [5,4,3,2,1,0]);
- text: <code>myArray</code>应该等于<code>[0,1,2,3,4]</code>。
testString: assert.deepEqual(myArray, [0,1,2,3,4]);
```
@ -37,6 +56,7 @@ var myArray = [];
// Only change code below this line.
```
</div>
@ -46,7 +66,7 @@ var myArray = [];
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
```
</div>
@ -56,7 +76,14 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [];
var i = 5;
while(i >= 0) {
myArray.push(i);
i--;
}
```
</section>

46
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/local-scope-and-functions.chinese.md
View File

@ -2,25 +2,44 @@
id: 56533eb9ac21ba0edf2244bf
title: Local Scope and Functions
challengeType: 1
videoUrl: ''
localeTitle: 本地范围和功能
videoUrl: 'https://scrimba.com/c/cd62NhM'
forumTopicId: 18227
localeTitle: 局部作用域和函数
---
## Description
<section id="description">在函数内声明的变量，以及函数参数都具有<dfn>局部</dfn>范围。这意味着，它们仅在该功能中可见。这是一个函数<code>myTest</code>带有一个名为<code>loc</code>的局部变量。 <blockquote> function myTest（）{ <br> var loc =“foo”; <br>的console.log（LOC）; <br> } <br> MYTEST（）; //记录“foo” <br>的console.log（LOC）; // loc未定义</blockquote> <code>loc</code>未在函数外定义。 </section>
<section id='description'>
在一个函数内声明的变量，以及该函数的参数都是局部变量，意味着它们只在该函数内可见。
这是在函数<code>myTest</code>内声明局部变量<code>loc</code>的例子：
```js
function myTest() {
var loc = "foo";
console.log(loc);
}
myTest(); // logs "foo"
console.log(loc); // loc is not defined
```
在函数外，<code>loc</code>是未定义的。
</section>
## Instructions
<section id="instructions">在<code>myLocalScope</code>声明一个局部变量<code>myVar</code> 。运行测试，然后按照编辑器中注释的说明进行操作。 <strong>暗示</strong> <br>如果您遇到问题，刷新页面可能会有所帮助。 </section>
<section id='instructions'>
在函数<code>myFunction</code>内部声明一个局部变量<code>myVar</code>，并删除外部的 console.log。
<strong>提示：</strong><br>如果你遇到了问题，可以先尝试刷新页面。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 没有全局<code>myVar</code>变量
- text: 未找到全局的<code>myVar</code>变量。
testString: assert(typeof myVar === 'undefined');
- text: 添加本地<code>myVar</code>变量
testString: assert(/function\s+myLocalScope\s*\(\s*\)\s*\{\s[\s\S]+\s*var\s*myVar\s*(\s*|=[\s\S]+)\s*;[\s\S]+}/.test(code));
- text: 需要定义局部的<code>myVar</code>变量。
testString: assert(/var\s+myVar/.test(code));
```
@ -80,7 +99,8 @@ function uncapture() {
<div id='js-teardown'>
```js
console.info('after the test');
typeof myLocalScope === 'function' && (capture(), myLocalScope(), uncapture());
(function() { return logOutput || "console.log never called"; })();
```
</div>
@ -90,7 +110,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
function myLocalScope() {
'use strict';
var myVar;
console.log(myVar);
}
myLocalScope();
```
</section>

69
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/logical-order-in-if-else-statements.chinese.md
View File

@ -2,26 +2,68 @@
id: 5690307fddb111c6084545d7
title: Logical Order in If Else Statements
challengeType: 1
videoUrl: ''
localeTitle: 如果其他陈述中的逻辑顺序
videoUrl: 'https://scrimba.com/c/cwNvMUV'
forumTopicId: 18228
localeTitle: if else 语句中的逻辑顺序
---
## Description
<section id="description">订单在<code>if</code> ， <code>else if</code>语句中很重要。该函数从上到下执行，因此您需要注意首先出现的语句。以这两个函数为例。这是第一个： <blockquote> function foo（x）{ <br> if（x &lt;1）{ <br>返回“少于一个”; <br> } else if（x &lt;2）{ <br>返回“少于两个”; <br> } else { <br>返回“大于或等于2”; <br> } <br> } </blockquote>第二个只是切换语句的顺序： <blockquote>功能栏（x）{ <br> if（x &lt;2）{ <br>返回“少于两个”; <br> } else if（x &lt;1）{ <br>返回“少于一个”; <br> } else { <br>返回“大于或等于2”; <br> } <br> } </blockquote>虽然如果我们将数字传递给两者，这两个函数看起来几乎相同但我们得到不同的输出。 <blockquote> foo（0）//“不到一个” <br> bar（0）//“少于两个” </blockquote></section>
<section id='description'>
<code>if</code>、<code>else if</code>语句中代码的执行顺序是很重要的。
在条件判断语句中，代码的执行顺序是从上到下，所以你需要考虑清楚先执行哪一句，后执行哪一句。
这有两个例子。
第一个例子：
```js
function foo(x) {
if (x < 1) {
return "Less than one";
} else if (x < 2) {
return "Less than two";
} else {
return "Greater than or equal to two";
}
}
```
第二个例子更改了代码的执行顺序：
```js
function bar(x) {
if (x < 2) {
return "Less than two";
} else if (x < 1) {
return "Less than one";
} else {
return "Greater than or equal to two";
}
}
```
这两个函数看起来几乎一模一样，我们传一个值进去看看它们有什么区别。
```js
foo(0) // "Less than one"
bar(0) // "Less than two"
```
</section>
## Instructions
<section id="instructions">更改函数中的逻辑顺序，以便在所有情况下都返回正确的语句。 </section>
<section id='instructions'>
更改函数的逻辑顺序以便通过所有的测试用例。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>orderMyLogic(4)</code>应返回“小于5”
- text: <code>orderMyLogic(4)</code>应该返回 "Less than 5"。
testString: assert(orderMyLogic(4) === "Less than 5");
- text: <code>orderMyLogic(6)</code>应该返回“少于10”
- text: <code>orderMyLogic(6)</code>应该返回 "Less than 10"。
testString: assert(orderMyLogic(6) === "Less than 10");
- text: <code>orderMyLogic(11)</code>应该返回“大于或等于10”
- text: <code>orderMyLogic(11)</code>应该返回 "Greater than or equal to 10"。
testString: assert(orderMyLogic(11) === "Greater than or equal to 10");
```
@ -46,7 +88,6 @@ function orderMyLogic(val) {
// Change this value to test
orderMyLogic(7);
```
</div>
@ -58,7 +99,17 @@ orderMyLogic(7);
## Solution
<section id='solution'>
```js
// solution required
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";
}
}
```
</section>

37
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-pop.chinese.md
View File

@ -2,26 +2,41 @@
id: 56bbb991ad1ed5201cd392cc
title: Manipulate Arrays With pop()
challengeType: 1
videoUrl: ''
localeTitle: 使用pop（）操作数组
videoUrl: 'https://scrimba.com/c/cRbVZAB'
forumTopicId: 18236
localeTitle: 使用 pop() 操作数组
---
## Description
<section id="description">更改数组中数据的另一种方法是使用<code>.pop()</code>函数。 <code>.pop()</code>用于“弹出”数组末尾的值。我们可以通过将其赋值给变量来存储这个“弹出”值。换句话说， <code>.pop()</code>从数组中删除最后一个元素并返回该元素。任何类型的条目都可以从数组“弹出” - 数字，字符串，甚至嵌套数组。 <blockquote> <code>var threeArr = [1, 4, 6]; <br> var oneDown = threeArr.pop(); <br> console.log(oneDown); // Returns 6 <br> console.log(threeArr); // Returns [1, 4]</code> </blockquote> </section>
<section id='description'>
改变数组中数据的另一种方法是用<code>.pop()</code>函数。
<code>.pop()</code>函数用来“抛出”一个数组末尾的值。我们可以把这个“抛出”的值赋给一个变量存储起来。换句话说就是<code>.pop()</code>函数移除数组末尾的元素并返回这个元素。
数组中任何类型的元素（数值，字符串，甚至是数组）可以被“抛出来” 。
```js
var threeArr = [1, 4, 6];
var oneDown = threeArr.pop();
console.log(oneDown); // Returns 6
console.log(threeArr); // Returns [1, 4]
```
</section>
## Instructions
<section id="instructions">使用<code>.pop()</code>函数从<code>myArray</code>删除最后一项，将“弹出”值分配给<code>removedFromMyArray</code> 。 </section>
<section id='instructions'>
使用<code>.pop()</code>函数移除<code>myArray</code>中的最后一个元素，并且把“抛出”的值赋给<code>removedFromMyArray</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>myArray</code>应该只包含<code>[[&quot;John&quot;, 23]]</code> 。'
- 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>
- 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>[&quot;cat&quot;, 2]</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));
```
@ -45,6 +60,7 @@ var myArray = [["John", 23], ["cat", 2]];
// Only change code below this line.
var removedFromMyArray;
```
</div>
@ -54,7 +70,7 @@ var removedFromMyArray;
<div id='js-teardown'>
```js
console.info('after the test');
(function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
```
</div>
@ -64,7 +80,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [["John", 23], ["cat", 2]];
var removedFromMyArray = myArray.pop();
```
</section>

31
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-push.chinese.md
View File

@ -2,22 +2,35 @@
id: 56bbb991ad1ed5201cd392cb
title: Manipulate Arrays With push()
challengeType: 1
videoUrl: ''
localeTitle: 用push（）操纵数组
videoUrl: 'https://scrimba.com/c/cnqmVtJ'
forumTopicId: 18237
localeTitle: 使用 push() 操作数组
---
## Description
<section id="description">将数据附加到数组末尾的简单方法是通过<code>push()</code>函数。 <code>.push()</code>接受一个或多个<dfn>参数</dfn>并将它们“推”到数组的末尾。 <blockquote> var arr = [1,2,3]; <br> arr.push（4）; <br> // arr现在是[1,2,3,4] </blockquote></section>
<section id='description'>
一个简单的方法将数据添加到一个数组的末尾是通过<code>push()</code>函数。
<code>.push()</code>接受一个或多个参数，并把它“推”入到数组的末尾。
```js
var arr = [1,2,3];
arr.push(4);
// arr is now [1,2,3,4]
```
</section>
## Instructions
<section id="instructions">将<code>[&quot;dog&quot;, 3]</code>推到<code>myArray</code>变量的末尾。 </section>
<section id='instructions'>
把<code>["dog", 3]</code>“推”入到<code>myArray</code>变量的末尾。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>myArray</code>现在应该等于<code>[[&quot;John&quot;, 23], [&quot;cat&quot;, 2], [&quot;dog&quot;, 3]]</code> 。'
- 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));
```
@ -40,6 +53,7 @@ var myArray = [["John", 23], ["cat", 2]];
// Only change code below this line.
```
</div>
@ -49,7 +63,7 @@ var myArray = [["John", 23], ["cat", 2]];
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return 'myArray = ' + JSON.stringify(z);})(myArray);
```
</div>
@ -59,7 +73,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [["John", 23], ["cat", 2]];
myArray.push(["dog",3]);
```
</section>

28
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-shift.chinese.md
View File

@ -2,24 +2,30 @@
id: 56bbb991ad1ed5201cd392cd
title: Manipulate Arrays With shift()
challengeType: 1
videoUrl: ''
localeTitle: 使用shift（）操纵数组
videoUrl: 'https://scrimba.com/c/cRbVETW'
forumTopicId: 18238
localeTitle: 使用 shift() 操作数组
---
## Description
<section id="description"> <code>pop()</code>总是删除数组的最后一个元素。如果你想删除第一个怎么办？这就是<code>.shift()</code>用武之地。它就像<code>.pop()</code>一样工作，除了它删除了第一个元素而不是最后一个元素。 </section>
<section id='description'>
<code>pop()</code>函数用来移出数组中最后一个元素。如果想要移出第一个元素要怎么办呢？
这就是<code>.shift()</code>的用武之地。它的工作原理就像<code>.pop()</code>，但它移除的是第一个元素，而不是最后一个。
</section>
## Instructions
<section id="instructions">使用<code>.shift()</code>函数从<code>myArray</code>删除第一项，将“shift off”值分配给<code>removedFromMyArray</code> 。 </section>
<section id='instructions'>
使用<code>.shift()</code>函数移出<code>myArray</code>中的第一项，并把“移出”的值赋给<code>removedFromMyArray</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>myArray</code>现在应该等于<code>[[&quot;dog&quot;, 3]]</code> 。'
- 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>[&quot;John&quot;, 23]</code> 。'
- 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));
```
@ -43,6 +49,7 @@ var myArray = [["John", 23], ["dog", 3]];
// Only change code below this line.
var removedFromMyArray;
```
</div>
@ -52,7 +59,7 @@ var removedFromMyArray;
<div id='js-teardown'>
```js
console.info('after the test');
(function(y, z){return 'myArray = ' + JSON.stringify(y) + ' & removedFromMyArray = ' + JSON.stringify(z);})(myArray, removedFromMyArray);
```
</div>
@ -62,7 +69,12 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [["John", 23], ["dog", 3]];
// Only change code below this line.
var removedFromMyArray = myArray.shift();
```
</section>

25
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/manipulate-arrays-with-unshift.chinese.md
View File

@ -2,22 +2,28 @@
id: 56bbb991ad1ed5201cd392ce
title: Manipulate Arrays With unshift()
challengeType: 1
videoUrl: ''
localeTitle: 使用unshift操作数组（）
videoUrl: 'https://scrimba.com/c/ckNDESv'
forumTopicId: 18239
localeTitle: 使用 unshift() 操作数组
---
## Description
<section id="description">不仅可以<code>shift</code>元件关闭的阵列的开头的，也可以<code>unshift</code>元素添加到数组的开始，即在阵列的前添加元素。 <code>.unshift()</code>工作方式与<code>.push()</code>完全相同，但是不是在数组的末尾添加元素， <code>unshift()</code>会在数组的开头添加元素。 </section>
<section id='description'>
你不仅可以<code>shift</code>（移出）数组中的第一个元素，你也可以<code>unshift</code>（移入）一个元素到数组的头部。
<code>.unshift()</code>函数用起来就像<code>.push()</code>函数一样, 但不是在数组的末尾添加元素，而是在数组的头部添加元素。
</section>
## Instructions
<section id="instructions">使用<code>unshift()</code>将<code>[&quot;Paul&quot;,35]</code>添加到<code>myArray</code>变量的开头。 </section>
<section id='instructions'>
使用<code>unshift()</code>函数把<code>["Paul",35]</code>加入到<code>myArray</code>的头部。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>myArray</code>现在应该有[[“Paul”，35]，[“dog”，3]]。'
- 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));
```
@ -42,6 +48,7 @@ myArray.shift();
// Only change code below this line.
```
</div>
@ -51,7 +58,7 @@ myArray.shift();
<div id='js-teardown'>
```js
console.info('after the test');
(function(y, z){return 'myArray = ' + JSON.stringify(y);})(myArray);
```
</div>
@ -61,7 +68,11 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [["John", 23], ["dog", 3]];
myArray.shift();
myArray.unshift(["Paul", 35]);
```
</section>

96
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects.chinese.md
View File

@ -2,38 +2,80 @@
id: 56533eb9ac21ba0edf2244cb
title: Manipulating Complex Objects
challengeType: 1
videoUrl: ''
localeTitle: 操纵复杂对象
videoUrl: 'https://scrimba.com/c/c9yNMfR'
forumTopicId: 18208
localeTitle: 操作复杂对象
---
## Description
<section id="description">有时您可能希望将数据存储在灵活的<dfn>数据结构中</dfn> 。 JavaScript对象是处理灵活数据的一种方法。它们允许<dfn>字符串</dfn> ， <dfn>数字</dfn> ， <dfn>布尔值</dfn> ， <dfn>数组</dfn> ， <dfn>函数</dfn>和<dfn>对象的</dfn>任意组合。这是一个复杂数据结构的示例： <blockquote> var ourMusic = [ <br> { <br> “艺术家”：“Daft Punk”， <br> “标题”：“家庭作业”， <br> “release_year”：1997年， <br> “格式”：[ <br> “光盘”， <br> “盒式” <br> “LP” <br> ] <br> “黄金”：是的<br> } <br> ]。 </blockquote>这是一个包含一个对象的数组。该对象具有关于专辑的各种<dfn>元数据</dfn> 。它还有一个嵌套的<code>&quot;formats&quot;</code>数组。如果要添加更多专辑记录，可以通过向顶级数组添加记录来完成此操作。对象将数据保存在属性中，该属性具有键值格式。在上面的示例中， <code>&quot;artist&quot;: &quot;Daft Punk&quot;</code>是具有<code>&quot;artist&quot;</code>键和<code>&quot;Daft Punk&quot;</code>值的属性。 <a href="http://www.json.org/" target="_blank">JavaScript Object Notation</a>或<code>JSON</code>是用于存储数据的相关数据交换格式。 <blockquote> { <br> “艺术家”：“Daft Punk”， <br> “标题”：“家庭作业”， <br> “release_year”：1997年， <br> “格式”：[ <br> “光盘”， <br> “盒式” <br> “LP” <br> ] <br> “黄金”：是的<br> } </blockquote> <strong>注意</strong> <br>除非它是数组中的最后一个对象，否则您需要在数组中的每个对象后面放置一个逗号。 </section>
<section id='description'>
有时你可能希望将数据存储在灵活的<dfn>数据结构</dfn>中。JavaScript 对象是处理灵活数据的一种方法。它可以储存<dfn>字符串</dfn>，<dfn>数字</dfn>，<dfn>布尔值</dfn>，<dfn>函数</dfn>，和<dfn>对象</dfn>以及这些值的任意组合。
这是一个复杂数据结构的示例：
```js
var ourMusic = [
{
"artist": "Daft Punk",
"title": "Homework",
"release_year": 1997,
"formats": [
"CD",
"Cassette",
"LP"
],
"gold": true
}
];
```
这是一个对象数组，并且对象有各种关于专辑的 <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>是用于存储数据的相关数据交换格式。
```json
{
"artist": "Daft Punk",
"title": "Homework",
"release_year": 1997,
"formats": [
"CD",
"Cassette",
"LP"
],
"gold": true
}
```
<strong>提示</strong><br>数组中有多个 JSON 对象的时候，对象与对象之间要用逗号隔开。
</section>
## Instructions
<section id="instructions">将新相册添加到<code>myMusic</code>阵列。添加<code>artist</code>和<code>title</code>字符串， <code>release_year</code>数字和<code>formats</code>字符串数组。 </section>
<section id='instructions'>
添加一个新专辑到<code>myMusic</code>的JSON对象。添加<code>artist</code>和<code>title</code>字符串，<code>release_year</code>数字和<code>formats</code>字符串数组。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myMusic</code>应该是一个数组
- text: <code>myMusic</code>应该是一个数组。
testString: assert(Array.isArray(myMusic));
- text: <code>myMusic</code>应该至少有两个元素
- text: <code>myMusic</code>应该至少包含两个元素。
testString: assert(myMusic.length > 1);
- text: '<code>myMusic[1]</code>应该是一个对象'
- text: <code>myMusic[1]</code>应该是一个对象。
testString: assert(typeof myMusic[1] === 'object');
- text: '<code>myMusic[1]</code>应该至少有4个属性'
- text: <code>myMusic[1]</code>至少要包含四个属性。
testString: assert(Object.keys(myMusic[1]).length > 3);
- text: '<code>myMusic[1]</code>应该包含一个<code>artist</code>属性，它是一个字符串'
- 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>属性，它是一个字符串'
- 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>属性，它是一个数字'
- 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>属性，它是一个数组'
- text: <code>myMusic[1]</code>应该包含一个类型为数组的<code>formats</code>属性。
testString: assert(myMusic[1].hasOwnProperty('formats') && Array.isArray(myMusic[1].formats));
- text: <code>formats</code>应该是一个至少包含两个元素的字符串数组
- text: <code>formats</code>应该是一个至少包含两个字符串元素的数组。
testString: assert(myMusic[1].formats.every(function(item) { return (typeof item === "string")}) && myMusic[1].formats.length > 1);
```
@ -70,7 +112,7 @@ var myMusic = [
<div id='js-teardown'>
```js
console.info('after the test');
(function(x){ if (Array.isArray(x)) { return JSON.stringify(x); } return "myMusic is not an array"})(myMusic);
```
</div>
@ -80,7 +122,31 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
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",
]
}
];
```
</section>

33
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/modify-array-data-with-indexes.chinese.md
View File

@ -2,24 +2,37 @@
id: cf1111c1c11feddfaeb8bdef
title: Modify Array Data With Indexes
challengeType: 1
videoUrl: ''
localeTitle: 使用索引修改数组数据
videoUrl: 'https://scrimba.com/c/czQM4A8'
forumTopicId: 18241
localeTitle: 通过索引修改数组中的数据
---
## Description
<section id="description">与字符串不同，数组的条目是<dfn>可变的</dfn> ，可以自由更改。 <strong>例</strong> <blockquote> var ourArray = [50,40,30]; <br> ourArray [0] = 15; //等于[15,40,30] </blockquote> <strong>注意</strong> <br>数组名称和方括号之间不应有任何空格，如<code>array [0]</code> 。尽管JavaScript能够正确处理，但这可能会让其他程序员在阅读代码时感到困惑。 </section>
<section id='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>
## Instructions
<section id="instructions">将存储在<code>myArray</code>索引<code>0</code>处的数据修改为值<code>45</code> 。 </section>
<section id='instructions'>
修改数组<code>myArray</code>中索引0上的值为<code>45</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>myArray</code>现在应该是[45,64,99]。'
- 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>的值。
- text: 你应该使用正确的索引修改<code>myArray</code>的值。
testString: assert((function(){if(code.match(/myArray\[0\]\s*=\s*/g)){return true;}else{return false;}})());
```
@ -41,6 +54,7 @@ var myArray = [18,64,99];
// Only change code below this line.
```
</div>
@ -50,7 +64,7 @@ var myArray = [18,64,99];
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
```
</div>
@ -60,7 +74,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [18,64,99];
myArray[0] = 45;
```
</section>

75
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/multiple-identical-options-in-switch-statements.chinese.md
View File

@ -2,42 +2,62 @@
id: 56533eb9ac21ba0edf2244df
title: Multiple Identical Options in Switch Statements
challengeType: 1
videoUrl: ''
localeTitle: 交换机语句中的多个相同选项
videoUrl: 'https://scrimba.com/c/cdBKWCV'
forumTopicId: 18242
localeTitle: 在 Switch 语句添加多个相同选项
---
## Description
<section id="description">如果从<code>switch</code>语句的<code>case</code>省略了<code>break</code>语句，则会执行以下<code>case</code>语句，直到遇到<code>break</code> 。如果您有多个具有相同输出的输入，则可以在<code>switch</code>语句中表示它们，如下所示： <blockquote> switch（val）{ <br>情况1： <br>案例2： <br>案例3： <br> result =“1,2或3”; <br>打破; <br>案例4： <br> result =“4 alone”; <br> } </blockquote> 1,2和3的情况都会产生相同的结果。 </section>
<section id='description'>
如果你忘了给<code>switch</code>的每一条<code>case</code>添加<code>break</code>，那么直到遇见<code>break</code>为止，后续的<code>case</code>会一直执行。如果你想为多个不同的输入设置相同的结果，可以这样写：
```js
switch(val) {
case 1:
case 2:
case 3:
result = "1, 2, or 3";
break;
case 4:
result = "4 alone";
}
```
这样，1、2、3 都会有相同的结果。
</section>
## Instructions
<section id="instructions">写一个switch语句来设置以下范围的<code>answer</code> ： <br> <code>1-3</code> - “低” <br> <code>4-6</code> - “中” <br> <code>7-9</code> - “高” <strong>注</strong> <br>您需要为范围中的每个数字都有一个<code>case</code>语句。 </section>
<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>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>sequentialSizes(1)</code>应返回“Low”
- text: <code>sequentialSizes(1)</code>应该返回 "Low"。
testString: assert(sequentialSizes(1) === "Low");
- text: <code>sequentialSizes(2)</code>应该返回“Low”
- text: <code>sequentialSizes(2)</code>应该返回 "Low"。
testString: assert(sequentialSizes(2) === "Low");
- text: <code>sequentialSizes(3)</code>应返回“Low”
- text: <code>sequentialSizes(3)</code>应该返回 "Low"。
testString: assert(sequentialSizes(3) === "Low");
- text: <code>sequentialSizes(4)</code>应返回“Mid”
- text: <code>sequentialSizes(4)</code>应该返回 "Mid"。
testString: assert(sequentialSizes(4) === "Mid");
- text: <code>sequentialSizes(5)</code>应返回“Mid”
- text: <code>sequentialSizes(5)</code>应该返回 "Mid"。
testString: assert(sequentialSizes(5) === "Mid");
- text: <code>sequentialSizes(6)</code>应返回“Mid”
- text: <code>sequentialSizes(6)</code>应该返回 "Mid"。
testString: assert(sequentialSizes(6) === "Mid");
- text: <code>sequentialSizes(7)</code>应该返回“High”
- text: <code>sequentialSizes(7)</code>应该返回 "High"。
testString: assert(sequentialSizes(7) === "High");
- text: <code>sequentialSizes(8)</code>应该返回“High”
- text: <code>sequentialSizes(8)</code>应该返回 "High"。
testString: assert(sequentialSizes(8) === "High");
- text: <code>sequentialSizes(9)</code>应该返回“High”
- text: <code>sequentialSizes(9)</code>应该返回 "High"。
testString: assert(sequentialSizes(9) === "High");
- text: 您不应该使用任何<code>if</code>或<code>else</code>语句
- text: 你不应使用<code>if</code>或<code>else</code>语句。
testString: assert(!/else/g.test(code) || !/if/g.test(code));
- text: 你应该有九个<code>case</code>陈述
- text: 你应该编写 9 个<code>case</code>语句。
testString: assert(code.match(/case/g).length === 9);
```
@ -74,7 +94,30 @@ sequentialSizes(1);
## Solution
<section id='solution'>
```js
// solution required
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;
}
```
</section>

25
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-decimals-with-javascript.chinese.md
View File

@ -2,24 +2,30 @@
id: bd7993c9c69feddfaeb7bdef
title: Multiply Two Decimals with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript乘以两个小数
videoUrl: 'https://scrimba.com/c/ce2GeHq'
forumTopicId: 301173
localeTitle: 两个小数相乘
---
## Description
<section id="description">在JavaScript中，您也可以使用十进制数执行计算，就像整数一样。让我们将两位小数相乘得到它们的乘积。 </section>
<section id='description'>
在 JavaScript 中，你也可以用小数进行计算，就像整数一样。
把两个小数相乘，并得到它们乘积。
</section>
## Instructions
<section id="instructions">更改<code>0.0</code>使产品等于<code>5.0</code> 。 </section>
<section id='instructions'>
改变<code>0.0</code>的数值让变量<code>product</code>的值等于<code>5.0</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 变量<code>product</code>应该等于<code>5.0</code> 。
- text: 变量<code>product</code>应该等于<code>5.0</code>。
testString: assert(product === 5.0);
- text: 你应该使用<code>*</code>运算符
- text: 要使用<code>*</code>运算符。
testString: assert(/\*/.test(code));
```
@ -34,6 +40,7 @@ tests:
```js
var product = 2.0 * 0.0;
```
</div>
@ -43,7 +50,7 @@ var product = 2.0 * 0.0;
<div id='js-teardown'>
```js
console.info('after the test');
(function(y){return 'product = '+y;})(product);
```
</div>
@ -53,7 +60,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var product = 2.0 * 2.5;
```
</section>

33
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/multiply-two-numbers-with-javascript.chinese.md
View File

@ -2,24 +2,38 @@
id: cf1231c1c11feddfaeb5bdef
title: Multiply Two Numbers with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript将两个数字相乘
videoUrl: 'https://scrimba.com/c/cP3y3Aq'
forumTopicId: 18243
localeTitle: 乘法运算
---
## Description
<section id="description">我们也可以将一个数字乘以另一个数字。 JavaScript使用<code>*</code>符号来乘以两个数字。 <p> <strong>例</strong> </p><blockquote> myVar = 13 * 13; //指定169 </blockquote></section>
<section id='description'>
我们也可在 JavaScript 中使用乘法运算。
JavaScript 使用<code>*</code>符号表示两数相乘。
<strong>示例</strong>
```js
myVar = 13 * 13; // assigned 169
```
</section>
## Instructions
<section id="instructions">更改<code>0</code>使产品等于<code>80</code> 。 </section>
<section id='instructions'>
改变数值<code>0</code>来让变量 product 的值等于<code>80</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 使变量<code>product</code>等于80
- text: 要使<code>product</code>的值等于 80。
testString: assert(product === 80);
- text: 使用<code>*</code>运算符
- text: 使用<code>*</code>运算符。
testString: assert(/\*/.test(code));
```
@ -34,6 +48,7 @@ tests:
```js
var product = 8 * 0;
```
</div>
@ -43,7 +58,7 @@ var product = 8 * 0;
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return 'product = '+z;})(product);
```
</div>
@ -53,7 +68,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var product = 8 * 10;
```
</section>

21
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/nest-one-array-within-another-array.chinese.md
View File

@ -2,22 +2,27 @@
id: cf1111c1c11feddfaeb7bdef
title: Nest one Array within Another Array
challengeType: 1
videoUrl: ''
localeTitle: 将一个Array嵌套在另一个Array中
videoUrl: 'https://scrimba.com/c/crZQZf8'
forumTopicId: 18247
localeTitle: 将一个数组嵌套在另一个数组中
---
## Description
<section id="description">您还可以在其他数组中嵌套数组，如： <code>[[&quot;Bulls&quot;, 23], [&quot;White Sox&quot;, 45]]</code> 。这也称为<dfn>多维数组<dfn>。</dfn></dfn> </section>
<section id='description'>
你也可以在数组中包含其他数组，例如：<code>[["Bulls", 23], ["White Sox", 45]]</code>。这被称为一个<dfn>多维数组<dfn>。
</section>
## Instructions
<section id="instructions">创建一个名为<code>myArray</code>的嵌套数组。 </section>
<section id='instructions'>
创建一个名为<code>myArray</code>的多维数组。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myArray</code>应至少有一个嵌套在另一个数组中的数组。
- text: 应该包含至少一个嵌入的数组。
testString: assert(Array.isArray(myArray) && myArray.some(Array.isArray));
```
@ -45,7 +50,7 @@ var myArray = [];
<div id='js-teardown'>
```js
console.info('after the test');
if(typeof myArray !== "undefined"){(function(){return myArray;})();}
```
</div>
@ -55,7 +60,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = [[1,2,3]];
```
</section>

46
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/nesting-for-loops.chinese.md
View File

@ -2,26 +2,44 @@
id: 56533eb9ac21ba0edf2244e1
title: Nesting For Loops
challengeType: 1
videoUrl: ''
localeTitle: 嵌套循环
videoUrl: 'https://scrimba.com/c/cRn6GHM'
forumTopicId: 18248
localeTitle: 循环嵌套
---
## Description
<section id="description">如果您有一个多维数组，则可以使用与先前路点相同的逻辑来遍历数组和任何子数组。这是一个例子： <blockquote> var arr = [ <br> [1,2]，[3,4]，[5,6] <br> ]。 <br> for（var i = 0; i &lt;arr.length; i ++）{ <br> for（var j = 0; j &lt;arr [i] .length; j ++）{ <br>的console.log（ARR [i] [j]）; <br> } <br> } </blockquote>这个输出在每个子元件<code>arr</code>一次一个。注意，对于内部循环，我们检查<code>arr[i]</code>的<code>.length</code> ，因为<code>arr[i]</code>本身就是一个数组。 </section>
<section id='description'>
如果你有一个二维数组，可以使用相同的逻辑，先遍历外面的数组，再遍历里面的子数组。下面是一个例子：
```js
var arr = [
[1,2], [3,4], [5,6]
];
for (var i=0; i < arr.length; i++) {
for (var j=0; j < arr[i].length; j++) {
console.log(arr[i][j]);
}
}
```
一次输出<code>arr</code>中的每个子元素。提示，对于内部循环，我们可以通过<code>arr[i]</code>的<code>.length</code>来获得子数组的长度，因为<code>arr[i]</code>的本身就是一个数组。
</section>
## Instructions
<section id="instructions">修改函数<code>multiplyAll</code> ，使其乘以<code>product</code>变量乘以<code>arr</code>的子数组中的每个数字</section>
<section id='instructions'>
修改函数<code>multiplyAll</code>，获得<code>arr</code>内部数组的每个数字相乘的结果<code>product</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>multiplyAll([[1],[2],[3]])</code>应该返回<code>6</code>'
- 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>'
- 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>'
- 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);
```
@ -56,7 +74,19 @@ multiplyAll([[1,2],[3,4],[5,6,7]]);
## Solution
<section id='solution'>
```js
// solution required
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]]);
```
</section>

51
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/passing-values-to-functions-with-arguments.chinese.md
View File

@ -2,29 +2,45 @@
id: 56533eb9ac21ba0edf2244bd
title: Passing Values to Functions with Arguments
challengeType: 1
videoUrl: ''
localeTitle: 将值传递给带参数的函数
videoUrl: 'https://scrimba.com/c/cy8rahW'
forumTopicId: 18254
localeTitle: 将值传递给带有参数的函数
---
## Description
<section id="description"> <dfn>参数</dfn>是变量，它们作为调用函数时要输入到函数的值的占位符。定义函数时，通常将其与一个或多个参数一起定义。调用函数时输入（或<dfn>“传递”</dfn> ）的实际值称为<dfn>参数</dfn> 。这是一个带有两个参数的函数， <code>param1</code>和<code>param2</code> ： <blockquote> function testFun（param1，param2）{ <br> console.log（param1，param2）; <br> } </blockquote>然后我们可以调用<code>testFun</code> ： <code>testFun(&quot;Hello&quot;, &quot;World&quot;);</code>我们通过了两个论点， <code>&quot;Hello&quot;</code>和<code>&quot;World&quot;</code> 。在函数内部， <code>param1</code>将等于“Hello”， <code>param2</code>将等于“World”。请注意，您可以使用不同的参数再次调用<code>testFun</code> ，并且参数将采用新参数的值。 </section>
<section id='description'>
函数的参数<code>parameters</code>在函数中充当占位符(也叫形参)的作用，参数可以为一个或多个。调用一个函数时所传入的参数为实参，实参决定着形参真正的值。简单理解：形参即形式、实参即内容。
这是带有两个参数的函数，<code>param1</code>和<code>param2</code>：
```js
function testFun(param1, param2) {
console.log(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>
## Instructions
<section id="instructions"><ol><li>创建一个名为<code>functionWithArgs</code> ，该函数接受两个参数并将其总和输出到开发控制台。 </li><li>使用两个数字作为参数调用该函数。 </li></ol></section>
<section id='instructions'>
<ol><li>创建一个名为<code>functionWithArgs</code>的函数，它可以接收两个参数，计算参数的和，将结果输出到控制台。</li><li>调用这个函数。</li></ol>
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>functionWithArgs</code>应该是一个函数
- text: <code>functionWithArgs</code>应该是一个函数。
testString: assert(typeof functionWithArgs === 'function');
- text: '<code>functionWithArgs(1,2)</code>应该输出<code>3</code>'
- 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>'
- 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));
- text: 在你定义<code>functionWithArgs</code>之后记得调用它。
testString: assert(/^\s*functionWithArgs\s*\(\s*\d+\s*,\s*\d+\s*\)\s*;?/m.test(code));
```
@ -44,6 +60,7 @@ ourFunctionWithArgs(10, 5); // Outputs 5
// Only change code below this line.
```
</div>
@ -72,7 +89,6 @@ function uncapture() {
}
capture();
```
</div>
@ -81,7 +97,13 @@ capture();
<div id='js-teardown'>
```js
console.info('after the test');
uncapture();
if (typeof functionWithArgs !== "function") {
(function() { return "functionWithArgs is not defined"; })();
} else {
(function() { return logOutput || "console.log never called"; })();
}
```
</div>
@ -91,7 +113,12 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
function functionWithArgs(a, b) {
console.log(a + b);
}
functionWithArgs(10, 5);
```
</section>

45
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/practice-comparing-different-values.chinese.md
View File

@ -2,26 +2,47 @@
id: 599a789b454f2bbd91a3ff4d
title: Practice comparing different values
challengeType: 1
videoUrl: ''
localeTitle: 练习比较不同的值
videoUrl: 'https://scrimba.com/c/cm8PqCa'
forumTopicId: 301174
localeTitle: 比较不同值
---
## Description
<section id="description">在最后两个挑战中，我们学习了等于运算符（ <code>==</code> ）和严格相等运算符（ <code>===</code> ）。让我们快速回顾一下这些运算符的实践。如果要比较的值不是同一类型，则相等运算符将执行类型转换，然后计算值。但是，严格相等运算符将按原样比较数据类型和值，而不将一种类型转换为另一种类型。 <strong>例子</strong> <blockquote> 3 ==&#39;3&#39;//返回true，因为JavaScript执行从字符串到数字的类型转换<br> 3 ===&#39;3&#39;//返回false，因为类型不同并且未执行类型转换</blockquote> <strong>注意</strong> <br>在JavaScript中，您可以使用<code>typeof</code>运算符确定变量的类型或值，如下所示： <blockquote> typeof 3 //返回&#39;number&#39; <br> typeof&#39;3&#39;//返回&#39;string&#39; </blockquote></section>
<section id='description'>
在上两个挑战中，我们学习了相等运算符 (<code>==</code>) 和严格相等运算符 (<code>===</code>)。现在让我们快速回顾并实践一下。
如果要比较的值不是同一类型，相等运算符会先执行数据类型转换，然后比较值。而严格相等运算符只比较值，不会进行数据类型转换。
由此可见，相等运算符和严格相等运算符的区别是：前者会执行隐式类型转换，后者不会。
<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>运算符确定变量的类型或值，如下所示：
```js
typeof 3 // returns 'number'
typeof '3' // returns 'string'
```
</section>
## Instructions
<section id="instructions">编辑器中的<code>compareEquality</code>函数使用<code>equality operator</code>比较两个值。修改函数，使其仅在值严格相等时返回“Equal”。 </section>
<section id='instructions'>
编辑器中的<code>compareEquality</code>函数使用相等运算符比较两个值。修改函数，使其仅在值严格相等时返回 "Equal" 。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>compareEquality(10, &quot;10&quot;)</code>应返回“Not Equal”'
- text: <code>compareEquality(10, "10")</code>应该返回 "Not Equal"。
testString: assert(compareEquality(10, "10") === "Not Equal");
- text: '<code>compareEquality(&quot;20&quot;, 20)</code>应该返回“Not Equal”'
- text: <code>compareEquality("20", 20)</code>应该返回 "Not Equal"。
testString: assert(compareEquality("20", 20) === "Not Equal");
- text: 您应该使用<code>===</code>运算符
- text: 你应该使用<code>===</code>运算符。
testString: assert(code.match(/===/g));
```
@ -44,7 +65,6 @@ function compareEquality(a, b) {
// Change this value to test
compareEquality(10, "10");
```
</div>
@ -56,7 +76,14 @@ compareEquality(10, "10");
## Solution
<section id='solution'>
```js
// solution required
function compareEquality(a,b) {
if (a === b) {
return "Equal";
}
return "Not Equal";
}
```
</section>

73
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/profile-lookup.chinese.md
View File

@ -2,15 +2,24 @@
id: 5688e62ea601b2482ff8422b
title: Profile Lookup
challengeType: 1
videoUrl: ''
localeTitle: 个人资料查询
videoUrl: 'https://scrimba.com/c/cDqW2Cg'
forumTopicId: 18259
localeTitle: 资料查找
---
## Description
<section id="description">我们的联系人列表中有一组代表不同人的对象。已经为您预先编写了一个以<code>name</code>和属性（ <code>prop</code> ）作为参数的<code>lookUpProfile</code>函数。该函数应检查<code>name</code>是否是实际联系人的<code>firstName</code> ，并且给定属性（ <code>prop</code> ）是该联系人的属性。如果两者都为真，则返回该属性的“值”。如果<code>name</code>与任何联系人不对应，则返回<code>&quot;No such contact&quot;</code>如果<code>prop</code>不符合找到匹配<code>name</code>的联系人的任何有效属性，则返回<code>&quot;No such property&quot;</code> </section>
<section id='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">
<section id='instructions'>
</section>
## Tests
@ -18,17 +27,17 @@ localeTitle: 个人资料查询
```yml
tests:
- text: '<code>&quot;Kristian&quot;, &quot;lastName&quot;</code>应该返回<code>&quot;Vos&quot;</code>'
- text: <code>"Kristian", "lastName"</code>应该返回 <code>"Vos"</code>。
testString: assert(lookUpProfile('Kristian','lastName') === "Vos");
- text: '<code>&quot;Sherlock&quot;, &quot;likes&quot;</code>应该回归<code>[&quot;Intriguing Cases&quot;, &quot;Violin&quot;]</code>'
- text: <code>"Sherlock", "likes"</code>应该返回 <code>["Intriguing Cases", "Violin"]</code>。
testString: assert.deepEqual(lookUpProfile("Sherlock", "likes"), ["Intriguing Cases", "Violin"]);
- text: '<code>&quot;Harry&quot;,&quot;likes&quot;</code>应该返回一个阵列'
- text: <code>"Harry","likes"</code>应该返回 an array。
testString: assert(typeof lookUpProfile("Harry", "likes") === "object");
- text: '<code>&quot;Bob&quot;, &quot;number&quot;</code>应该返回“没有这样的联系”'
- text: <code>"Bob", "number"</code>应该返回 "No such contact"。
testString: assert(lookUpProfile("Bob", "number") === "No such contact");
- text: '<code>&quot;Bob&quot;, &quot;potato&quot;</code>应该返回“没有这样的联系”'
- text: <code>"Bob", "potato"</code>应该返回 "No such contact"。
testString: assert(lookUpProfile("Bob", "potato") === "No such contact");
- text: '<code>&quot;Akira&quot;, &quot;address&quot;</code>应该返回“没有这样的财产”'
- text: <code>"Akira", "address"</code>应该返回 "No such property"。
testString: assert(lookUpProfile("Akira", "address") === "No such property");
```
@ -78,7 +87,6 @@ function lookUpProfile(name, prop){
// Change these values to test your function
lookUpProfile("Akira", "likes");
```
</div>
@ -90,7 +98,48 @@ lookUpProfile("Akira", "likes");
## Solution
<section id='solution'>
```js
// solution required
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");
```
</section>

46
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/quoting-strings-with-single-quotes.chinese.md
View File

@ -2,24 +2,51 @@
id: 56533eb9ac21ba0edf2244b4
title: Quoting Strings with Single Quotes
challengeType: 1
videoUrl: ''
localeTitle: 单引号引用字符串
videoUrl: 'https://scrimba.com/c/cbQmnhM'
forumTopicId: 18260
localeTitle: 用单引号引用字符串
---
## Description
<section id="description"> JavaScript中的<dfn>字符串</dfn>值可以使用单引号或双引号编写，只要您以相同类型的引号开头和结尾即可。与其他一些编程语言不同，单引号和双引号在JavaScript中的工作方式相同。 <blockquote> doubleQuoteStr =“这是一个字符串”; <br> singleQuoteStr =&#39;这也是一个字符串&#39;; </blockquote>你可能想要使用一种报价而不是另一种报价的原因是你想在字符串中使用这两种报价。如果要将对话保存在字符串中并将对话用引号括起，则可能会发生这种情况。它的另一个用途是在一个字符串中保存带引号中各种属性的<code>&lt;a&gt;</code>标签。 <blockquote>谈话=&#39;芬恩向杰克惊呼，“代数！”&#39;; </blockquote>但是，如果您需要使用其中的最外层引号，这将成为一个问题。请记住，字符串在开头和结尾都有相同的引用。但是如果你在中间的某个地方有相同的引用，字符串将提前停止并抛出错误。 <blockquote> goodStr =&#39;杰克问芬恩，“嘿，我们去冒险吧？” <br> badStr =&#39;芬恩回答，“我们走了！”&#39;; //引发错误</blockquote>在上面的<dfn>goodStr中</dfn> ，您可以使用反斜杠<code>\</code>作为转义字符安全地使用两个引号。 <strong>注意</strong> <br>反斜杠<code>\</code>不应与正斜杠<code>/</code>混淆。他们不做同样的事情。 </section>
<section id='description'>
JavaScript 中的<dfn>字符串</dfn>可以使用开始和结束都是同类型的单引号或双引号表示，与其他一些编程语言不同的是，单引号和双引号的功能在 JavaScript 中是相同的。
```js
doubleQuoteStr = "This is a string";
singleQuoteStr = 'This is also a string';
```
当你需要在一个字符串中使用多个引号的时候，你可以使用单引号包裹双引号或者相反。常见的场景比如在字符串中包含对话的句子需要用引号包裹。另外比如在一个包含有<code>&#60;a&#62;</code>标签的字符串中，<code>&#60;a&#62;</code>标签的属性值需要用引号包裹。
```js
conversation = 'Finn exclaims to Jake, "Algebraic!"';
```
但是，如果你想在字符串中使用与最外层相同的引号，会有一些问题。要知道，字符串在开头和结尾都有相同的引号，如果在中间使用了相同的引号，字符串会提前中止并抛出错误。
```js
goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"';
badStr = 'Finn responds, "Let's go!"'; // Throws an error
```
在上面的<code>goodStr</code>中，通过使用反斜杠<code>\</code>转义字符可以安全地使用两种引号
<strong>提示</strong><br/>不要把反斜杠<code>\</code>和斜杠<code>/</code>搞混，它们不是一回事。
</section>
## Instructions
<section id="instructions">将提供的字符串更改为在开头和结尾使用单引号的字符串，并且不包含转义字符。现在，字符串中的<code>&lt;a&gt;</code>标签在任何地方都使用双引号。您需要将外引号更改为单引号，以便删除转义字符。 </section>
<section id='instructions'>
把字符串更改为开头和结尾使用单引号的字符串，并且不包含转义字符。
这样字符串中的<code>&#60;a&#62;</code>标签里面任何地方都可以使用双引号。你需要将最外层引号更改为单引号，以便删除转义字符。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 删除所有<code>backslashes</code> （ <code>\</code> ）
- 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>'
- text: 应该要有两个单引号<code>&#39;</code>和四个双引号<code>&quot;</code>。
testString: assert(code.match(/"/g).length === 4 && code.match(/'/g).length === 2);
```
@ -34,6 +61,7 @@ tests:
```js
var myStr = "<a href=\"http://www.example.com\" target=\"_blank\">Link</a>";
```
</div>
@ -43,7 +71,7 @@ var myStr = "<a href=\"http://www.example.com\" target=\"_blank\">Link</a>";
<div id='js-teardown'>
```js
console.info('after the test');
(function() { return "myStr = " + myStr; })();
```
</div>
@ -53,7 +81,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myStr = '<a href="http://www.example.com" target="_blank">Link</a>';
```
</section>

140
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/record-collection.chinese.md
View File

@ -2,15 +2,29 @@
id: 56533eb9ac21ba0edf2244cf
title: Record Collection
challengeType: 1
videoUrl: ''
localeTitle: 记录收集
videoUrl: 'https://scrimba.com/c/c4mpysg'
forumTopicId: 18261
localeTitle: 记录集合
---
## Description
<section id="description">您将获得一个JSON对象，表示您的音乐专辑集合的一部分。每张专辑都有几个属性和一个唯一的ID号作为其关键。并非所有相册都有完整的信息。写一个功能，它取一个专辑的<code>id</code> （如<code>2548</code> ），一个属性<code>prop</code> （如<code>&quot;artist&quot;</code>或<code>&quot;tracks&quot;</code> ），以及一个<code>value</code> （如<code>&quot;Addicted to Love&quot;</code> ）来修改此集合中的数据。如果<code>prop</code>不是<code>&quot;tracks&quot;</code>且<code>value</code>不为空（ <code>&quot;&quot;</code> ），则更新或设置该记录专辑属性的<code>value</code> 。您的函数必须始终返回整个集合对象。处理不完整数据有几个规则：如果<code>prop</code>是<code>&quot;tracks&quot;</code>但是相册没有<code>&quot;tracks&quot;</code>属性，则在将新值添加到相册的相应属性之前创建一个空数组。如果<code>prop</code>是<code>&quot;tracks&quot;</code>且<code>value</code>不为空（ <code>&quot;&quot;</code> ），则将<code>value</code>推到专辑现有<code>tracks</code>数组的末尾。如果<code>value</code>为空（ <code>&quot;&quot;</code> ），则从相册中删除给定的<code>prop</code>属性。 <strong>提示</strong> <br>使用<a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/accessing-object-properties-with-variables" target="_blank">变量访问对象属性</a>时使用<code>bracket notation</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="/learn/javascript-algorithms-and-data-structures/basic-javascript/manipulating-complex-objects" target="_blank">操作复杂对象</a>介绍JavaScript对象表示法（JSON）进行复习。 </section>
<section id='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>。
你的函数必须始终返回整个音乐专辑集合对象。
处理不完整数据有几条规则：
如果属性<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">
<section id='instructions'>
</section>
## Tests
@ -18,19 +32,21 @@ localeTitle: 记录收集
```yml
tests:
- text: '在<code>updateRecords(5439, &quot;artist&quot;, &quot;ABBA&quot;)</code> ， <code>artist</code>应该是<code>&quot;ABBA&quot;</code>'
testString: collection = collectionCopy; assert(updateRecords(5439, "artist", "ABBA")[5439]["artist"] === "ABBA");
- text: '在<code>updateRecords(5439, &quot;tracks&quot;, &quot;Take a Chance on Me&quot;)</code> ， <code>tracks</code>应该以<code>&quot;Take a Chance on Me&quot;</code>作为最后一个元素。'
- 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, &quot;artist&quot;, &quot;&quot;)</code> ，不应该设置<code>artist</code>'
- text: 执行<code>updateRecords(2548, "artist", "")</code>后，<code>artist</code>不应被创建。
testString: updateRecords(2548, "artist", ""); assert(!collection[2548].hasOwnProperty("artist"));
- text: '在<code>updateRecords(1245, &quot;tracks&quot;, &quot;Addicted to Love&quot;)</code> ， <code>tracks</code>应该将<code>&quot;Addicted to Love&quot;</code>作为最后一个元素。'
- 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, &quot;tracks&quot;, &quot;Free&quot;)</code> ， <code>tracks</code>应该以<code>&quot;1999&quot;</code>作为第一个元素。'
- 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, &quot;tracks&quot;, &quot;&quot;)</code> ，不应设置<code>tracks</code>'
- text: 执行<code>updateRecords(2548, "tracks", "")</code>后，<code>tracks</code>不应被创建。
testString: updateRecords(2548, "tracks", ""); assert(!collection[2548].hasOwnProperty("tracks"));
- text: '在<code>updateRecords(1245, &quot;album&quot;, &quot;Riptide&quot;)</code> ， <code>album</code>应该是<code>&quot;Riptide&quot;</code>'
- text: 执行<code>updateRecords(1245, "album", "Riptide")</code>后，<code>album</code>应该是<code>"Riptide"</code>。
testString: assert(updateRecords(1245, "album", "Riptide")[1245]["album"] === "Riptide");
```
@ -39,38 +55,35 @@ tests:
## Challenge Seed
<section id='challengeSeed'>
<div id='js-seed'>
```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"
}
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"
}
};
// Keep a copy of the collection for tests
var collectionCopy = JSON.parse(JSON.stringify(collection));
// Only change code below this line
function updateRecords(id, prop, value) {
@ -85,23 +98,50 @@ updateRecords(5439, "artist", "ABBA");
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
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;
}
```
</section>

110
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/replace-loops-using-recursion.chinese.md Normal file
View File

@ -0,0 +1,110 @@
---
id: 5cfa3679138e7d9595b9d9d4
title: Replace Loops using Recursion
challengeType: 1
videoUrl: 'https://www.freecodecamp.org/news/how-recursion-works-explained-with-flowcharts-and-a-video-de61f40cb7f9/'
forumTopicId: 301175
localeTitle: 使用递归代替循环
---
## Description
<section id='description'>
函数调用自身的编程技巧称为递归。为了便于理解，有如下任务：计算数组内元素第 <code>0</code> 到第 <code>n</code> 的元素乘积，使用 <code>for</code> 循环， 可以这样做：
```js
function multiply(arr, n) {
var product = arr[0];
for (var i = 1; i <= n; i++) {
product *= arr[i];
}
return product;
}
```
下面是递归写法，注意代码里的 <code>multiply(arr, n) == multiply(arr, n - 1) * arr[n]</code>。这意味着可以重写 <code>multiply</code> 以调用自身而无需依赖循环。
```js
function multiply(arr, n) {
if (n <= 0) {
return arr[0];
} else {
return multiply(arr, n - 1) * arr[n];
}
}
```
递归版本的 <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> 返回结果。
<strong>注意：</strong> 递归函数在没有函数调用时（在这个例子是，是当 <code>n <= 0</code> 时）必需有一个跳出结构，否则永远不会执行完毕。
</section>
## Instructions
<section id='instructions'>
写一个递归函数，<code>sum(arr, n)</code>，返回递归调用数组 <code>arr</code> 从第 <code>0</code> 个到第 <code>n</code> 个元素和。
</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'>
```js
function sum(arr, n) {
// Only change code below this line
// Only change code above this line
}
```
</div>
### After Test
<div id='js-teardown'>
```js
const removeJSComments = str => str.replace(/\/\*[\s\S]*?\*\/|\/\/.*$/gm, '');
```
</div>
</section>
## Solution
<section id='solution'>
```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
}
```
</section>

83
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/replacing-if-else-chains-with-switch.chinese.md
View File

@ -2,40 +2,71 @@
id: 56533eb9ac21ba0edf2244e0
title: Replacing If Else Chains with Switch
challengeType: 1
videoUrl: ''
localeTitle: 如果用交换机替换其他链条
videoUrl: 'https://scrimba.com/c/c3JE8fy'
forumTopicId: 18266
localeTitle: 用一个 Switch 语句来替代多个 if else 语句
---
## Description
<section id="description">如果您有许多选项可供选择，那么<code>switch</code>语句比许多链接的<code>if</code> / <code>else if</code>语句更容易编写。下列： <blockquote> if（val === 1）{ <br> answer =“a”; <br> } else if（val === 2）{ <br> answer =“b”; <br> } else { <br> answer =“c”; <br> } </blockquote>可以替换为： <blockquote> switch（val）{ <br>情况1： <br> answer =“a”; <br>打破; <br>案例2： <br> answer =“b”; <br>打破; <br>默认： <br> answer =“c”; <br> } </blockquote></section>
<section id='description'>
如果你有多个选项需要选择，<code>switch</code>语句写起来会比多个串联的<code>if</code>/<code>if else</code>语句容易些，譬如:
```js
if (val === 1) {
answer = "a";
} else if (val === 2) {
answer = "b";
} else {
answer = "c";
}
```
可以被下面替代：
```js
switch(val) {
case 1:
answer = "a";
break;
case 2:
answer = "b";
break;
default:
answer = "c";
}
```
</section>
## Instructions
<section id="instructions">将链接的<code>if</code> / <code>else if</code>语句更改为<code>switch</code>语句。 </section>
<section id='instructions'>
把串联的<code>if</code>/<code>if else</code>语句改成<code>switch</code>语句。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 您不应该在编辑器中的任何位置使用任何<code>else</code>语句
- text: 不要使用<code>else</code>表达式。
testString: assert(!/else/g.test(code));
- text: 您不应在编辑器中的任何位置使用任何<code>if</code>语句
- text: 不要使用<code>if</code>表达式。
testString: assert(!/if/g.test(code));
- text: 你应该至少有四个<code>break</code>语句
- text: 你应该有至少 4 个<code>break</code>表达式。
testString: assert(code.match(/break/g).length >= 4);
- text: <code>chainToSwitch(&quot;bob&quot;)</code>应该是“Marley”
- text: <code>chainToSwitch("bob")</code>应该为 "Marley"。
testString: assert(chainToSwitch("bob") === "Marley");
- text: <code>chainToSwitch(42)</code>应该是“答案”
- text: <code>chainToSwitch(42)</code>应该为 "The Answer"。
testString: assert(chainToSwitch(42) === "The Answer");
- text: <code>chainToSwitch(1)</code>应该是“没有＃1”
- text: <code>chainToSwitch(1)</code>应该为 "There is no #1"。
testString: "assert(chainToSwitch(1) === \"There is no #1\");"
- text: <code>chainToSwitch(99)</code>应该是“错过了我这么多！”
- 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”
- text: <code>chainToSwitch(7)</code>应该为 "Ate Nine"。
testString: assert(chainToSwitch(7) === "Ate Nine");
- text: <code>chainToSwitch(&quot;John&quot;)</code>应为“”（空字符串）
- text: <code>chainToSwitch("John")</code>应该为 "" (empty string)。
testString: assert(chainToSwitch("John") === "");
- text: <code>chainToSwitch(156)</code>应为“”（空字符串）
- text: <code>chainToSwitch(156)</code>应该为 "" (empty string)。
testString: assert(chainToSwitch(156) === "");
```
@ -82,7 +113,29 @@ chainToSwitch(7);
## Solution
<section id='solution'>
```js
// solution required
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;
}
```
</section>

39
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/return-a-value-from-a-function-with-return.chinese.md
View File

@ -2,28 +2,43 @@
id: 56533eb9ac21ba0edf2244c2
title: Return a Value from a Function with Return
challengeType: 1
videoUrl: ''
localeTitle: 从带返回的函数返回值
videoUrl: 'https://scrimba.com/c/cy87wue'
forumTopicId: 18271
localeTitle: 函数可以返回某个值
---
## Description
<section id="description">我们可以将值传递给带<dfn>参数</dfn>的函数。您可以使用<code>return</code>语句从函数中发回一个值。 <strong>例</strong> <blockquote> function plusThree（num）{ <br>返回num + 3; <br> } <br> var answer = plusThree（5）; // 8 </blockquote> <code>plusThree</code>接受<code>num</code>的<dfn>参数</dfn>并返回一个等于<code>num + 3</code>的值。 </section>
<section id='description'>
我们可以通过函数的<dfn>参数</dfn>把值传入函数，也可以使用<code>return</code>语句把数据从一个函数中传出来。
<strong>示例</strong>
```js
function plusThree(num) {
return num + 3;
}
var answer = plusThree(5); // 8
```
<code>plusThree</code>带有一个<code>num</code>的<dfn>参数</dfn>并且返回（returns）一个等于<code>num + 3</code>的值。
</section>
## Instructions
<section id="instructions">创建一个接受一个参数的函数<code>timesFive</code> ，将其乘以<code>5</code> ，然后返回新值。有关如何测试<code>timesFive</code>函数的示例，请参阅编辑器中的最后一行。 </section>
<section id='instructions'>
创建一个函数<code>timesFive</code>接收一个参数, 把它乘以<code>5</code>之后返回，关于如何测试timesFive 函数，可以参考编辑器中最后一行的示例。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>timesFive</code>应该是一个功能
- text: <code>timesFive</code>应是一个函数。
testString: assert(typeof timesFive === 'function');
- text: <code>timesFive(5)</code>应该返回<code>25</code>
- text: <code>timesFive(5)</code>应该返回<code>25</code>。
testString: assert(timesFive(5) === 25);
- text: <code>timesFive(2)</code>应该返回<code>10</code>
- text: <code>timesFive(2)</code>应该返回<code>10</code>。
testString: assert(timesFive(2) === 10);
- text: <code>timesFive(0)</code>应该返回<code>0</code>
- text: <code>timesFive(0)</code>应该返回<code>0</code>。
testString: assert(timesFive(0) === 0);
```
@ -46,7 +61,6 @@ function minusSeven(num) {
console.log(minusSeven(10));
```
</div>
@ -58,7 +72,12 @@ console.log(minusSeven(10));
## Solution
<section id='solution'>
```js
// solution required
function timesFive(num) {
return num * 5;
}
timesFive(10);
```
</section>

48
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/return-early-pattern-for-functions.chinese.md
View File

@ -2,32 +2,50 @@
id: 56533eb9ac21ba0edf2244c4
title: Return Early Pattern for Functions
challengeType: 1
videoUrl: ''
localeTitle: 返回函数的早期模式
videoUrl: 'https://scrimba.com/c/cQe39Sq'
forumTopicId: 18272
localeTitle: 函数执行到 return 语句就结束
---
## Description
<section id="description">当达到<code>return</code>语句时，当前函数的执行停止，控制返回到调用位置。 <strong>例</strong> <blockquote> function myFun（）{ <br>的console.log（ “你好”）; <br>回归“世界”; <br>的console.log（ “BYEBYE”） <br> } <br> myFun（）; </blockquote>上面输出“Hello”到控制台，返回“World”，但是<code>&quot;byebye&quot;</code>永远不输出，因为函数退出<code>return</code>语句。 </section>
<section id='description'>
当代码执行到 return 语句时，函数返回一个结果就结束运行了，return 后面的语句不会执行。
<strong>示例</strong>
```js
function myFun() {
console.log("Hello");
return "World";
console.log("byebye")
}
myFun();
```
上面的代码输出"Hello"到控制台、返回 "World"，但没有输出<code>"byebye"</code>，因为函数遇到 return 语句就退出了。
</section>
## Instructions
<section id="instructions">修改函数<code>abTest</code>以便如果<code>a</code>或<code>b</code>小于<code>0</code> ，函数将立即以<code>undefined</code>值退出。 <strong>暗示</strong> <br>请记住， <a href="http://www.freecodecamp.org/challenges/understanding-uninitialized-variables" target="_blank"><code>undefined</code>是一个关键字</a> ，而不是一个字符串。 </section>
<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>
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>abTest(2,2)</code>应返回一个数字'
- text: <code>abTest(2,2)</code> 应该返回一个数字。
testString: assert(typeof abTest(2,2) === 'number' );
- text: '<code>abTest(2,2)</code>应该返回<code>8</code>'
- text: <code>abTest(2,2)</code> 应该返回 <code>8</code>。
testString: assert(abTest(2,2) === 8 );
- text: '<code>abTest(-2,2)</code>应返回<code>undefined</code>'
- text: <code>abTest(-2,2)</code> 应该返回 <code>undefined</code>。
testString: assert(abTest(-2,2) === undefined );
- text: '<code>abTest(2,-2)</code>应返回<code>undefined</code>'
- text: <code>abTest(2,-2)</code> 应该返回 <code>undefined</code>。
testString: assert(abTest(2,-2) === undefined );
- text: '<code>abTest(2,8)</code>应该返回<code>18</code>'
- text: <code>abTest(2,8)</code> 应该返回 <code>18</code>。
testString: assert(abTest(2,8) === 18 );
- text: '<code>abTest(3,3)</code>应该返回<code>12</code>'
- text: <code>abTest(3,3)</code> 应该返回 <code>12</code>。
testString: assert(abTest(3,3) === 12 );
```
@ -53,7 +71,6 @@ function abTest(a, b) {
// Change values below to test your code
abTest(2,2);
```
</div>
@ -65,7 +82,14 @@ abTest(2,2);
## Solution
<section id='solution'>
```js
// solution required
function abTest(a, b) {
if(a < 0 || b < 0) {
return undefined;
}
return Math.round(Math.pow(Math.sqrt(a) + Math.sqrt(b), 2));
}
```
</section>

44
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/returning-boolean-values-from-functions.chinese.md
View File

@ -2,26 +2,51 @@
id: 5679ceb97cbaa8c51670a16b
title: Returning Boolean Values from Functions
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/cp62qAQ'
forumTopicId: 18273
localeTitle: 从函数返回布尔值
---
## Description
<section id="description">您可以从<a href="/learn/javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator" target="_blank">与Equality运算符的比较中</a>回忆一下，所有比较运算符都返回布尔值<code>true</code>或<code>false</code>值。有时人们使用if / else语句进行比较，如下所示： <blockquote> function isEqual（a，b）{ <br> if（a === b）{ <br>返回true; <br> } else { <br>返回虚假; <br> } <br> } </blockquote>但是有一种更好的方法可以做到这一点。由于<code>===</code>返回<code>true</code>或<code>false</code> ，我们可以返回比较结果： <blockquote> function isEqual（a，b）{ <br>返回a === b; <br> } </blockquote></section>
<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>。
```js
function isEqual(a,b) {
if (a === b) {
return true;
} else {
return false;
}
}
```
有一个更好的方法，因为<code>===</code>总是返回<code>true</code>或<code>false</code>，所以我们可以直接返回比较的结果：
```js
function isEqual(a,b) {
return a === b;
}
```
</section>
## Instructions
<section id="instructions">修复函数<code>isLess</code>以删除<code>if/else</code>语句。 </section>
<section id='instructions'>
移除<code>isLess</code>函数的<code>if/else</code>语句但不影响函数的功能。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: '<code>isLess(10,15)</code>应该返回<code>true</code>'
- text: <code>isLess(10,15)</code>应该返回 <code>true</code>。
testString: assert(isLess(10,15) === true);
- text: '<code>isLess(15,10)</code>应该返回<code>false</code>'
- text: <code>isLess(15,10)</code>应该返回 <code>false</code>。
testString: assert(isLess(15, 10) === false);
- text: 您不应该使用任何<code>if</code>或<code>else</code>语句
- text: 不应该使用 <code>if</code> 或者 <code>else</code> 语句。
testString: assert(!/if|else/g.test(code));
```
@ -45,7 +70,6 @@ function isLess(a, b) {
// Change these values to test
isLess(10, 15);
```
</div>
@ -57,7 +81,11 @@ isLess(10, 15);
## Solution
<section id='solution'>
```js
// solution required
function isLess(a, b) {
return a < b;
}
```
</section>

52
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/selecting-from-many-options-with-switch-statements.chinese.md
View File

@ -2,15 +2,15 @@
id: 56533eb9ac21ba0edf2244dd
title: Selecting from Many Options with Switch Statements
challengeType: 1
videoUrl: ''
localeTitle: 从带有开关语句的多个选项中进行选择
videoUrl: 'https://scrimba.com/c/c4mv4fm'
forumTopicId: 18277
localeTitle: 使用 Switch 语句从许多选项中进行选择
---
## Description
<section id="description">
如果您有很多选择，请使用<dfn> switch </dfn>语句。 <code> switch </code>语句测试一个值，并且可以包含许多定义各种可能值的<dfn> case </dfn>语句。 从第一个匹配的<code> case </code>值开始执行语句，直到遇到<code> break </code>。
这是<code> switch </code>语句的示例：
<section id='description'>
如果你有非常多的选项需要选择，可以使用 switch 语句。根据不同的参数值会匹配上不同的 case 分支，语句会从第一个匹配的 case 分支开始执行，直到碰到 break 就结束。
这是一个伪代码案例：
```js
switch(lowercaseLetter) {
@ -23,29 +23,30 @@ switch(lowercaseLetter) {
}
```
<code> case </code>值以严格相等性（<code> === </code>）进行测试。 <code> break </code>告诉JavaScript停止执行语句。 如果省略<code> break </code>，将执行下一条语句。
测试<code>case</code>值使用严格相等运算符进行比较，break 关键字告诉 JavaScript 停止执行语句。如果没有 break 关键字，下一个语句会继续执行。
</section>
## Instructions
<section id="instructions">编写一个switch语句，测试<code>val</code>并设置以下条件的<code>answer</code> ： <br> <code>1</code> - “alpha” <br> <code>2</code> - “beta” <br> <code>3</code> - “伽玛” <br> <code>4</code> - “三角洲” </section>
<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>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>caseInSwitch(1)</code>的值应为“alpha”
- text: <code>caseInSwitch(1)</code> 应该有一个值为 "alpha"。
testString: assert(caseInSwitch(1) === "alpha");
- text: <code>caseInSwitch(2)</code>的值应为“beta”
- text: <code>caseInSwitch(2)</code> 应该有一个值为 "beta"。
testString: assert(caseInSwitch(2) === "beta");
- text: <code>caseInSwitch(3)</code>的值应为“gamma”
- text: <code>caseInSwitch(3)</code> 应该有一个值为 "gamma"。
testString: assert(caseInSwitch(3) === "gamma");
- text: <code>caseInSwitch(4)</code>的值应为“delta”
- text: <code>caseInSwitch(4)</code> 应该有一个值为 "delta"。
testString: assert(caseInSwitch(4) === "delta");
- text: 您不应该使用任何<code>if</code>或<code>else</code>语句
- text: 不能使用任何<code>if</code>或<code>else</code>表达式。
testString: assert(!/else/g.test(code) || !/if/g.test(code));
- text: 你应该至少有3个<code>break</code>语句
- text: 你应该有至少 3 个<code>break</code>表达式。
testString: assert(code.match(/break/g).length > 2);
```
@ -82,7 +83,26 @@ caseInSwitch(1);
## Solution
<section id='solution'>
```js
// solution required
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;
}
```
</section>

59
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/shopping-list.chinese.md
View File

@ -2,15 +2,22 @@
id: 56533eb9ac21ba0edf2244bc
title: Shopping List
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/c9MEKHZ'
forumTopicId: 18280
localeTitle: 购物清单
---
## Description
<section id="description">在变量<code>myList</code>创建购物清单。该列表应该是包含多个子阵列的多维数组。每个子数组中的第一个元素应包含一个带有项目名称的字符串。第二个元素应该是一个代表数量的数字，即<code>[&quot;Chocolate Bar&quot;, 15]</code>列表中应该至少有5个子数组。 </section>
<section id='description'>
创建一个名叫<code>myList</code>的购物清单，清单的数据格式就是多维数组。
每个子数组中的第一个元素应该是购买的物品名称，第二个元素应该是物品的数量，类似于：
<code>["Chocolate Bar", 15]</code>
任务：你的购物清单至少应该有 5 个子数组。
</section>
## Instructions
<section id="instructions">
<section id='instructions'>
</section>
## Tests
@ -18,13 +25,13 @@ localeTitle: 购物清单
```yml
tests:
- text: <code>myList</code>应该是一个数组
- text: <code>myList</code>应该一个数组。
testString: assert(isArray);
- text: 每个子数组中的第一个元素都必须是字符串
- text: 你的每个子数组的第一个元素的类型都应该是字符串。
testString: assert(hasString);
- text: 每个子数组中的第二个元素都必须是数字
- text: 你的每个子数组的第二个元素的类型都应该是数字。
testString: assert(hasNumber);
- text: 您的列表中必须至少有5个项目
- text: 你的列表中至少要包含 5 个元素。
testString: assert(count > 4);
```
@ -39,6 +46,7 @@ tests:
```js
var myList = [];
```
</div>
@ -48,7 +56,32 @@ var myList = [];
<div id='js-teardown'>
```js
console.info('after the test');
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);
```
</div>
@ -58,7 +91,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myList = [
["Candy", 10],
["Potatoes", 12],
["Eggs", 12],
["Catfood", 1],
["Toads", 9]
];
```
</section>

40
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/stand-in-line.chinese.md
View File

@ -2,15 +2,22 @@
id: 56533eb9ac21ba0edf2244c6
title: Stand in Line
challengeType: 1
videoUrl: ''
localeTitle: 站在队中
videoUrl: 'https://scrimba.com/c/ca8Q8tP'
forumTopicId: 18307
localeTitle: 排队
---
## Description
<section id="description">在计算机科学中， <dfn>队列</dfn>是一个抽象的<dfn>数据结构</dfn> ，其中项目按顺序保存。可以在<code>queue</code>的后面添加新项目，并从<code>queue</code>的前面取出旧项目。编写一个函数<code>nextInLine</code> ，它接受一个数组（ <code>arr</code> ）和一个数字（ <code>item</code> ）作为参数。将数字添加到数组的末尾，然后删除数组的第一个元素。然后， <code>nextInLine</code>函数应返回已删除的元素。 </section>
<section id='description'>
在计算机科学中<dfn>队列</dfn>（queue）是一个抽象的数据结构，队列中的条目都是有秩序的。新的条目会被加到<code>队列</code>的末尾，旧的条目会从<code>队列</code>的头部被移出。
写一个函数<code>nextInLine</code>，用一个数组(<code>arr</code>)和一个数字(<code>item</code>)作为参数。
把数字添加到数组的结尾，然后移出数组的第一个元素。
最后<code>nextInLine</code>函数应该返回被删除的元素。
</section>
## Instructions
<section id="instructions">
<section id='instructions'>
</section>
## Tests
@ -18,15 +25,15 @@ localeTitle: 站在队中
```yml
tests:
- text: '<code>nextInLine([], 5)</code>应返回一个数字。'
- text: <code>nextInLine([], 5)</code>应该返回一个数字。
testString: assert.isNumber(nextInLine([],5));
- text: '<code>nextInLine([], 1)</code>应该返回<code>1</code>'
- text: <code>nextInLine([], 1)</code>应该返回<code>1</code>。
testString: assert(nextInLine([],1) === 1);
- text: '<code>nextInLine([2], 1)</code>应返回<code>2</code>'
- 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>'
- 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>'
- text: 在<code>nextInLine(testArr, 10)</code>执行后<code>testArr[4]</code>应该是<code>10</code>。
testString: nextInLine(testArr, 10); assert(testArr[4] === 10);
```
@ -52,7 +59,6 @@ var testArr = [1,2,3,4,5];
console.log("Before: " + JSON.stringify(testArr));
console.log(nextInLine(testArr, 6)); // Modify this line to test
console.log("After: " + JSON.stringify(testArr));
```
</div>
@ -81,7 +87,6 @@ function uncapture() {
}
capture();
```
</div>
@ -90,7 +95,9 @@ capture();
<div id='js-teardown'>
```js
console.info('after the test');
uncapture();
testArr = [1,2,3,4,5];
(function() { return logOutput.join("\n");})();
```
</div>
@ -100,7 +107,14 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var testArr = [ 1,2,3,4,5];
function nextInLine(arr, item) {
arr.push(item);
return arr.shift();
}
```
</section>

28
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/store-multiple-values-in-one-variable-using-javascript-arrays.chinese.md
View File

@ -2,26 +2,34 @@
id: bd7993c9c69feddfaeb8bdef
title: Store Multiple Values in one Variable using JavaScript Arrays
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript数组在一个变量中存储多个值
videoUrl: 'https://scrimba.com/c/crZQWAm'
forumTopicId: 18309
localeTitle: 使用 JavaScript 数组将多个值存储在一个变量中
---
## Description
<section id="description">使用JavaScript <code>array</code>变量，我们可以在一个地方存储多个数据。你开始一个带有开口方括号的数组声明，用一个结束的方括号结束，并在每个条目之间加一个逗号，如下所示： <code>var sandwich = [&quot;peanut butter&quot;, &quot;jelly&quot;, &quot;bread&quot;]</code> 。 </section>
<section id='description'>
使用<code>数组</code>，我们可以在一个地方存储多个数据。
以左方括号<code>[</code>开始定义一个数组，以右方括号<code>]</code>结束，里面每个元素之间用逗号隔开，例如：
<code>var sandwich = ["peanut butter", "jelly", "bread"]</code>.
</section>
## Instructions
<section id="instructions">修改新数组<code>myArray</code> ，使其包含<code>string</code>和<code>number</code> （ <code>myArray</code>顺序）。 <strong>暗示</strong> <br>如果卡住，请参阅文本编辑器中的示例代码。 </section>
<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>array</code> 。
- text: <code>myArray</code>应该是一个<code>数组</code>。
testString: assert(typeof myArray == 'object');
- text: <code>myArray</code>的第一项应该是一个<code>string</code> 。
- text: <code>myArray</code>数组的第一个元素应该是一个<code>字符串</code>。
testString: assert(typeof myArray[0] !== 'undefined' && typeof myArray[0] == 'string');
- text: <code>myArray</code>的第二项应该是一个<code>number</code> 。
- text: <code>myArray</code>数组的第二个元素应该是一个<code>数字</code>。
testString: assert(typeof myArray[1] !== 'undefined' && typeof myArray[1] == 'number');
```
@ -49,7 +57,7 @@ var myArray = [];
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return z;})(myArray);
```
</div>
@ -59,7 +67,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myArray = ["The Answer", 42];
```
</section>

40
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/storing-values-with-the-assignment-operator.chinese.md
View File

@ -2,28 +2,44 @@
id: 56533eb9ac21ba0edf2244a8
title: Storing Values with the Assignment Operator
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/cEanysE'
forumTopicId: 18310
localeTitle: 使用赋值运算符存储值
---
## Description
<section id="description">在JavaScript中，您可以使用<dfn>赋值</dfn>运算符将值存储在变量中。 <code>myVariable = 5;</code>这将<code>Number</code>值<code>5</code>分配给<code>myVariable</code> 。作业总是从右到左。在将值分配给运算符左侧的变量之前，将解析<code>=</code>运算符右侧的所有内容。 <blockquote> myVar = 5; <br> myNum = myVar; </blockquote>这将为<code>myVar</code>分配<code>5</code> ，然后再次将<code>myVar</code>解析为<code>5</code>并将其分配给<code>myNum</code> 。 </section>
<section id='description'>
在 JavaScript 中，你可以使用赋值运算符将值存储在变量中。
<code>myVariable = 5;</code>
这条语句把<code>Number</code>类型的值<code>5</code>赋给变量<code>myVariable</code>。
赋值过程是从右到左进行的。在将值分配给运算符左侧的变量之前，将解析<code>=</code>运算符右侧的所有内容。
```js
myVar = 5;
myNum = myVar;
```
数值<code>5</code>被赋给变量<code>myVar</code>中，然后再次将变量<code>myVar</code>解析为<code>5</code>并将其赋给<code>myNum</code>变量。
</section>
## Instructions
<section id="instructions">将值<code>7</code>分配给变量<code>a</code> 。分配的内容<code>a</code>变量<code>b</code> 。 </section>
<section id='instructions'>
把数值<code>7</code>赋给变量 <code>a</code>。
把变量<code>a</code>中的内容赋给变量<code>b</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 不要更改行上方的代码
- text: 不要修改注释上方的代码。
testString: assert(/var a;/.test(code) && /var b = 2;/.test(code));
- text: <code>a</code>的值应为7
- text: <code>a</code>的值应该是 7。
testString: assert(typeof a === 'number' && a === 7);
- text: <code>b</code>的值应为7
- text: <code>b</code>的值应该是 7。
testString: assert(typeof b === 'number' && b === 7);
- text: <code>a</code>应分配给<code>b</code> <code>=</code>
- text: 你需要用<code>=</code>把<code>a</code>的值赋给<code>b</code>。
testString: assert(/b\s*=\s*a\s*;/g.test(code));
```
@ -56,7 +72,6 @@ if (typeof a != 'undefined') {
if (typeof b != 'undefined') {
b = undefined;
}
```
</div>
@ -65,7 +80,7 @@ if (typeof b != 'undefined') {
<div id='js-teardown'>
```js
console.info('after the test');
(function(a,b){return "a = " + a + ", b = " + b;})(a,b);
```
</div>
@ -75,7 +90,12 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var a;
var b = 2;
a = 7;
b = a;
```
</section>

35
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/subtract-one-number-from-another-with-javascript.chinese.md
View File

@ -2,25 +2,39 @@
id: cf1111c1c11feddfaeb4bdef
title: Subtract One Number from Another with JavaScript
challengeType: 1
videoUrl: ''
localeTitle: 使用JavaScript从另一个数字中减去一个数字
videoUrl: 'https://scrimba.com/c/cP3yQtk'
forumTopicId: 18314
localeTitle: 减法运算
---
## Description
<section id="description">我们也可以从另一个数字中减去一个数字。 JavaScript使用<code>-</code>符号进行减法。 <p> <strong>例</strong> </p><blockquote> myVar = 12 - 6; //分配6 </blockquote></section>
<section id='description'>
我们也可以在 JavaScript 中进行减法运算。
JavaScript 中使用<code>-</code>来做减法运算。
<strong>示例</strong>
```js
myVar = 12 - 6; // assigned 6
```
</section>
## Instructions
<section id="instructions">更改<code>0</code>因此差异为<code>12</code> 。 </section>
<section id='instructions'>
改变数字<code>0</code>让变量 difference 的值为<code>12</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 使变量<code>difference</code>等于12。
- text: 要使<code>difference</code>的值等于 12。
testString: assert(difference === 12);
- text: 只从45中减去一个数字。
testString: assert(/difference=45-33;?/.test(code.replace(/\s/g, '')));
- text: 只用 45 减去一个数。
testString: assert(/var\s*difference\s*=\s*45\s*-\s*[0-9]*;(?!\s*[a-zA-Z0-9]+)/.test(code));
```
@ -34,6 +48,7 @@ tests:
```js
var difference = 45 - 0;
```
</div>
@ -43,7 +58,7 @@ var difference = 45 - 0;
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return 'difference = '+z;})(difference);
```
</div>
@ -53,7 +68,9 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var difference = 45 - 33;
```
</section>

46
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/testing-objects-for-properties.chinese.md
View File

@ -2,26 +2,42 @@
id: 567af2437cbaa8c51670a16c
title: Testing Objects for Properties
challengeType: 1
videoUrl: ''
localeTitle: 测试属性的对象
videoUrl: 'https://scrimba.com/c/cm8Q7Ua'
forumTopicId: 18324
localeTitle: 测试对象的属性
---
## Description
<section id="description">有时检查给定对象的属性是否存在是有用的。我们可以使用对象的<code>.hasOwnProperty(propname)</code>方法来确定该对象是否具有给定的属性名称。 <code>.hasOwnProperty()</code>如果找到属性则返回<code>true</code>或<code>false</code> 。 <strong>例</strong> <blockquote> var myObj = { <br>顶部：“帽子”， <br>底部：“裤子” <br> }; <br> myObj.hasOwnProperty（ “顶部”）; //真的<br> myObj.hasOwnProperty（ “中间”）; //假</blockquote></section>
<section id='description'>
有时检查一个对象属性是否存在是非常有用的，我们可以用<code>.hasOwnProperty(propname)</code>方法来检查对象是否有该属性。如果有返回<code>true</code>，反之返回<code>false</code>。
<strong>示例</strong>
```js
var myObj = {
top: "hat",
bottom: "pants"
};
myObj.hasOwnProperty("top"); // true
myObj.hasOwnProperty("middle"); // false
```
</section>
## Instructions
<section id="instructions">修改函数<code>checkObj</code>以测试<code>myObj</code>的<code>checkProp</code> 。如果找到该属性，则返回该属性的值。如果没有，请返回<code>&quot;Not Found&quot;</code> 。 </section>
<section id='instructions'>
修改函数<code>checkObj</code>检查<code>myObj</code>是否有<code>checkProp</code>属性，如果属性存在，返回属性对应的值，如果不存在，返回<code>"Not Found"</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>checkObj(&quot;gift&quot;)</code>应该返回<code>&quot;pony&quot;</code> 。
- text: <code>checkObj("gift")</code>应该返回<code>"pony"</code>。
testString: assert(checkObj("gift") === "pony");
- text: <code>checkObj(&quot;pet&quot;)</code>应该返回<code>&quot;kitten&quot;</code> 。
- text: <code>checkObj("pet")</code>应该返回<code>"kitten"</code>。
testString: assert(checkObj("pet") === "kitten");
- text: <code>checkObj(&quot;house&quot;)</code>应该返回<code>&quot;Not Found&quot;</code> 。
- text: <code>checkObj("house")</code>应该返回<code>"Not Found"</code>。
testString: assert(checkObj("house") === "Not Found");
```
@ -49,7 +65,6 @@ function checkObj(checkProp) {
// Test your code by modifying these values
checkObj("gift");
```
</div>
@ -61,7 +76,20 @@ checkObj("gift");
## Solution
<section id='solution'>
```js
// solution required
var myObj = {
gift: "pony",
pet: "kitten",
bed: "sleigh"
};
function checkObj(checkProp) {
if(myObj.hasOwnProperty(checkProp)) {
return myObj[checkProp];
} else {
return "Not Found";
}
}
```
</section>

39
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/understand-string-immutability.chinese.md
View File

@ -2,24 +2,43 @@
id: 56533eb9ac21ba0edf2244ba
title: Understand String Immutability
challengeType: 1
videoUrl: ''
localeTitle: 理解字符串不变性
videoUrl: 'https://scrimba.com/c/cWPVaUR'
forumTopicId: 18331
localeTitle: 了解字符串的不变性
---
## Description
<section id="description">在JavaScript中， <code>String</code>值是<dfn>不可变的</dfn> ，这意味着一旦创建它们就不能被更改。例如，以下代码： <blockquote> var myStr =“Bob”; <br> myStr [0] =“J”; </blockquote>无法将<code>myStr</code>的值更改为“Job”，因为<code>myStr</code>的内容无法更改。请注意，这<em>并不</em>意味着<code>myStr</code>不能改变的，只是一个<dfn>字符串</dfn>的单个字符不能改变。更改<code>myStr</code>的唯一方法是为其分配一个新字符串，如下所示： <blockquote> var myStr =“Bob”; <br> myStr =“工作”; </blockquote></section>
<section id='description'>
在 JavaScript 中，<code>字符串</code>的值是 <dfn>不可变的</dfn>，这意味着一旦字符串被创建就不能被改变。
例如，下面的代码：
```js
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>中的唯一方法是重新给它赋一个值，例如：
```js
var myStr = "Bob";
myStr = "Job";
```
</section>
## Instructions
<section id="instructions">更正<code>myStr</code>的赋值，使其包含<code>Hello World</code>的字符串值，使用上面示例中显示的方法。 </section>
<section id='instructions'>
把<code>myStr</code>的值改为<code>Hello World</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>myStr</code>应该具有<code>Hello World</code>的值
- text: message:<code>myStr</code>的值应该是<code>Hello World</code>。
testString: assert(myStr === "Hello World");
- text: 不要更改行上方的代码
- text: 不要修改注释上面的代码。
testString: assert(/myStr = "Jello World"/.test(code));
```
@ -39,6 +58,7 @@ var myStr = "Jello World";
myStr[0] = "H"; // Fix Me
```
</div>
@ -48,7 +68,7 @@ myStr[0] = "H"; // Fix Me
<div id='js-teardown'>
```js
console.info('after the test');
(function(v){return "myStr = " + v;})(myStr);
```
</div>
@ -58,7 +78,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myStr = "Jello World";
myStr = "Hello World";
```
</section>

33
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-boolean-values.chinese.md
View File

@ -2,24 +2,30 @@
id: bd7123c9c441eddfaeb5bdef
title: Understanding Boolean Values
challengeType: 1
videoUrl: ''
localeTitle: 了解布尔值
videoUrl: 'https://scrimba.com/c/c9Me8t4'
forumTopicId: 301176
localeTitle: 理解布尔值
---
## Description
<section id="description">另一种数据类型是<dfn>布尔值</dfn> 。 <code>Booleans</code>可能只是两个值中的一个： <code>true</code>或<code>false</code> 。它们基本上是很少的开关，其中<code>true</code>为“on”而<code>false</code>为“off”。这两个国家是相互排斥的。 <strong>注意</strong> <br> <code>Boolean</code>值永远不会用引号写。 <code>strings</code> <code>&quot;true&quot;</code>和<code>&quot;false&quot;</code>不是<code>Boolean</code> ，在JavaScript中没有特殊含义。 </section>
<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>
## Instructions
<section id="instructions">修改<code>welcomeToBooleans</code>函数，以便在单击运行按钮时返回<code>true</code>而不是<code>false</code> 。 </section>
<section id='instructions'>
修改<code>welcomeToBooleans</code>函数，让它返回<code>true</code>而不是<code>false</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>welcomeToBooleans()</code>函数应该返回一个布尔值（true / false）。
- text: <code>welcomeToBooleans()</code>函数应该返回一个布尔值 &#40;true/false&#41;。
testString: assert(typeof welcomeToBooleans() === 'boolean');
- text: <code>welcomeToBooleans()</code>应该返回true。
- text: <code>welcomeToBooleans()</code>应该返回 true。
testString: assert(welcomeToBooleans() === true);
```
@ -34,13 +40,12 @@ tests:
```js
function welcomeToBooleans() {
// Only change code below this line.
// Only change code below this line.
return false; // Change this line
return false; // Change this line
// Only change code above this line.
// Only change code above this line.
}
```
</div>
@ -50,7 +55,7 @@ return false; // Change this line
<div id='js-teardown'>
```js
console.info('after the test');
welcomeToBooleans();
```
</div>
@ -60,7 +65,11 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
function welcomeToBooleans() {
return true; // Change this line
}
```
</section>

47
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-case-sensitivity-in-variables.chinese.md
View File

@ -2,32 +2,48 @@
id: 56533eb9ac21ba0edf2244ab
title: Understanding Case Sensitivity in Variables
challengeType: 1
videoUrl: ''
localeTitle: 了解变量中的大小写敏感度
videoUrl: 'https://scrimba.com/c/cd6GDcD'
forumTopicId: 18334
localeTitle: 了解变量名区分大小写
---
## Description
<section id="description">在JavaScript中，所有变量和函数名称都区分大小写。这意味着资本化很重要。 <code>MYVAR</code>与<code>MyVar</code>和<code>myvar</code> 。可以有多个具有相同名称但不同外壳的不同变量。强烈建议您为清晰起见， <em>不要</em>使用此语言功能。 <h4>最佳实践</h4>在<dfn>camelCase中用</dfn> JavaScript编写变量名。在<dfn>camelCase中</dfn> ，多字变量名称的第一个单词为小写，每个后续单词的首字母大写。 <strong>例子：</strong> <blockquote> var someVariable; <br> var anotherVariableName; <br> var thisVariableNameIsSoLong; </blockquote></section>
<section id='description'>
在 JavaScript 中所有的变量和函数名都是大小写敏感的。要区别对待大写字母和小写字母。
<code>MYVAR</code>与<code>MyVar</code>和<code>myvar</code>是截然不同的变量。这有可能导致出现多个相似名字的的变量。所以强烈地建议你，为了保持代码清晰不要使用这一特性。
<h4>最佳实践</h4>
使用<dfn>驼峰命名法</dfn>来书写一个 Javascript 变量，在<dfn>驼峰命名法</dfn>中，变量名的第一个单词的首写字母小写，后面的单词的第一个字母大写。
<strong>示例：</strong>
```js
var someVariable;
var anotherVariableName;
var thisVariableNameIsSoLong;
```
</section>
## Instructions
<section id="instructions">修改现有的声明和赋值，使其名称使用<dfn>camelCase</dfn> 。 <br>不要创建任何新变量。 </section>
<section id='instructions'>
修改已声明的变量，让它们的命名符合<dfn>驼峰命名法</dfn>的规范。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>studlyCapVar</code>已定义且值为<code>10</code>
- text: <code>studlyCapVar</code>应该被定义并且值为<code>10</code>。
testString: assert(typeof studlyCapVar !== 'undefined' && studlyCapVar === 10);
- text: <code>properCamelCase</code>已定义且值为<code>&quot;A String&quot;</code>
- text: <code>properCamelCase</code>应该被定义并且值为<code>"A String"</code>。
testString: assert(typeof properCamelCase !== 'undefined' && properCamelCase === "A String");
- text: <code>titleCaseOver</code>已定义，其值为<code>9000</code>
- text: <code>titleCaseOver</code>应该被定义并且值为<code>9000</code>。
testString: assert(typeof titleCaseOver !== 'undefined' && titleCaseOver === 9000);
- text: <code>studlyCapVar</code>应该在声明和赋值部分使用camelCase。
- text: <code>studlyCapVar</code>在声明和赋值时都应该使用驼峰命名法。
testString: assert(code.match(/studlyCapVar/g).length === 2);
- text: <code>properCamelCase</code>应该在声明和赋值部分使用camelCase。
- text: <code>properCamelCase</code> 在声明和赋值时都应该使用驼峰命名法。
testString: assert(code.match(/properCamelCase/g).length === 2);
- text: <code>titleCaseOver</code>应该在声明和赋值部分使用camelCase。
- text: <code>titleCaseOver</code> 在声明和赋值时都应该使用驼峰命名法。
testString: assert(code.match(/titleCaseOver/g).length === 2);
```
@ -49,7 +65,6 @@ var TitleCaseOver;
STUDLYCAPVAR = 10;
PRoperCAmelCAse = "A String";
tITLEcASEoVER = 9000;
```
</div>
@ -61,7 +76,15 @@ tITLEcASEoVER = 9000;
## Solution
<section id='solution'>
```js
// solution required
var studlyCapVar;
var properCamelCase;
var titleCaseOver;
studlyCapVar = 10;
properCamelCase = "A String";
titleCaseOver = 9000;
```
</section>

67
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-undefined-value-returned-from-a-function.chinese.md
View File

@ -2,28 +2,44 @@
id: 598e8944f009e646fc236146
title: Understanding Undefined Value returned from a Function
challengeType: 1
videoUrl: ''
localeTitle: 了解从函数返回的未定义值
videoUrl: 'https://scrimba.com/c/ce2p7cL'
forumTopicId: 301177
localeTitle: 函数也可以返回 undefined
---
## Description
<section id="description">函数可以包含<code>return</code>语句但不必包含。在函数没有<code>return</code>语句的情况下，当您调用它时，该函数处理内部代码但返回的值是<code>undefined</code> 。 <strong>例</strong> <blockquote> var sum = 0; <br> function addSum（num）{ <br> sum = sum + num; <br> } <br> var returnedValue = addSum（3）; //将修改sum，但返回值未定义</blockquote> <code>addSum</code>是一个没有<code>return</code>语句的函数。该函数将更改全局<code>sum</code>变量，但函数的返回值<code>undefined</code> </section>
<section id='description'>
函数一般用<code>return</code>语句来返回值，但这不是必须的。在函数没有<code>return</code>语句的情况下，当你调用它时，该函数会执行内部代码，返回的值是<code>undefined</code>。
<strong>示例</strong>
```js
var sum = 0;
function addSum(num) {
sum = sum + 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>
## Instructions
<section id="instructions">创建一个没有任何参数的函数<code>addFive</code> 。此函数向<code>sum</code>变量添加5，但其返回值<code>undefined</code> 。 </section>
<section id='instructions'>
创建一个没有任何参数的函数<code>addFive</code>。此函数使<code>sum</code>变量加 5，但其返回值是<code>undefined</code>。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>addFive</code>应该是一个函数
- text: <code>addFive</code>应该是一个函数。
testString: assert(typeof addFive === 'function');
- text: <code>sum</code>应该等于8
- text: <code>sum</code>应该等于 8。
testString: assert(sum === 8);
- text: <code>addFive</code>返回值应该是<code>undefined</code>
- text: <code>addFive</code>的返回值应该是<code>undefined</code>。
testString: assert(addFive() === undefined);
- text: 在函数内部，向<code>sum</code>变量添加5
- text: 函数给变量 <code>sum</code> 加 5。
testString: assert(addFive.toString().replace(/\s/g, '').match(/sum=sum\+5|sum\+=5/));
```
@ -44,31 +60,34 @@ function addThree() {
// Only change code below this line
// Only change code above this line
var returnedValue = addFive();
addThree();
addFive();
```
</div>
### After Test
<div id='js-teardown'>
```js
console.info('after the test');
```
</div>
</section>
## Solution
<section id='solution'>
```js
// solution required
// 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();
```
</section>

32
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/understanding-uninitialized-variables.chinese.md
View File

@ -2,28 +2,33 @@
id: 56533eb9ac21ba0edf2244aa
title: Understanding Uninitialized Variables
challengeType: 1
videoUrl: ''
localeTitle: 了解未初始化的变量
videoUrl: 'https://scrimba.com/c/cBa2JAL'
forumTopicId: 18335
localeTitle: 理解未初始化的变量
---
## Description
<section id="description">声明JavaScript变量时，它们的初始值为<code>undefined</code> 。如果对<code>undefined</code>变量进行数学运算，则结果将为<code>NaN</code> ，表示<dfn>“非数字”</dfn> 。如果将字符串与<code>undefined</code>变量连接起来，您将得到一个<code>&quot;undefined&quot;</code>的文字<dfn>字符串</dfn> 。 </section>
<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>
## Instructions
<section id="instructions">初始化三个变量<code>a</code> ， <code>b</code>和<code>c</code>与<code>5</code> ， <code>10</code> ，和<code>&quot;I am a&quot;</code>分别让他们不会<code>undefined</code> 。 </section>
<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>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>a</code>应定义并评估其值为<code>6</code>
- text: <code>a</code>应该被定义，并且值为<code>6</code>。
testString: assert(typeof a === 'number' && a === 6);
- text: 应定义和评估<code>b</code>的值为<code>15</code>
- text: <code>b</code>应该被定义，并且值为<code>15</code>。
testString: assert(typeof b === 'number' && b === 15);
- text: <code>c</code>不应该包含<code>undefined</code>并且值应为“我是一个字符串！”
- text: <code>c</code>的值不能包含<code>undefined</code>，应该为 "I am a String!"。
testString: assert(!/undefined/.test(c) && c === "I am a String!");
- text: 不要更改行下方的代码
- text: 不要修改第二条注释下的代码。
testString: assert(/a = a \+ 1;/.test(code) && /b = b \+ 5;/.test(code) && /c = c \+ " String!";/.test(code));
```
@ -56,7 +61,7 @@ c = c + " String!";
<div id='js-teardown'>
```js
console.info('after the test');
(function(a,b,c){ return "a = " + a + ", b = " + b + ", c = '" + c + "'"; })(a,b,c);
```
</div>
@ -66,7 +71,14 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var a = 5;
var b = 10;
var c = "I am a";
a = a + 1;
b = b + 5;
c = c + " String!";
```
</section>

43
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/updating-object-properties.chinese.md
View File

@ -2,24 +2,44 @@
id: 56bbb991ad1ed5201cd392d1
title: Updating Object Properties
challengeType: 1
videoUrl: ''
videoUrl: 'https://scrimba.com/c/c9yEJT4'
forumTopicId: 18336
localeTitle: 更新对象属性
---
## Description
<section id="description">在创建JavaScript对象之后，您可以随时更新其属性，就像更新任何其他变量一样。您可以使用点或括号表示法进行更新。例如，让我们看看我们的<code>ourDog</code> ： <blockquote> var ourDog = { <br> “名字”：“露营者”， <br> “腿”：4， <br> “尾巴”：1， <br> “朋友们”：[“一切！”] <br> }; </blockquote>由于他是一只特别开心的狗，让我们改名为“快乐露营者”。以下是我们更新对象名称属性的方法： <code>ourDog.name = &quot;Happy Camper&quot;;</code>或者我们的<code>ourDog[&quot;name&quot;] = &quot;Happy Camper&quot;;</code>现在，当我们评估我们的<code>ourDog.name</code> ，而不是获得“Camper”时，我们将获得他的新名字“Happy Camper”。 </section>
<section id='description'>
当你创建了一个对象后，你可以用点操作符或中括号操作符来更新对象的属性。
举个例子，让我们看看<code>ourDog</code>:
```js
var ourDog = {
"name": "Camper",
"legs": 4,
"tails": 1,
"friends": ["everything!"]
};
```
让我们更改它的名称为 "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>
## Instructions
<section id="instructions">更新<code>myDog</code>对象的name属性。让我们将她的名字从“Coder”改为“Happy Coder”。您可以使用点或括号表示法。 </section>
<section id='instructions'>
更新<code>myDog</code>对象的<code>name</code>属性，让它的名字从 "Coder" 变成 "Happy Coder"。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: 将<code>myDog</code>的<code>&quot;name&quot;</code>属性更新为“Happy Coder”。
- text: 更新<code>myDog</code>的<code>"name"</code>属性, 使其等于 "Happy Coder"。
testString: assert(/happy coder/gi.test(myDog.name));
- text: 不要编辑<code>myDog</code>定义
- text: 不要修改<code>myDog</code>的定义。
testString: 'assert(/"name": "Coder"/.test(code));'
```
@ -52,6 +72,7 @@ var myDog = {
// Only change code below this line.
```
</div>
@ -61,7 +82,7 @@ var myDog = {
<div id='js-teardown'>
```js
console.info('after the test');
(function(z){return z;})(myDog);
```
</div>
@ -71,7 +92,15 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var myDog = {
"name": "Coder",
"legs": 4,
"tails": 1,
"friends": ["freeCodeCamp Campers"]
};
myDog.name = "Happy Coder";
```
</section>

31
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-first-character-in-a-string.chinese.md
View File

@ -2,24 +2,32 @@
id: bd7123c9c549eddfaeb5bdef
title: Use Bracket Notation to Find the First Character in a String
challengeType: 1
videoUrl: ''
localeTitle: 使用括号表示法查找字符串中的第一个字符
videoUrl: 'https://scrimba.com/c/ca8JwhW'
forumTopicId: 18341
localeTitle: 使用方括号查找字符串中的第一个字符
---
## Description
<section id="description"> <code>Bracket notation</code>是一种在字符串中的特定<code>index</code>处获取字符的方法。大多数现代编程语言，如JavaScript，都不像人类那样开始计算。它们从0开始。这称为<dfn>基于零的</dfn>索引。例如，单词“Charles”中索引0处的字符是“C”。因此，如果<code>var firstName = &quot;Charles&quot;</code> ，则可以使用<code>firstName[0]</code>获取字符串第一个字母的值。 </section>
<section id='description'>
方括号表示法是一种在字符串中的特定<code>index</code>（索引）处获取字符的方法。
大多数现代编程语言，如JavaScript，不同于人类从 1 开始计数。它们是从 0 开始计数，这被称为 <dfn>基于零</dfn> 的索引。
例如, 在单词 "Charles" 中索引 0 上的字符为 "C"，所以在<code>var firstName = "Charles"</code>中，你可以使用<code>firstName[0]</code>来获得第一个位置上的字符。
</section>
## Instructions
<section id="instructions">使用<dfn>括号表示法</dfn>查找<code>lastName</code>变量中的第一个字符并将其分配给<code>firstLetterOfLastName</code> 。 <strong>暗示</strong> <br>如果卡住，请尝试查看<code>firstLetterOfFirstName</code>变量声明。 </section>
<section id='instructions'>
使用方括号获取变量<code>lastName</code>中的第一个字符，并赋给变量<code>firstLetterOfLastName</code>。
<strong>提示</strong><br>如果你遇到困难了，不妨看看变量<code>firstLetterOfFirstName</code>是如何赋值的。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>firstLetterOfLastName</code>变量的值应为<code>L</code>
- text: <code>firstLetterOfLastName</code>的值应该是<code>L</code>。
testString: assert(firstLetterOfLastName === 'L');
- text: 您应该使用括号表示法。
- text: 你应该使用中括号。
testString: assert(code.match(/firstLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
```
@ -45,6 +53,7 @@ var lastName = "Lovelace";
// Only change code below this line
firstLetterOfLastName = lastName;
```
</div>
@ -54,7 +63,7 @@ firstLetterOfLastName = lastName;
<div id='js-teardown'>
```js
console.info('after the test');
(function(v){return v;})(firstLetterOfLastName);
```
</div>
@ -64,7 +73,13 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var firstLetterOfLastName = "";
var lastName = "Lovelace";
// Only change code below this line
firstLetterOfLastName = lastName[0];
```
</section>

30
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-last-character-in-a-string.chinese.md
View File

@ -2,24 +2,31 @@
id: bd7123c9c451eddfaeb5bdef
title: Use Bracket Notation to Find the Last Character in a String
challengeType: 1
videoUrl: ''
localeTitle: 使用括号表示法查找字符串中的最后一个字符
videoUrl: 'https://scrimba.com/c/cBZQGcv'
forumTopicId: 18342
localeTitle: 使用方括号查找字符串中的最后一个字符
---
## Description
<section id="description">为了获得字符串的最后一个字母，您可以从字符串的长度中减去一个字母。例如，如果<code>var firstName = &quot;Charles&quot;</code> ，则可以使用<code>firstName[firstName.length - 1]</code>获取字符串最后一个字母的值。 </section>
<section id='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>
<section id='instructions'>
使用<dfn>方括号<dfn来取得<code>lastName</code>变量中的最后一个字符。
<strong>提示</strong><br>如果你遇到困难了，不妨看看在<code>lastLetterOfFirstName</code>变量上是怎么做的。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>lastLetterOfLastName</code>应为“e”。
- text: <code>lastLetterOfLastName</code>应该是"e"。
testString: assert(lastLetterOfLastName === "e");
- text: 你必须使用<code>.length</code>来获取最后一个字母。
- text: 你需要使用<code>.length</code>获取最后一个字符。
testString: assert(code.match(/\.length/g).length === 2);
```
@ -42,6 +49,7 @@ var lastName = "Lovelace";
// Only change code below this line.
var lastLetterOfLastName = lastName;
```
</div>
@ -51,7 +59,7 @@ var lastLetterOfLastName = lastName;
<div id='js-teardown'>
```js
console.info('after the test');
(function(v){return v;})(lastLetterOfLastName);
```
</div>
@ -61,7 +69,13 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var firstName = "Ada";
var lastLetterOfFirstName = firstName[firstName.length - 1];
var lastName = "Lovelace";
var lastLetterOfLastName = lastName[lastName.length - 1];
```
</section>

27
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-character-in-a-string.chinese.md
View File

@ -2,24 +2,31 @@
id: bd7123c9c450eddfaeb5bdef
title: Use Bracket Notation to Find the Nth Character in a String
challengeType: 1
videoUrl: ''
localeTitle: 使用括号表示法查找字符串中的第N个字符
videoUrl: 'https://scrimba.com/c/cWPVJua'
forumTopicId: 18343
localeTitle: 使用方括号查找字符串中的第N个字符
---
## Description
<section id="description">您还可以使用<dfn>括号表示法</dfn>来获取字符串中其他位置的字符。请记住，计算机从<code>0</code>开始计数，因此第一个字符实际上是第0个字符。 </section>
<section id='description'>
你也可以使用方括号来获得一个字符串中的其他位置的字符。
请记住，程序是从<code>0</code>开始计数，所以获取第一个字符实际上是[0]。
</section>
## Instructions
<section id="instructions">让我们尝试使用括号表示法将<code>thirdLetterOfLastName</code>设置为等于<code>lastName</code>变量的第三个字母。 <strong>暗示</strong> <br>如果卡住，请尝试查看<code>secondLetterOfFirstName</code>变量声明。 </section>
<section id='instructions'>
让我们使用方括号，把<code>lastName</code>变量的第三个字符赋值给<code>thirdLetterOfLastName</code>。
<strong>提示</strong><br>如果你遇到困难了，看看<code>secondLetterOfFirstName</code>变量是如何做的。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>thirdLetterOfLastName</code>变量的值应为<code>v</code> 。
- text: <code>thirdLetterOfLastName</code>的值应该是<code>v</code>。
testString: assert(thirdLetterOfLastName === 'v');
- text: 您应该使用括号表示法。
- text: 你应该使用方括号。
testString: assert(code.match(/thirdLetterOfLastName\s*?=\s*?lastName\[.*?\]/));
```
@ -42,6 +49,7 @@ var lastName = "Lovelace";
// Only change code below this line.
var thirdLetterOfLastName = lastName;
```
</div>
@ -51,7 +59,7 @@ var thirdLetterOfLastName = lastName;
<div id='js-teardown'>
```js
console.info('after the test');
(function(v){return v;})(thirdLetterOfLastName);
```
</div>
@ -61,7 +69,10 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var lastName = "Lovelace";
var thirdLetterOfLastName = lastName[2];
```
</section>

30
curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-javascript/use-bracket-notation-to-find-the-nth-to-last-character-in-a-string.chinese.md
View File

@ -2,24 +2,31 @@
id: bd7123c9c452eddfaeb5bdef
title: Use Bracket Notation to Find the Nth-to-Last Character in a String
challengeType: 1
videoUrl: ''
localeTitle: 使用括号表示法查找字符串中的第N个到最后一个字符
videoUrl: 'https://scrimba.com/c/cw4vkh9'
forumTopicId: 18344
localeTitle: 使用方括号查找字符串中的第N个字符到最后一个字符
---
## Description
<section id="description">您可以使用我们刚刚用于检索字符串中最后一个字符的相同原理来检索N到最后一个字符。例如，您可以使用<code>firstName[firstName.length - 3]</code>获取<code>var firstName = &quot;Charles&quot;</code>字符串的倒数第三个字母的值</section>
<section id='description'>
我们既可以获取字符串的最后一个字符，也可以用获取字符串的倒数第N个字符。
例如，你可以这样<code>firstName[firstName.length - 3]</code>操作来获得<code>var firstName = "Charles"</code>字符串中的倒数第三个字符。
</section>
## Instructions
<section id="instructions">使用<dfn>括号表示法</dfn>查找<code>lastName</code>字符串中倒数第二个字符。 <strong>暗示</strong> <br>如果卡住，请尝试查看<code>thirdToLastLetterOfFirstName</code>变量声明。 </section>
<section id='instructions'>
使用<dfn>方括号</dfn>来获得<code>lastName</code>字符串中的倒数第二个字符。
<strong>提示</strong><br>如果你遇到困难了，不妨看看<code>thirdToLastLetterOfFirstName</code>变量是如何做到的。
</section>
## Tests
<section id='tests'>
```yml
tests:
- text: <code>secondToLastLetterOfLastName</code>应为“c”。
- text: <code>secondToLastLetterOfLastName</code>应该是"c"。
testString: assert(secondToLastLetterOfLastName === 'c');
- text: 你必须使用<code>.length</code>来获得倒数第二个字母。
- text: 你需要使用<code>.length</code>获取倒数第二个字符。
testString: assert(code.match(/\.length/g).length === 2);
```
@ -42,6 +49,7 @@ var lastName = "Lovelace";
// Only change code below this line
var secondToLastLetterOfLastName = lastName;
```
</div>
@ -51,7 +59,7 @@ var secondToLastLetterOfLastName = lastName;
<div id='js-teardown'>
```js
console.info('after the test');
(function(v){return v;})(secondToLastLetterOfLastName);
```
</div>
@ -61,7 +69,13 @@ console.info('after the test');
## Solution
<section id='solution'>
```js
// solution required
var firstName = "Ada";
var thirdToLastLetterOfFirstName = firstName[firstName.length - 3];
var lastName = "Lovelace";
var secondToLastLetterOfLastName = lastName[lastName.length - 2];
```
</section>

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