diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md index d17c2c3199..7d21d9c0f7 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/boo-who.md @@ -1,71 +1,73 @@ --- id: a77dbc43c33f39daa4429b4f -title: 嘘谁 +title: 基本类型布尔值的检查 challengeType: 5 -videoUrl: '' +forumTopicId: 16000 --- # --description-- -检查参数是否归类为布尔基元。返回true或false。布尔基元是true和false。如果卡住，请记得使用[Read-Search-Ask](http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514) 。尝试配对程序。编写自己的代码。 +检查一个值是否是[基本类型](https://developer.mozilla.org/zh-CN/docs/Glossary/Primitive)中的布尔值（boolean）类型。函数应返回 true 或者 false。 + +基本类型中的布尔值为 true 或者 false。 # --hints-- -`booWho(true)`应该返回true。 +`booWho(true)` 应返回 true。 ```js assert.strictEqual(booWho(true), true); ``` -`booWho(false)`应该返回true。 +`booWho(false)` 应返回 true。 ```js assert.strictEqual(booWho(false), true); ``` -`booWho([1, 2, 3])`应该返回false。 +`booWho([1, 2, 3])` 应返回 false。 ```js assert.strictEqual(booWho([1, 2, 3]), false); ``` -`booWho([].slice)`应该返回false。 +`booWho([].slice)` 应返回 false。 ```js assert.strictEqual(booWho([].slice), false); ``` -`booWho({ "a": 1 })`应该返回false。 +`booWho({ "a": 1 })` 应返回 false。 ```js assert.strictEqual(booWho({ a: 1 }), false); ``` -`booWho(1)`应该返回false。 +`booWho(1)` 应返回 false。 ```js assert.strictEqual(booWho(1), false); ``` -`booWho(NaN)`应该返回false。 +`booWho(NaN)` 应返回 false。 ```js assert.strictEqual(booWho(NaN), false); ``` -`booWho("a")`应该返回false。 +`booWho("a")` 应返回 false。 ```js assert.strictEqual(booWho('a'), false); ``` -`booWho("true")`应该返回false。 +`booWho("true")` 应返回 false。 ```js assert.strictEqual(booWho('true'), false); ``` -`booWho("false")`应该返回false。 +`booWho("false")` 应返回 false。 ```js assert.strictEqual(booWho('false'), false); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md index c378f5ae69..5f0e162d1d 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/chunky-monkey.md @@ -1,17 +1,17 @@ --- id: a9bd25c716030ec90084d8a1 -title: 矮胖的猴子 +title: 分割数组 challengeType: 5 -videoUrl: '' +forumTopicId: 16005 --- # --description-- -编写一个函数，将数组（第一个参数）拆分为`size`的长度（第二个参数），并将它们作为二维数组返回。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +请编写一个函数，该函数将一个数组（第一个参数）拆分成若干长度为 `size`（第二个参数）的子数组，并将它们作为二维数组返回。 # --hints-- -`chunkArrayInGroups(["a", "b", "c", "d"], 2)`应返回`[["a", "b"], ["c", "d"]]` 。 +`chunkArrayInGroups(["a", "b", "c", "d"], 2)` 应返回 `[["a", "b"], ["c", "d"]]`。 ```js assert.deepEqual(chunkArrayInGroups(['a', 'b', 'c', 'd'], 2), [ @@ -20,7 +20,7 @@ assert.deepEqual(chunkArrayInGroups(['a', 'b', 'c', 'd'], 2), [ ]); ``` -`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)`应返回`[[0, 1, 2], [3, 4, 5]]` 。 +`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3)` 应返回 `[[0, 1, 2], [3, 4, 5]]`。 ```js assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [ @@ -29,7 +29,7 @@ assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 3), [ ]); ``` -`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)`应返回`[[0, 1], [2, 3], [4, 5]]` 。 +`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2)` 应返回 `[[0, 1], [2, 3], [4, 5]]`。 ```js assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [ @@ -39,7 +39,7 @@ assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 2), [ ]); ``` -`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)`应该返回`[[0, 1, 2, 3], [4, 5]]` 。 +`chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4)` 应返回 `[[0, 1, 2, 3], [4, 5]]`。 ```js assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [ @@ -48,7 +48,7 @@ assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5], 4), [ ]); ``` -`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)`应该返回`[[0, 1, 2], [3, 4, 5], [6]]` 。 +`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3)` 应返回 `[[0, 1, 2], [3, 4, 5], [6]]`。 ```js assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [ @@ -58,7 +58,7 @@ assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3), [ ]); ``` -`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)`应返回`[[0, 1, 2, 3], [4, 5, 6, 7], [8]]` `chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)` `[[0, 1, 2, 3], [4, 5, 6, 7], [8]]` 。 +`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4)` 应返回 `[[0, 1, 2, 3], [4, 5, 6, 7], [8]]`。 ```js assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [ @@ -68,7 +68,7 @@ assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 4), [ ]); ``` -`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)`应返回`[[0, 1], [2, 3], [4, 5], [6, 7], [8]]` 。 +`chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2)` 应返回 `[[0, 1], [2, 3], [4, 5], [6, 7], [8]]`。 ```js assert.deepEqual(chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6, 7, 8], 2), [ diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md index e1d4865067..e16eecb0d9 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/confirm-the-ending.md @@ -1,35 +1,37 @@ --- id: acda2fb1324d9b0fa741e6b5 -title: 确认结束 +title: 检查字符串结尾 challengeType: 5 -videoUrl: '' +forumTopicId: 16006 --- # --description-- -检查字符串（第一个参数`str` ）是否以给定的目标字符串（第二个参数， `target` ）结束。这个挑战*可以*通过`.endsWith()`中引入的`.endsWith()`方法来解决。但是出于这个挑战的目的，我们希望您使用其中一个JavaScript子字符串方法。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +检查字符串（第一个参数 `str`）是否以给定的目标字符串（第二个参数 `target`）结束。 + +这个挑战*可以*用 ES2015 引入的 `.endsWith()` 方法来解决。但在这个挑战中，请使用 JavaScript 的字符串子串方法或正则表达式来通过挑战，而不要使用 `.endsWith()` 方法。 # --hints-- -`confirmEnding("Bastian", "n")`应该返回true。 +`confirmEnding("Bastian", "n")` 应返回 true。 ```js assert(confirmEnding('Bastian', 'n') === true); ``` -`confirmEnding("Congratulation", "on")`应该返回true。 +`confirmEnding("Congratulation", "on")` 应返回 true。 ```js assert(confirmEnding('Congratulation', 'on') === true); ``` -`confirmEnding("Connor", "n")`应返回false。 +`confirmEnding("Connor", "n")` 应返回 false。 ```js assert(confirmEnding('Connor', 'n') === false); ``` -`confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")`应该返回false。 +`confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification")` 应返回 false。 ```js assert( @@ -40,31 +42,31 @@ assert( ); ``` -`confirmEnding("He has to give me a new name", "name")`应该返回true。 +`confirmEnding("He has to give me a new name", "name")` 应返回 true。 ```js assert(confirmEnding('He has to give me a new name', 'name') === true); ``` -`confirmEnding("Open sesame", "same")`应该返回true。 +`confirmEnding("Open sesame", "same")` 应返回 true。 ```js assert(confirmEnding('Open sesame', 'same') === true); ``` -`confirmEnding("Open sesame", "pen")`应该返回false。 +`confirmEnding("Open sesame", "sage")` 应返回 false。 ```js -assert(confirmEnding('Open sesame', 'pen') === false); +assert(confirmEnding('Open sesame', 'sage') === false); ``` -`confirmEnding("Open sesame", "game")`应该返回false。 +`confirmEnding("Open sesame", "game")` 应返回 false。 ```js assert(confirmEnding('Open sesame', 'game') === false); ``` -`confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")`应该返回虚假。 +`confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain")` 应返回 false。 ```js assert( @@ -75,13 +77,13 @@ assert( ); ``` -`confirmEnding("Abstraction", "action")`应该返回true。 +`confirmEnding("Abstraction", "action")` 应该返回 true。 ```js assert(confirmEnding('Abstraction', 'action') === true); ``` -不要使用内置方法`.endsWith()`来解决挑战。 +不应使用内置方法 `.endsWith()` 来完成挑战。 ```js assert(!/\.endsWith\(.*?\)\s*?;?/.test(code) && !/\['endsWith'\]/.test(code)); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md index be110d34ae..80b341a674 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/convert-celsius-to-fahrenheit.md @@ -1,47 +1,49 @@ --- id: 56533eb9ac21ba0edf2244b3 -title: 将摄氏温度转换为华氏温度 +title: 将摄氏度转换为华氏度 challengeType: 1 -videoUrl: '' +forumTopicId: 16806 --- # --description-- -从摄氏温度转换为华氏温度的算法是以摄氏度乘以`9/5`，再加上`32` 。您将获得一个参数`celsius`代表着摄氏温度。使用已准备好代表华氏温度的变量`fahrenheit`，将`celsius`摄氏温度变量值兑换成华氏温度值，然后存储在`farenheit`变量里。使用以上提到的算法将摄氏温度转换为华氏温度。不需要过多担心函数和返回语句，因为它们将会在未来的挑战中加以解释。目前，只需使用您已经学过的运算符。 +将摄氏度转换为华氏度的计算方式为：摄氏度乘以 `9/5` 然后加上 `32`。 + +输入参数 `celsius` 代表一个摄氏度的温度。请根据上述转换公式，将已定义好的 `fahrenheit` 变量赋值为相应的华氏度的温度值。 # --hints-- -`convertToF(0)`应该返回一个数字 +`convertToF(0)` 应返回一个数字。 ```js assert(typeof convertToF(0) === 'number'); ``` -`convertToF(-30)`应该返回值`-22` +`convertToF(-30)` 应返回 `-22`。 ```js assert(convertToF(-30) === -22); ``` -`convertToF(-10)`应该返回值`14` +`convertToF(-10)` 应返回 `14`。 ```js assert(convertToF(-10) === 14); ``` -`convertToF(0)`应返回值`32` +`convertToF(0)` 应返回 `32`。 ```js assert(convertToF(0) === 32); ``` -`convertToF(20)`应返回值`68` +`convertToF(20)` 应返回 `68`。 ```js assert(convertToF(20) === 68); ``` -`convertToF(30)`应返回值`86` +`convertToF(30)` 应返回 `86`。 ```js assert(convertToF(30) === 86); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md index 5677bae931..ef9d396998 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/factorialize-a-number.md @@ -1,41 +1,49 @@ --- id: a302f7aae1aa3152a5b413bc -title: 对一个数字进行推理 +title: 计算整数的阶乘 challengeType: 5 -videoUrl: '' +forumTopicId: 16013 --- # --description-- -返回提供的整数的阶乘。如果整数用字母n表示，则阶乘是所有小于或等于n的正整数的乘积。因子通常用简写符号`n!`表示`n!`例如： `5! = 1 * 2 * 3 * 4 * 5 = 120`只有大于或等于零的整数才会被提供给该函数。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +返回一个给定整数的阶乘计算结果。 + +对于整数 n，n 的阶乘就是所有小于等于 n 的正整数的乘积。 + +`n` 的阶乘通常用符号 `n!` 来表示。 + +例如：`5! = 1 * 2 * 3 * 4 * 5 = 120` + +在这个挑战中，只有非负整数会作为参数传入函数。 # --hints-- -`factorialize(5)`应该返回一个数字。 +`factorialize(5)` 应返回一个数字。 ```js assert(typeof factorialize(5) === 'number'); ``` -`factorialize(5)`应该返回120。 +`factorialize(5)` 应返回 120。 ```js assert(factorialize(5) === 120); ``` -`factorialize(10)`应返回3628800。 +`factorialize(10)` 应返回 3628800。 ```js assert(factorialize(10) === 3628800); ``` -`factorialize(20)`应该返回2432902008176640000。 +`factorialize(20)` 应返回 2432902008176640000。 ```js assert(factorialize(20) === 2432902008176640000); ``` -`factorialize(0)`应该返回1。 +`factorialize(0)` 应返回 1。 ```js assert(factorialize(0) === 1); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md index 1272b9eddd..6ee5246df6 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/falsy-bouncer.md @@ -1,35 +1,40 @@ --- id: adf08ec01beb4f99fc7a68f2 -title: Falsy Bouncer +title: 过滤数组中的假值 challengeType: 5 -videoUrl: '' +forumTopicId: 16014 --- # --description-- -从数组中删除所有有价值的值。 JavaScript中的Falsy值为`false` ， `null` ， `0` ， `""` ， `undefined`和`NaN` 。提示：尝试将每个值转换为布尔值。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +从数组中移除所有假值（falsy values）。 + +JavaScript 中的假值有 `false`、`null`、`0`、`""`、`undefined`、`NaN`。 + +提示：可以考虑将每个值都转换为布尔值（boolean）。 + # --hints-- -`bouncer([7, "ate", "", false, 9])`应该返回`[7, "ate", 9]` 。 +`bouncer([7, "ate", "", false, 9])` 应返回 `[7, "ate", 9]`。 ```js assert.deepEqual(bouncer([7, 'ate', '', false, 9]), [7, 'ate', 9]); ``` -`bouncer(["a", "b", "c"])`应返回`["a", "b", "c"]` 。 +`bouncer(["a", "b", "c"])` 应返回 `["a", "b", "c"]`。 ```js assert.deepEqual(bouncer(['a', 'b', 'c']), ['a', 'b', 'c']); ``` -`bouncer([false, null, 0, NaN, undefined, ""])`应返回`[]` 。 +`bouncer([false, null, 0, NaN, undefined, ""])` 应返回 `[]`。 ```js assert.deepEqual(bouncer([false, null, 0, NaN, undefined, '']), []); ``` -`bouncer([1, null, NaN, 2, undefined])`应该返回`[1, 2]` 。 +`bouncer([1, null, NaN, 2, undefined])`应返回 `[1, 2]`。 ```js assert.deepEqual(bouncer([null, NaN, 1, 2, undefined]), [1, 2]); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md index 26c12530d2..8d30c6c24b 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/find-the-longest-word-in-a-string.md @@ -1,17 +1,19 @@ --- id: a26cbbe9ad8655a977e1ceb5 -title: 找到字符串中最长的单词 +title: 找出字符串中的最长单词 challengeType: 5 -videoUrl: '' +forumTopicId: 16015 --- # --description-- -返回所提供句子中最长单词的长度。您的回答应该是一个数字。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +返回给出的句子中，最长单词的长度。 + +函数的返回值应是一个数字。 # --hints-- -`findLongestWordLength("The quick brown fox jumped over the lazy dog")`应该返回一个数字。 +`findLongestWordLength("The quick brown fox jumped over the lazy dog")` 应返回一个数字。 ```js assert( @@ -21,7 +23,7 @@ assert( ); ``` -`findLongestWordLength("The quick brown fox jumped over the lazy dog")`应该返回6。 +`findLongestWordLength("The quick brown fox jumped over the lazy dog")` 应返回 6。 ```js assert( @@ -29,19 +31,19 @@ assert( ); ``` -`findLongestWordLength("May the force be with you")`应该返回5。 +`findLongestWordLength("May the force be with you")` 应返回 5。 ```js assert(findLongestWordLength('May the force be with you') === 5); ``` -`findLongestWordLength("Google do a barrel roll")`应返回6。 +`findLongestWordLength("Google do a barrel roll")` 应返回 6。 ```js assert(findLongestWordLength('Google do a barrel roll') === 6); ``` -`findLongestWordLength("What is the average airspeed velocity of an unladen swallow")`应该返回8。 +`findLongestWordLength("What is the average airspeed velocity of an unladen swallow")` 应返回 8。 ```js assert( @@ -51,7 +53,7 @@ assert( ); ``` -`findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")`应该返回19。 +`findLongestWordLength("What if we try a super-long word such as otorhinolaryngology")` 应返回 19。 ```js assert( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md index 1a2782d6f3..2b6294526e 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/finders-keepers.md @@ -1,17 +1,17 @@ --- id: a6e40f1041b06c996f7b2406 -title: Finders Keepers +title: 按参数过滤数组 challengeType: 5 -videoUrl: '' +forumTopicId: 16016 --- # --description-- -创建一个查看数组（第一个参数）的函数，并返回数组中传递真值测试的第一个元素（第二个参数）。如果没有元素通过测试，则返回undefined。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。尝试配对程序。编写自己的代码。 +请写一个函数来检查数组（第一个参数 `arr`）中的元素，并返回数组中第一个通过校验测试的元素。其中，“通过校验测试”指的是对于数组中的一个元素 `x`，若 `func(x)` 返回的结果为 `true`，则校验测试通过。如果没有元素通过测试，请返回 `undefined`。 # --hints-- -`findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })`应该返回8。 +`findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; })` 应返回 8。 ```js assert.strictEqual( @@ -22,7 +22,7 @@ assert.strictEqual( ); ``` -`findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })`应返回undefined。 +`findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; })` 应返回 undefined。 ```js assert.strictEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md index c3e918b22e..2b3369fd14 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/mutations.md @@ -1,69 +1,99 @@ --- id: af2170cad53daa0770fabdea -title: 突变 +title: 比较字符串 challengeType: 5 -videoUrl: '' +forumTopicId: 16025 --- # --description-- -如果数组的第一个元素中的字符串包含数组第二个元素中字符串的所有字母，则返回true。例如， `["hello", "Hello"]`应该返回true，因为第二个字符串中的所有字母都出现在第一个字母中，忽略大小写。参数`["hello", "hey"]`应返回false，因为字符串“hello”不包含“y”。最后， `["Alien", "line"]`应该返回true，因为“line”中的所有字母都出现在“Alien”中。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +输入参数是一个数组，其中包含两个字符串元素。如果数组里的第一个字符串包含了第二个字符串中的所有字母，则返回 true。 + +例如，`["hello", "Hello"]` 应该返回 true。因为在忽略大小写的情况下，第一个字符串中包含了第二个字符串里出现的所有字母。 + +而 `["hello", "hey"]` 应该返回 false。因为第一个字符串 "hello" 没有包含字母 "y"。 + +最后，`["Alien", "line"]` 应该返回 true。因为 "line" 中的所有字母都出现在了 "Alien" 中。 # --hints-- -`mutation(["hello", "hey"])`应该返回false。 +`mutation(["hello", "hey"])` 应返回 false。 ```js assert(mutation(['hello', 'hey']) === false); ``` -`mutation(["hello", "Hello"])`应该返回true。 +`mutation(["hello", "Hello"])` 应返回 true。 ```js assert(mutation(['hello', 'Hello']) === true); ``` -`mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])`应该返回true。 +`mutation(["zyxwvutsrqponmlkjihgfedcba", "qrstu"])` 应返回 true。 ```js assert(mutation(['zyxwvutsrqponmlkjihgfedcba', 'qrstu']) === true); ``` -`mutation(["Mary", "Army"])`应该返回true。 +`mutation(["Mary", "Army"])` 应返回 true。 ```js assert(mutation(['Mary', 'Army']) === true); ``` -`mutation(["Mary", "Aarmy"])`应该返回true。 +`mutation(["Mary", "Aarmy"])` 应返回 true。 ```js assert(mutation(['Mary', 'Aarmy']) === true); ``` -`mutation(["Alien", "line"])`应该返回true。 +`mutation(["Alien", "line"])` 应返回 true。 ```js assert(mutation(['Alien', 'line']) === true); ``` -`mutation(["floor", "for"])`应该返回true。 +`mutation(["floor", "for"])` 应返回 true。 ```js assert(mutation(['floor', 'for']) === true); ``` -`mutation(["hello", "neo"])`应该返回false。 +`mutation(["hello", "neo"])` 应返回 false。 ```js assert(mutation(['hello', 'neo']) === false); ``` -`mutation(["voodoo", "no"])`应该返回false。 +`mutation(["voodoo", "no"])` 应返回 false。 ```js assert(mutation(['voodoo', 'no']) === false); ``` +`mutation(["voodoo", "no"])` 应返回 false。 + +```js +assert(mutation(['voodoo', 'no']) === false); +``` + +`mutation(["ate", "date"]` 应返回 false。 + +```js +assert(mutation(['ate', 'date']) === false); +``` + +`mutation(["Tiger", "Zebra"])` 应返回 false。 + +```js +assert(mutation(['Tiger', 'Zebra']) === false); +``` + +`mutation(["Noel", "Ole"])` 应返回 true。 + +```js +assert(mutation(['Noel', 'Ole']) === true); +``` + # --solutions-- diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md index ea797fb2cc..7a52c8b183 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/repeat-a-string-repeat-a-string.md @@ -1,57 +1,66 @@ --- id: afcc8d540bea9ea2669306b6 -title: 重复一个字符串重复字符串 +title: 重复输出字符串 challengeType: 5 -videoUrl: '' +forumTopicId: 16041 --- # --description-- 为`num` times（第二个参数）重复给定的字符串`str` （第一个参数）。如果`num`不是正数，则返回空字符串。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +将一个给定的字符串 `str`（第一个参数）重复输出 `num`（第二个参数）次。如果 `num` 不是正数，返回空字符串。在这个挑战中，请不要使用 JavaScript 内置的 `.repeat()` 方法。 + + # --hints-- -`repeatStringNumTimes("*", 3)`应该返回`"***"` 。 +`repeatStringNumTimes("*", 3)` 应返回 `"***"`。 ```js assert(repeatStringNumTimes('*', 3) === '***'); ``` -`repeatStringNumTimes("abc", 3)`应该返回`"abcabcabc"` 。 +`repeatStringNumTimes("abc", 3)` 应返回 `"abcabcabc"`。 ```js assert(repeatStringNumTimes('abc', 3) === 'abcabcabc'); ``` -`repeatStringNumTimes("abc", 4)`应返回`"abcabcabcabc"` 。 +`repeatStringNumTimes("abc", 4)` 应返回 `"abcabcabcabc"`。 ```js assert(repeatStringNumTimes('abc', 4) === 'abcabcabcabc'); ``` -`repeatStringNumTimes("abc", 1)`应该返回`"abc"` 。 +`repeatStringNumTimes("abc", 1)` 应返回 `"abc"`。 ```js assert(repeatStringNumTimes('abc', 1) === 'abc'); ``` -`repeatStringNumTimes("*", 8)`应该返回`"********"` 。 +`repeatStringNumTimes("*", 8)` 应返回 `"********"`。 ```js assert(repeatStringNumTimes('*', 8) === '********'); ``` -`repeatStringNumTimes("abc", -2)`应返回`""` 。 +`repeatStringNumTimes("abc", -2)` 应返回 `""`。 ```js assert(repeatStringNumTimes('abc', -2) === ''); ``` -不应使用内置的`repeat()`方法 +不应使用内置的 `repeat()` 方法。 ```js assert(!/\.repeat/g.test(code)); ``` +`repeatStringNumTimes("abc", 0)` 应返回 `""`。 + +```js +assert(repeatStringNumTimes('abc', 0) === ''); +``` + # --solutions-- diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md index 48791d2534..cacf8dbb1b 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/return-largest-numbers-in-arrays.md @@ -1,17 +1,19 @@ --- id: a789b3483989747d63b0e427 -title: 返回数组中的最大数字 +title: 找出多个数组中的最大数字 challengeType: 5 -videoUrl: '' +forumTopicId: 16042 --- # --description-- -返回一个数组，该数组由每个提供的子数组中的最大数字组成。为简单起见，提供的数组将包含4个子数组。请记住，您可以使用简单的for循环遍历数组，并使用数组语法`arr[i]`访问每个成员。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +请返回一个数组，该数组由参数中每个子数组中的最大数字组成。为简单起见，给出的数组总会包含 4 个子数组。 + +别忘了，你可以通过 for 循环遍历一个数组，并用 `arr[i]` 的写法来访问数组中的元素。 # --hints-- -`largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])`应该返回一个数组。 +`largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])` 应返回一个数组。 ```js assert( @@ -24,7 +26,7 @@ assert( ); ``` -`largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])`应该返回`[27, 5, 39, 1001]` `largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])` `[27, 5, 39, 1001]` 。 +`largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]])` 应返回 `[27, 5, 39, 1001]`。 ```js assert.deepEqual( @@ -38,7 +40,7 @@ assert.deepEqual( ); ``` -`largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])`应该返回`[9, 35, 97, 1000000]` `largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])` `[9, 35, 97, 1000000]` 。 +`largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]])` 应返回 `[9, 35, 97, 1000000]`。 ```js assert.deepEqual( @@ -52,7 +54,7 @@ assert.deepEqual( ); ``` -`largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])`应该返回`[25, 48, 21, -3]` 。 +`largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]])` 应返回 `[25, 48, 21, -3]`。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md index 2ecf03d248..e40472754f 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/reverse-a-string.md @@ -2,34 +2,38 @@ id: a202eed8fc186c8434cb6d61 title: 反转字符串 challengeType: 5 -videoUrl: '' +forumTopicId: 16043 --- # --description-- -反转提供的字符串。您可能需要先将字符串转换为数组，然后才能将其反转。您的结果必须是字符串。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +请反转传入函数的字符串。 + +在反转字符串之前，你可能需要将其切分成包含字符的数组。 + +函数的返回结果应为字符串。 # --hints-- -`reverseString("hello")`应该返回一个字符串。 +`reverseString("hello")` 应返回一个字符串。 ```js assert(typeof reverseString('hello') === 'string'); ``` -`reverseString("hello")`应该变成`"olleh"` 。 +`reverseString("hello")` 应返回 `"olleh"`。 ```js assert(reverseString('hello') === 'olleh'); ``` -`reverseString("Howdy")`应该变成`"ydwoH"` 。 +`reverseString("Howdy")` 应返回 `"ydwoH"`。 ```js assert(reverseString('Howdy') === 'ydwoH'); ``` -`reverseString("Greetings from Earth")`应返回`"htraE morf sgniteerG"` 。 +`reverseString("Greetings from Earth")` 应返回 `"htraE morf sgniteerG"`。 ```js assert(reverseString('Greetings from Earth') === 'htraE morf sgniteerG'); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md index 577f52e923..147d54aeac 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/slice-and-splice.md @@ -1,29 +1,35 @@ --- id: 579e2a2c335b9d72dd32e05c -title: 切片和拼接 +title: Slice 与 Splice challengeType: 5 forumTopicId: 301148 --- # --description-- -您将获得两个数组和一个索引。使用数组方法`slice`和`splice`按顺序将第一个数组的每个元素复制到第二个数组中。开始在第二个数组的索引`n`处插入元素。返回结果数组。函数运行后，输入数组应保持不变。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +本挑战的输入参数为两个数组和一个索引值。 + +请使用数组的 `slice` 和 `splice` 方法，将第一个数组中的所有元素依次复制到第二个数组中。 + +请注意，你需要从第二个数组索引值为 `n`（函数的第三个参数）的地方开始插入。 + +最后，请返回插入元素后的数组。作为输入参数的两个数组在函数执行前后应保持不变。 # --hints-- -`frankenSplice([1, 2, 3], [4, 5], 1)`应该返回`[4, 1, 2, 3, 5]`。 +`frankenSplice([1, 2, 3], [4, 5], 1)` 应返回 `[4, 1, 2, 3, 5]`。 ```js assert.deepEqual(frankenSplice([1, 2, 3], [4, 5], 1), [4, 1, 2, 3, 5]); ``` -`frankenSplice([1, 2], ["a", "b"], 1)` 应返回 `["a", 1, 2, "b"]` +`frankenSplice([1, 2], ["a", "b"], 1)` 应返回 `["a", 1, 2, "b"]`。 ```js assert.deepEqual(frankenSplice(testArr1, testArr2, 1), ['a', 1, 2, 'b']); ``` -`frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)` 应该返回 `["head", "shoulders", "claw", "tentacle", "knees", "toes"]` +`frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2)` 应返回 `["head", "shoulders", "claw", "tentacle", "knees", "toes"]`。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md index 179a869c58..005eee45cd 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/title-case-a-sentence.md @@ -1,35 +1,37 @@ --- id: ab6137d4e35944e21037b769 -title: 标题案例句子 +title: 句中单词首字母大写 challengeType: 5 -videoUrl: '' +forumTopicId: 16088 --- # --description-- -返回提供的字符串，每个单词的首字母大写。确保单词的其余部分为小写。出于本练习的目的，您还应该将诸如“the”和“of”之类的连接词大写。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +请将传入的字符串中，每个单词的第一个字母变成大写并返回。注意除首字母外，其余的字符都应是小写的。 + +另外请注意，像是 “the”、“of” 之类的连接词的首字母也要大写。 # --hints-- -`titleCase("I'm a little tea pot")`应该返回一个字符串。 +`titleCase("I'm a little tea pot")` 应返回一个字符串。 ```js assert(typeof titleCase("I'm a little tea pot") === 'string'); ``` -`titleCase("I'm a little tea pot")`应该归还`I'm A Little Tea Pot` 。 +`titleCase("I'm a little tea pot")` 应返回 `I'm A Little Tea Pot`。 ```js assert(titleCase("I'm a little tea pot") === "I'm A Little Tea Pot"); ``` -`titleCase("sHoRt AnD sToUt")`应返回`Short And Stout` 。 +`titleCase("sHoRt AnD sToUt")` 应返回 `Short And Stout`。 ```js assert(titleCase('sHoRt AnD sToUt') === 'Short And Stout'); ``` -`titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")` `Here Is My Handle Here Is My Spout` `titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")`应该回到`Here Is My Handle Here Is My Spout` 。 +`titleCase("HERE IS MY HANDLE HERE IS MY SPOUT")` 应返回 `Here Is My Handle Here Is My Spout`。 ```js assert( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md index fa4f3a1b96..4ad0c0475d 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/truncate-a-string.md @@ -2,16 +2,16 @@ id: ac6993d51946422351508a41 title: 截断字符串 challengeType: 5 -videoUrl: '' +forumTopicId: 16089 --- # --description-- -如果字符串（第一个参数）长于给定的最大字符串长度（第二个参数），则截断该字符串。返回带有`...`结尾的截断字符串。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +如果传入的字符串（第一个参数）的长度大于传入的值（第二个参数），请在这个位置截断它并在后面加上 `...`，然后返回结果。 # --hints-- -`truncateString("A-tisket a-tasket A green and yellow basket", 8)`应该返回“A-tisket ......”。 +`truncateString("A-tisket a-tasket A green and yellow basket", 8)` 应返回 "A-tisket..."。 ```js assert( @@ -20,7 +20,7 @@ assert( ); ``` -`truncateString("Peter Piper picked a peck of pickled peppers", 11)`应该回归“Peter Piper ......”。 +`truncateString("Peter Piper picked a peck of pickled peppers", 11)` 应返回 "Peter Piper..."。 ```js assert( @@ -29,7 +29,7 @@ assert( ); ``` -`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)`应该返回“A-tisket a-tasket A green and yellow basket”。 +`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length)` 应返回 "A-tisket a-tasket A green and yellow basket"。 ```js assert( @@ -40,7 +40,7 @@ assert( ); ``` -`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)`应返回“A-tisket a-tasket A green and yellow basket”。 +`truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2)` 应返回 "A-tisket a-tasket A green and yellow basket"。 ```js assert( @@ -51,13 +51,13 @@ assert( ); ``` -`truncateString("A-", 1)`应返回“A ...”。 +`truncateString("A-", 1)` 应返回 "A..."。 ```js assert(truncateString('A-', 1) === 'A...'); ``` -`truncateString("Absolutely Longer", 2)`应返回“Ab ...”。 +`truncateString("Absolutely Longer", 2)` 应返回 "Ab..."。 ```js assert(truncateString('Absolutely Longer', 2) === 'Ab...'); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md index 6d11046bd9..e785ed71f2 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-algorithm-scripting/where-do-i-belong.md @@ -1,107 +1,111 @@ --- id: a24c1a4622e3c05097f71d67 -title: 我属于哪里？ +title: 找出元素在排序后数组中的索引 challengeType: 5 -videoUrl: '' +forumTopicId: 16094 --- # --description-- -返回一个值（第二个参数）应该在排序后插入数组（第一个参数）的最低索引。返回的值应该是一个数字。例如， `getIndexToIns([1,2,3,4], 1.5)`应返回`1`因为它大于`1` （索引0），但小于`2` （索引1）。同样， `getIndexToIns([20,3,5], 19)`应返回`2`因为一旦数组已经排序，它将看起来像`[3,5,20]` ， `19`小于`20` （索引2）并且大于`5` （指数1）。如果卡住，请记得使用[Read-Search-Ask](https://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck-coding/19514) 。编写自己的代码。 +第一个参数的数组在排序后，将一个值（第二个参数）插入该数组，并使数组保持有序。返回这个新插入元素的**最小**索引值（应为一个数字）。 + +例如，`getIndexToIns([1,2,3,4], 1.5)` 应该返回 `1` 因为 `1.5` 大于 `1`（索引为 0）且小于 `2`（索引为 1）。 + +同样地，`getIndexToIns([20,3,5], 19)` 应该返回 `2`。因为数组排序后会变成 `[3,5,20]`，而 `19` 小于 `20`（索引为 2）且大于 `5`（索引为 1）。 # --hints-- -`getIndexToIns([10, 20, 30, 40, 50], 35)`应返回`3` 。 +`getIndexToIns([10, 20, 30, 40, 50], 35)` 应返回 `3`。 ```js assert(getIndexToIns([10, 20, 30, 40, 50], 35) === 3); ``` -`getIndexToIns([10, 20, 30, 40, 50], 35)`应返回一个数字。 +`getIndexToIns([10, 20, 30, 40, 50], 35)` 应返回一个数字。 ```js assert(typeof getIndexToIns([10, 20, 30, 40, 50], 35) === 'number'); ``` -`getIndexToIns([10, 20, 30, 40, 50], 30)`应该返回`2` 。 +`getIndexToIns([10, 20, 30, 40, 50], 30)` 应返回 `2`。 ```js assert(getIndexToIns([10, 20, 30, 40, 50], 30) === 2); ``` -`getIndexToIns([10, 20, 30, 40, 50], 30)`应该返回一个数字。 +`getIndexToIns([10, 20, 30, 40, 50], 30)` 应返回一个数字。 ```js assert(typeof getIndexToIns([10, 20, 30, 40, 50], 30) === 'number'); ``` -`getIndexToIns([40, 60], 50)`应返回`1` 。 +`getIndexToIns([40, 60], 50)` 应返回 `1`。 ```js assert(getIndexToIns([40, 60], 50) === 1); ``` -`getIndexToIns([40, 60], 50)`应返回一个数字。 +`getIndexToIns([40, 60], 50)` 应返回一个数字。 ```js assert(typeof getIndexToIns([40, 60], 50) === 'number'); ``` -`getIndexToIns([3, 10, 5], 3)`应该返回`0` 。 +`getIndexToIns([3, 10, 5], 3)` 应返回 `0`。 ```js assert(getIndexToIns([3, 10, 5], 3) === 0); ``` -`getIndexToIns([3, 10, 5], 3)`应返回一个数字。 +`getIndexToIns([3, 10, 5], 3)` 应返回一个数字。 ```js assert(typeof getIndexToIns([3, 10, 5], 3) === 'number'); ``` -`getIndexToIns([5, 3, 20, 3], 5)`应返回`2` 。 +`getIndexToIns([5, 3, 20, 3], 5)` 应返回 `2`。 ```js assert(getIndexToIns([5, 3, 20, 3], 5) === 2); ``` -`getIndexToIns([5, 3, 20, 3], 5)`应返回一个数字。 +`getIndexToIns([5, 3, 20, 3], 5)` 应返回一个数字。 ```js assert(typeof getIndexToIns([5, 3, 20, 3], 5) === 'number'); ``` -`getIndexToIns([2, 20, 10], 19)`应该返回`2` 。 +`getIndexToIns([2, 20, 10], 19)` 应返回 `2`。 ```js assert(getIndexToIns([2, 20, 10], 19) === 2); ``` -`getIndexToIns([2, 20, 10], 19)`应返回一个数字。 +`getIndexToIns([2, 20, 10], 19)` 应返回一个数字。 ```js assert(typeof getIndexToIns([2, 20, 10], 19) === 'number'); ``` -`getIndexToIns([2, 5, 10], 15)`应该返回`3` 。 +`getIndexToIns([2, 5, 10], 15)` 应返回 `3`。 ```js assert(getIndexToIns([2, 5, 10], 15) === 3); ``` -`getIndexToIns([2, 5, 10], 15)`应返回一个数字。 +`getIndexToIns([2, 5, 10], 15)` 应返回一个数字。 ```js assert(typeof getIndexToIns([2, 5, 10], 15) === 'number'); ``` -`getIndexToIns([], 1)`应该返回`0` 。 +`getIndexToIns([], 1)`应该返回 `0`。 ```js assert(getIndexToIns([], 1) === 0); ``` -`getIndexToIns([], 1)`应该返回一个数字。 +`getIndexToIns([], 1)` 应返回一个数字。 ```js assert(typeof getIndexToIns([], 1) === 'number'); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md index 5faf0a3a11..196b97cdbd 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.md @@ -1,13 +1,13 @@ --- id: 5a661e0f1068aca922b3ef17 -title: 使用方括号访问数组的内容 +title: 使用方括号访问数组的元素 challengeType: 1 forumTopicId: 301149 --- # --description-- -所有数据结构的基本特性是，它们不仅能够存储数据，我们还能够按照需求来访问存放在其中的数据。我们已经学习了如何创建一个数组结构，现在让我们开始学习如何访问这个数组结构中的数据。 +所有数据结构的基本特性是，它们不仅可以存储数据，还可以让我们按需访问存放在其中的数据。我们已经学习了如何创建数组，现在让我们来学习如何访问数组中的数据。 我们先定义一个包含 3 个元素的数组： @@ -15,47 +15,47 @@ forumTopicId: 301149 let ourArray = ["a", "b", "c"]; ``` -在一个数组结构中，其内部的每个元素都有一个与之对应的索引（index）。索引是该元素在数组中的位置，可被用于引用该元素。但需要注意的是，JavaScript 数组的索引是从0开始的（zero-indexed），即一个数组的第一个元素是在数组中的***第 0 个***位置，而不是第 1 个位置。 要从一个数组中获取一个元素，我们可以在一个数组变量名的后面加一个使用“方括号”括起来的索引。这叫做方括号符号（bracket notation）。 例如我们要从`ourArray`数组变量中获取数据元素`"a"`并将其赋值给一个变量，我们可以编写如下所示的代码： +在数组中，内部的每个元素都有一个与之对应的索引（index）。索引既是该元素在数组中的位置，也是我们访问该元素的参考。需要注意的是，JavaScript 数组的索引是从 0 开始的（这种从 0 开始的规则叫做 zero-indexed），即数组的第一个元素是在数组中的***第 0 个***位置，而不是第 1 个位置。要从数组中获取一个元素，我们可以在数组字面量后面加一个用方括号（`[]`）括起来的索引。不过习惯上，我们会通过表示数组的变量名来访问，而不是直接通过字面量。这种从数组中读取元素的方式叫做方括号表示法（bracket notation）。如果我们要从数组 `ourArray` 中获取数据元素 `"a"` 并将其赋值给另一个变量，可以这样写： ```js let ourVariable = ourArray[0]; // ourVariable 的值为 "a" ``` -除了使用 “索引” 来获取某个元素值以外，你还可以通过类似的方法来*设置*一个索引位置所对应的元素值： +除了使用索引来获取某个元素值以外，你还可以通过类似的写法来*设置*一个索引位置的元素值： ```js ourArray[1] = "not b anymore"; // ourArray 现在的值为 ["a", "not b anymore", "c"]; ``` -我们现在已经利用方括号将索引为 1 的元素从`"b"`设置为了`"not b anymore"`。 +在上面的代码中，我们用方括号表示法把索引为 1 的元素从 `"b"` 改成了 `"not b anymore"`。 # --instructions-- -在本挑战中，请你将`myArray`中第二个元素（索引`1`）设置为除了`"b"`以外的任意值。 +在本挑战中，请将 `myArray` 中的第二个元素（索引为 `1`）设置为除了 `"b"` 以外的任意值。 # --hints-- -`myArray[0]`等于`"a"` +`myArray[0]` 应为 `"a"`。 ```js assert.strictEqual(myArray[0], 'a'); ``` -`myArray[1]`不再设置为`"b"` +`myArray[1]` 不应为 `"b"`。 ```js assert.notStrictEqual(myArray[1], 'b'); ``` -`myArray[2]`等于`"c"` +`myArray[2]` 应为 `"c"`。 ```js assert.strictEqual(myArray[2], 'c'); ``` -`myArray[3]`等于`"d"` +`myArray[3]` 应为 `"d"`。 ```js assert.strictEqual(myArray[3], 'd'); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md index 925986e588..b0d5b67619 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.md @@ -7,28 +7,28 @@ forumTopicId: 301150 # --description-- -在关于对象的第一个挑战中，我们提到可以在方括号符号中用一个变量作为属性名来访问属性值。假设一个超市的收银台的程序中使用了一个`foods`对象，并且有一些程序逻辑会设置`selectedFood`，我们需要查询`foods`对象来检查某种食物是否存在，我们可以这样写检查逻辑： +在关于对象的第一个挑战中，我们提到可以在一对方括号中用一个变量作为属性名来访问属性的值。假设一个超市收银台程序中有一个 `foods` 对象，并且有一个函数会设置 `selectedFood`；如果我们需要查询 `foods` 对象中，某种食物是否存在，可以这样实现： ```js let selectedFood = getCurrentFood(scannedItem); let inventory = foods[selectedFood]; ``` -上述代码会先计算`selectedFood`变量的值，并返回`foods`对象中以该值命名的属性对应的值，若没有以该值命名的属性则会返回`undefined`。有时候对象的属性名在运行之前是不确定的，或者我们需要动态地访问对象的属性，这时方括号符号就会很有用。 +上述代码会先读取 `selectedFood` 变量的值，并返回 `foods` 对象中以该值命名的属性所对应的属性值。若没有以该值命名的属性，则会返回 `undefined`。有时候对象的属性名在运行之前是不确定的，或者我们需要动态地访问对象的属性值。在这些场景下，方括号表示法就变得十分有用。 # --instructions-- -我们已经定义了一个`checkInventory`函数，它接受一个被扫描到的商品名作为输入参数。它要返回`foods`对象中以`scannedItem`的值命名的属性的值。只有有效的属性名会作为参数传入`checkInventory`，你在完成挑战时不需处理参数无效的情况。 +我们已经定义了 `checkInventory` 函数，它接受一个被扫描到的商品名作为输入参数。请让这个函数返回 `foods` 对象中，以 `scannedItem` 的值所命名的属性对应的属性值。在本挑战中，只有合理有效的属性名会作为参数传入 `checkInventory`，因此你不需要处理参数无效的情况。 # --hints-- -`checkInventory`是一个函数 +`checkInventory` 应是一个函数。 ```js assert.strictEqual(typeof checkInventory, 'function'); ``` -`foods`对象应该只有以下键值对： `apples: 25` ， `oranges: 32` ， `plums: 28` ， `bananas: 13` ， `grapes: 35` ， `strawberries: 27` +`foods` 对象应只包含以下键值对：`apples: 25`、`oranges: 32`、`plums: 28`、`bananas: 13`、`grapes: 35`、`strawberries: 27`。 ```js assert.deepEqual(foods, { @@ -41,19 +41,19 @@ assert.deepEqual(foods, { }); ``` -`checkInventory("apples")`应该返回`25` +`checkInventory("apples")` 应返回 `25`。 ```js assert.strictEqual(checkInventory('apples'), 25); ``` -`checkInventory("bananas")`应该返回`13` +`checkInventory("bananas")` 应返回 `13`。 ```js assert.strictEqual(checkInventory('bananas'), 13); ``` -`checkInventory("strawberries")`应该返回`27` +`checkInventory("strawberries")` 应返回 `27`。 ```js assert.strictEqual(checkInventory('strawberries'), 27); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md index 4138ed1786..e20d2bbde9 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.md @@ -1,15 +1,15 @@ --- id: 587d78b2367417b2b2512b0e -title: 使用 push() 和 unshift() 添加项目到数组中 +title: 使用 push() 和 unshift() 为数组添加元素 challengeType: 1 forumTopicId: 301151 --- # --description-- -一个数组的长度与其包含的数据类型一样，是不固定的。数组可以包含任意数量的元素，可以不限次数地往数组中添加元素或者从中移除元素，或者说数组是可变的（mutable）。在本挑战中，我们要学习两个以编程方式修改数组的方法：`Array.push()`和`Array.unshift()`。 +数组的长度与数组能包含的数据类型一样，都是不固定的。数组可以包含任意数量的元素，可以不限次数地往数组中添加元素或者从中移除元素。总之，数组是可变的（mutable）。在本挑战中，我们要学习两种修改数组的方法：`Array.push()` 和 `Array.unshift()`。 -这两个方法都接收一个或多个元素作为参数；对一个数组调用这两个方法都可以将输入的元素插入到该数组中；`push()`方法将元素插入到一个数组的末尾，而`unshift()`方法将元素插入到一个数组的开头。请看以下例子： +这两个方法都接收一个或多个元素作为参数，并会将参数中的元素添加到该数组中。`push()` 方法会将元素插入到数组的末尾，而 `unshift()` 方法会将元素插入到数组的开头。请看以下例子： ```js let twentyThree = 'XXIII'; @@ -22,15 +22,15 @@ romanNumerals.push(twentyThree); // 数组现在为 ['XIX', 'XX', 'XXI', 'XXII', 'XXIII'] ``` -注意，我们还可以输入变量，这允许我们很灵活地动态改变我们数组中的数据。 +**注意：**我们甚至可以传入变量，这在动态改变数组数据的场景下十分有用。 # --instructions-- -我们已经定义了一个`mixedNumbers`函数，它会接受一个数组作为参数。请你修改这个函数，使用`push()`和`unshift()`来将`'I', 2, 'three'`插入到数组的开头，将`7, 'VIII', 9`插入到数组的末尾，使得这个函数返回一个依次包含 1-9 的数组。 +我们已经定义了一个 `mixedNumbers` 函数，它接收一个数组作为参数。请你修改这个函数，使用 `push()` 和 `unshift()` 来将 `'I', 2, 'three'` 插入到数组开头，将 `7, 'VIII', 9` 插入到数组的末尾，使得这个函数返回一个依次包含 1 至 9。 # --hints-- -`mixedNumbers(["IV", 5, "six"])`现在应该返回`["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]` +`mixedNumbers(["IV", 5, "six"])` 应返回 `["I", 2, "three", "IV", 5, "six", 7, "VIII", 9]`。 ```js assert.deepEqual(mixedNumbers(['IV', 5, 'six']), [ @@ -46,13 +46,13 @@ assert.deepEqual(mixedNumbers(['IV', 5, 'six']), [ ]); ``` -`mixedNumbers`函数应该使用`push()`方法 +`mixedNumbers` 函数中应调用 `push()` 方法。 ```js assert(mixedNumbers.toString().match(/\.push/)); ``` -`mixedNumbers`函数应该使用`unshift()`方法 +`mixedNumbers` 函数中应调用 `unshift()` 方法。 ```js assert(mixedNumbers.toString().match(/\.unshift/)); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md index 84dfa6c4f3..d73158f8a5 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.md @@ -1,13 +1,13 @@ --- id: 587d78b3367417b2b2512b11 -title: 使用 splice() 增加项目 +title: 使用 splice() 添加元素 challengeType: 1 forumTopicId: 301152 --- # --description-- -你还记得在上个挑战中我们提到`splice()`方法可以接受最多 3 个参数吗？我们现在可以进一步了解`splice()`。除了移除元素，我们还可以利用它的第三个参数来向数组中*添加*元素。第三个参数可以是一个或多个元素，这些元素会被添加到数组中。这使我们能够便捷地将数组中的一个或一系列元素换成其他的元素。例如： +还记得在上个挑战中我们提到 `splice()` 方法最多可以接收 3 个参数吗？除了移除元素，我们还可以利用它的第三个参数来向数组中*添加*元素。第三个参数可以是一个或多个元素，这些元素会被添加到数组中。这样，我们能够便捷地将数组中的一个或多个连续元素换成其他的元素。例如： ```js const numbers = [10, 11, 12, 12, 15]; @@ -20,15 +20,15 @@ console.log(numbers); // 返回 [ 10, 11, 12, 13, 14, 15 ] ``` -以一个数字数组开始。接着调用 `splice()` 方法，在 (3) 的索引位置开始删除元素，删除的元素数量是 (1)，(13, 14) 是在删除位置插入的元素，可以在 `amountToDelete` 后面插入任意数量的元素（以逗号分隔），每个都会被插入。 +在上面的代码中，数组一开始包含了若干数字。接着，我们调用 `splice()` 方法，索引为 (3) 的地方开始删除元素，删除的元素数量是 (1)。然后，(13, 14) 是在删除位置插入的元素，可以在 `amountToDelete` 后面传入任意数量的元素（以逗号分隔），每个都会被插入到数组中。 # --instructions-- -我们已经定义了一个`htmlColorNames`函数，它以一个 HTML 颜色的数组作为输入参数。请修改这个函数，利用`splice()`来移除数组中的前两个元素，并在对应的位置上添加`'DarkSalmon'`和`'BlanchedAlmond'`。 +我们已经定义了一个 `htmlColorNames` 函数，它以一个 HTML 颜色的数组作为输入参数。请修改这个函数，使用 `splice()` 来移除数组中的前两个元素，并在对应的位置上添加 `'DarkSalmon'` 和 `'BlanchedAlmond'`。 # --hints-- -`htmlColorNames`应该返回`["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"]` +`htmlColorNames` 应返回 `["DarkSalmon", "BlanchedAlmond", "LavenderBlush", "PaleTurqoise", "FireBrick"]`。 ```js assert.deepEqual( @@ -49,19 +49,19 @@ assert.deepEqual( ); ``` -`htmlColorNames`函数应该使用`splice()`方法 +`htmlColorNames` 函数中应调用 `splice()` 方法。 ```js assert(/.splice/.test(code)); ``` -你不应该使用`shift()`或`unshift()` 。 +不应使用 `shift()` 或 `unshift()`。 ```js assert(!/shift|unshift/.test(code)); ``` -您不应该使用数组括号表示法。 +不应使用数组的方括号表示法。 ```js assert(!/\[\d\]\s*=/.test(code)); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md index e310032773..282c063143 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.md @@ -7,64 +7,80 @@ forumTopicId: 301153 # --description-- -对象（object）本质上是键值对（key-value pair）的集合，或者说，一系列被映射到唯一标识符（叫做属性（property）或者键（key））的数据。让我们来看一个很简单的例子： +对象（object）本质上是键值对（key-value pair）的集合。或者说，一系列被映射到唯一标识符的数据就是对象；习惯上，唯一标识符叫做属性（property）或者键（key））；数据叫做值（value）。让我们来看一个简单的例子： ```js -let FCC_User = { - username: 'awesome_coder', - followers: 572, - points: 1741, - completedProjects: 15 +const tekkenCharacter = { + player: 'Hwoarang', + fightingStyle: 'Tae Kwon Doe', + human: true }; ``` -上面的代码定义了一个叫做`FCC_User`的对象，它有 4 个属性，每个属性映射一个特定的值。如果我们想知道`FCC_User`有多少`followers`，我们可以这样访问其`followers`属性： +上面的代码定义了一个叫做 `tekkenCharacter` 的“铁拳”游戏人物对象。它有三个属性，每个属性都对应一个特定的值。如果我们想为它再添加一个叫做 `origin` 的属性，可以这样写： ```js -let userData = FCC_User.followers; -// userData 等于 572 +tekkenCharacter.origin = 'South Korea'; ``` -这叫做点符号（dot notation）。我们还可以用方括号符号来访问对象中的属性： +上面的代码中，我们使用了点号表示法（dot notation）。如果我们现在输出这个对象，便可以看到它具有 `origin` 属性。接下来，因为这个人物在游戏中有着与众不同的橘色头发，我们可以通过方括号表示法来为它添加这个属性，像这样： ```js -let userData = FCC_User['followers']; -// userData 等于 572 +tekkenCharacter['hair color'] = 'dyed orange'; ``` -注意，在用方括号符号时，我们在括号里写的是字符串`followers`（用引号括起）。方括号符号让我们能用一个变量作为属性名来访问对象的属性（请记住）。若我们在方括号中不写引号而直接写`followers`，JavaScript 引擎会将其看作一个变量，并抛出一个`ReferenceError: followers is not defined`的错误。 +如果要设置的属性中存在空格，或者要设置的属性是一个变量，那我们必须使用方括号表示法（bracket notation）来为对象添加属性。在上面的代码中，我们把属性 `hair color` 放到引号里，以此来表示整个字符串都是需要设置的属性。如果我们不加上引号，那么中括号里的内容会被当作一个变量来解析，这个变量对应的值就会作为要设置的属性，请看这段代码： + +```js +const eyes = 'eye color'; + +tekkenCharacter[eyes] = 'brown'; +``` + +执行以上所有示例代码后，对象会变成这样： + +```js +{ + player: 'Hwoarang', + fightingStyle: 'Tae Kwon Doe', + human: true, + origin: 'South Korea', + 'hair color': 'dyed orange', + 'eye color': 'brown' +}; +``` # --instructions-- -用这样的语法，我们还可以向对象中***新增***键值对。我们已经创建了一个有 3 个属性的`foods`对象，请为其新增 3 项：值为`13`的`bananas`属性、值为`35`的`grapes`属性和值为`27`的`strawberries`属性。 +我们已经为你创建了 `foods` 对象。请使用上述任意语法，来为 `foods` 对象添加如下三个键值对：`bananas` 属性，值为 `13`；`grapes` 属性，值为 `35`；`strawberries` 属性，值为 `27`。 # --hints-- -`foods`应该是一个对象。 +`foods` 应为一个对象。 ```js assert(typeof foods === 'object'); ``` -`foods`应该有一个值为`13`的`"bananas"`属性。 +`foods` 应有一个值为 `13` 的 `"bananas"` 属性。 ```js assert(foods.bananas === 13); ``` -`foods`应该有一个值为`35`的`"grapes"`属性。 +`foods` 应有一个值为 `35` 的 `"grapes"` 属性。 ```js assert(foods.grapes === 35); ``` -`foods`应该有一个值为`27`的`"strawberries"`属性。 +`foods` 应有一个值为 `27` 的 `"strawberries"` 属性。 ```js assert(foods.strawberries === 27); ``` -你应该用点符号或者方括号符号来设置对象的属性。 +应使用点号表示法或方括号表示法来设置对象的属性。 ```js assert( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md index 0c0053ed46..0665cc1d2a 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.md @@ -7,7 +7,7 @@ forumTopicId: 301154 # --description-- -由于数组可以在任意时间被修改或者说*被改变（mutated）*，我们不能保证某个数据在一个给定数组中的位置，甚至不能保证该元素还存在于该数组中。幸运的是，JavaScript 给我们提供了另一个内置方法`indexOf()`。这个方法让我们可以便捷地检查某个元素是否存在于一个数组中。`indexOf()`方法接受一个元素作为输入参数，并返回该元素在数组中的位置（索引）；若该元素不存在于数组中则返回`-1`。 +由于数组随时都可以修改或发生“突变”（*mutated*），我们很难保证某个数据始终处于数组中的特定位置，甚至不能保证该元素是否还存在于该数组中。好消息是，JavaScript 为我们提供了内置方法 `indexOf()`。这个方法让我们可以方便地检查某个元素是否存在于数组中。`indexOf()` 方法接受一个元素作为输入参数，并返回该元素在数组中的位置（索引）；若该元素不存在于数组中则返回 `-1`。 例如： @@ -16,16 +16,16 @@ let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears']; fruits.indexOf('dates'); // 返回 -1 fruits.indexOf('oranges'); // 返回 2 -fruits.indexOf('pears'); // 返回 1，即第一个出现的 'pears' 元素在数组中的索引为 1 +fruits.indexOf('pears'); // 返回 1，因为第一个出现在数组中的 'pears' 元素索引为 1 ``` # --instructions-- -`indexOf()`在快速检查一个数组中是否存在某个元素时非常有用。我们已经定义了一个`quickCheck`函数，它接受一个数组和一个元素作为输入参数。请修改这个函数，利用`indexOf()`方法，使得当输入的数组中含有输入的元素时，函数返回`true`；不含有输入的元素时，函数返回`false`。 +`indexOf()` 在快速检查一个数组中是否存在某个元素时非常有用。我们已经定义了一个 `quickCheck` 函数，它接受一个数组和一个元素作为输入参数。请修改这个函数，通过 `indexOf()` 方法，使得当参数数组中包含第二个参数的元素时返回 `true`，不包含时返回 `false`。 # --hints-- -`quickCheck(["squash", "onions", "shallots"], "mushrooms")`应该返回`false` +`quickCheck(["squash", "onions", "shallots"], "mushrooms")` 应返回 `false`。 ```js assert.strictEqual( @@ -34,7 +34,7 @@ assert.strictEqual( ); ``` -`quickCheck(["squash", "onions", "shallots"], "onions")`应该返回`true` +`quickCheck(["squash", "onions", "shallots"], "onions")` 应返回 `true`。 ```js assert.strictEqual( @@ -43,19 +43,19 @@ assert.strictEqual( ); ``` -`quickCheck([3, 5, 9, 125, 45, 2], 125)`应该返回`true` +`quickCheck([3, 5, 9, 125, 45, 2], 125)` 应返回 `true`。 ```js assert.strictEqual(quickCheck([3, 5, 9, 125, 45, 2], 125), true); ``` -`quickCheck([true, false, false], undefined)`应返回`false` +`quickCheck([true, false, false], undefined)` 应返回 `false`。 ```js assert.strictEqual(quickCheck([true, false, false], undefined), false); ``` -`quickCheck`函数应该使用`indexOf()`方法 +`quickCheck` 函数中应使用 `indexOf()` 方法。 ```js assert.notStrictEqual(quickCheck.toString().search(/\.indexOf\(/), -1); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md index dfe520dc48..cebe583b0e 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.md @@ -7,7 +7,7 @@ forumTopicId: 301155 # --description-- -现在我们可以新增、修改和移除对象中的属性。但如果我们想知道一个对象中是否含有某个属性呢？JavaScript 为我们提供了两种不同的方式来实现这个功能，一个是`hasOwnProperty()`方法，另一个是`in`关键字。如果我们有一个`users`对象，它有一个`Alan`属性，我们可以用以下两种方式之一来检查该属性在对象中是否存在： +我们已经学习了如果添加、修改和移除对象中的属性。但如果我们想知道一个对象中是否包含某个属性呢？JavaScript 为我们提供了两种不同的方式来实现这个功能：一个是通过 `hasOwnProperty()` 方法，另一个是使用 `in` 关键字。假如我们有一个 `users` 对象，为检查它是否含有 `Alan` 属性，可以这样写： ```js users.hasOwnProperty('Alan'); @@ -17,11 +17,11 @@ users.hasOwnProperty('Alan'); # --instructions-- -我们已经创建了一个含有一些用户的`users`对象和一个`isEveryoneHere`函数，该函数接受`users`对象作为参数。请完成该函数使其在`users`对象中包含以下 4 个键`Alan`、`Jeff`、`Sarah`和`Ryan`时才返回`true`，否则返回`false`。 +我们已经定义了一个包含若干用户信息的 `users` 对象和一个 `isEveryoneHere` 函数，该函数接收 `users` 对象作为参数。请完成该函数使其在 `users` 对象中同时包含 `Alan`、`Jeff`、`Sarah`、`Ryan` 四个属性时才返回 `true`，否则返回 `false`。 # --hints-- -`users`对象应该只含有`Alan`、`Jeff`、`Sarah`和`Ryan`4 个键。 +`users` 对象应该只包含 `Alan`、`Jeff`、`Sarah`、`Ryan` 4 个属性。 ```js assert( @@ -33,13 +33,13 @@ assert( ); ``` -`isEveryoneHere`函数在`users`对象包含`Alan`、`Jeff`、`Sarah`和`Ryan`4 个键时应该返回`true`。 +`isEveryoneHere` 函数在 `users` 对象包含 `Alan`、`Jeff`、`Sarah`、`Ryan` 4 个属性时应返回 `true`。 ```js assert(isEveryoneHere(users) === true); ``` -`isEveryoneHere`函数在`users`对象不包含`Alan`、`Jeff`、`Sarah`或`Ryan`4 个键时应该返回`false`。 +`isEveryoneHere` 函数在 `users` 对象不包含 `Alan`、`Jeff`、`Sarah`、`Ryan` 4 个属性时应返回 `false`。 ```js assert( @@ -50,7 +50,7 @@ assert( ); ``` -如果 `Jeff` 不是 `users` 对象的属性，函数 `isEveryoneHere` 应该返回 `false`。 +如果 `users` 对象中不包含属性 `Jeff`，则函数 `isEveryoneHere` 应返回 `false`。 ```js assert( @@ -61,7 +61,7 @@ assert( ); ``` -如果 `Sarah` 不是 `users` 对象的属性，函数 `isEveryoneHere` 应该返回 `false`。 +如果 `users` 对象中不包含属性 `Sarah`，则函数 `isEveryoneHere` 应返回 `false`。 ```js assert( @@ -72,7 +72,7 @@ assert( ); ``` -如果 `Ryan` 不是 `users` 对象的属性，函数 `isEveryoneHere` 应该返回 `false`。 +如果 `users` 对象中不包含属性 `Ryan`，则函数 `isEveryoneHere` 应返回 `false`。 ```js assert( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md index 3bad5f4092..13f04a5786 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.md @@ -1,13 +1,13 @@ --- id: 587d7b7b367417b2b2512b17 -title: 组合使用数组和扩展运算符 +title: 使用展开运算符合并数组 challengeType: 1 forumTopicId: 301156 --- # --description-- -展开运算符的另一个大用处是合并数组，或者将某个数组的所有元素插入到另一个数组的任意位置。用传统的语法我们也可以连接两个数组，但只能两个数组首尾相接。而展开语法能使下面的操作变得极其简单： +展开语法的另一个重要用途是合并数组，或者将某个数组的所有元素插入到另一个数组的任意位置。我们也可以使用 ES5 的语法连接两个数组，但只能让它们首尾相接。而展开语法可以让这样的操作变得极其简单： ```js let thisArray = ['sage', 'rosemary', 'parsley', 'thyme']; @@ -16,21 +16,21 @@ let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander']; // thatArray 现在是 ['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander'] ``` -使用展开语法，我们这样就实现了一个用传统方法要写得很复杂冗长的操作。 +使用展开语法，我们像这样就可以实现一个用传统方法会写得很复杂且冗长的操作。 # --instructions-- -我们已经定义了一个返回`sentence`变量的`spreadOut`函数，请修改该函数，利用展开运算符使该函数返回数组`['learning', 'to', 'code', 'is', 'fun']`。 +我们已经定义了一个返回 `sentence` 变量的 `spreadOut` 函数。请修改这个函数，利用展开语法使该函数返回数组 `['learning', 'to', 'code', 'is', 'fun']`。 # --hints-- -`spreadOut`应该返回`["learning", "to", "code", "is", "fun"]` +`spreadOut` 应返回 `["learning", "to", "code", "is", "fun"]`。 ```js assert.deepEqual(spreadOut(), ['learning', 'to', 'code', 'is', 'fun']); ``` -`spreadOut`函数里应该用到展开语法 +`spreadOut` 函数里应用到展开语法。 ```js assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md index de46d4c308..131609a7bf 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.md @@ -1,30 +1,30 @@ --- id: 587d7b7b367417b2b2512b13 -title: 使用扩展运算符复制数组 +title: 使用展开运算符复制数组 challengeType: 1 forumTopicId: 301157 --- # --description-- -`slice()`已经能让我们从一个数组中选择一些元素来复制到新数组中了，而 ES6 中又新引入了一个简洁且可读性强的语法展开运算符（spread operator），它能让我们方便地复制数组中的*所有*元素。展开语法是这样的：`...` +`slice()` 可以让我们从一个数组中选择一些元素来复制到新数组中，而 ES6 中又引入了一个简洁且可读性强的语法：展开运算符（spread operator），它能让我们方便地复制数组中的*所有*元素。展开语法写出来是这样：`...` -在实践中，我们可以这样用展开运算符来复制一个数组： +我们可以用展开运算符来复制数组： ```js let thisArray = [true, true, undefined, false, null]; let thatArray = [...thisArray]; -// thatArray 等于 [true, true, undefined, false, null] -// thisArray 保持不变，等于 thatArray +// thatArray 的值现在也是 [true, true, undefined, false, null] +// thisArray 保持不变。现在 thatArray 所包含的值与 thisArray 完全相同 ``` # --instructions-- -我们已经定义了一个`copyMachine`函数，它接受`arr`（一个数组）和`num`（一个数字）作为输入参数。该函数应该返回一个由`num`个`arr`组成的新数组。我们已经为你写好了大部分的代码，但它还不能正确地工作。请修改这个函数，使用展开语法，使该函数正确工作（提示：我们已经学到过的一个方法很适合用在这里！） +我们已经定义了一个 `copyMachine` 函数，它接受 `arr`（一个数组）和 `num`（一个数字）作为输入参数。该函数需要返回一个由 `num` 个 `arr` 组成的新的二维数组。同时，我们写好了大致的流程，只是细节实现还没有写完。请修改这个函数，使用展开语法，使该函数能正常工作（提示：我们已经学到过的一个方法很适合用在这里）！ # --hints-- -`copyMachine([true, false, true], 2)`应该返回`[[true, false, true], [true, false, true]]` +`copyMachine([true, false, true], 2)` 应返回 `[[true, false, true], [true, false, true]]`。 ```js assert.deepEqual(copyMachine([true, false, true], 2), [ @@ -33,7 +33,7 @@ assert.deepEqual(copyMachine([true, false, true], 2), [ ]); ``` -`copyMachine([1, 2, 3], 5)`应该返回`[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]` +`copyMachine([1, 2, 3], 5)` 应返回 `[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]`。 ```js assert.deepEqual(copyMachine([1, 2, 3], 5), [ @@ -45,13 +45,13 @@ assert.deepEqual(copyMachine([1, 2, 3], 5), [ ]); ``` -`copyMachine([true, true, null], 1)`应该返回`[[true, true, null]]` +`copyMachine([true, true, null], 1)` 应返回 `[[true, true, null]]`。 ```js assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]]); ``` -`copyMachine(["it works"], 3)`应该返回`[["it works"], ["it works"], ["it works"]]` +`copyMachine(["it works"], 3)` 应返回 `[["it works"], ["it works"], ["it works"]]`。 ```js assert.deepEqual(copyMachine(['it works'], 3), [ @@ -61,7 +61,7 @@ assert.deepEqual(copyMachine(['it works'], 3), [ ]); ``` -`copyMachine`函数中应该对数组`arr`使用`spread operator`。 +`copyMachine` 函数中应对 `arr` 使用`展开运算符`。 ```js assert(removeJSComments(code).match(/\.\.\.arr/)); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md index 00ec37322e..50bab4dedd 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.md @@ -1,13 +1,13 @@ --- id: 587d7b7a367417b2b2512b12 -title: 使用 slice() 拷贝数组项目 +title: 使用 slice() 复制数组元素 challengeType: 1 forumTopicId: 301158 --- # --description-- -接下来我们要介绍`slice()`方法。`slice()`并不修改数组，而是复制或者说*提取（extract）*给定数量的元素到一个新数组里，而调用方法的数组则保持不变。`slice()`只接受 2 个输入参数—第一个是开始提取元素的位置（索引），第二个是结束提取元素的位置（索引）。slice 方法会提取直到截止索引的元素，但被提取的元素不包括截止索引对应的元素。请看以下例子： +接下来我们要介绍 `slice()` 方法。`slice()` 不会修改数组，而是会复制，或者说*提取（extract）*给定数量的元素到一个新数组。同时，调用方法的数组保持不变。`slice()` 只接收 2 个输入参数：第一个是开始提取元素的位置（索引），第二个是提取元素的结束位置（索引）。`slice()` 提取的元素中不包括第二个参数所对应的元素。请看以下例子： ```js let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear']; @@ -17,15 +17,15 @@ let todaysWeather = weatherConditions.slice(1, 3); // weatherConditions 仍然等于 ['rain', 'snow', 'sleet', 'hail', 'clear'] ``` -现在我们从一个已有的数组中提取了一些元素，并用这些元素创建了一个新数组。 +在上面的代码中，我们从一个数组中提取了一些元素，并用这些元素创建了一个新数组。 # --instructions-- -我们已经定义了一个`forecast`函数，它接受一个数组作为参数。请修改这个函数，利用`slice()`来从输入的数组中提取信息，并返回一个包含元素`'warm'`和`'sunny'` 的新数组。 +我们已经定义了一个 `forecast` 函数，它接受一个数组作为参数。请修改这个函数，利用 `slice()` 从输入的数组中提取信息，最终返回一个包含元素 `'warm'` 和 `'sunny'` 的新数组。 # --hints-- -`forecast`应该返回`["warm", "sunny"]` +`forecast` 应返回 `["warm", "sunny"]`。 ```js assert.deepEqual( @@ -34,7 +34,7 @@ assert.deepEqual( ); ``` -`forecast`函数应该使用`slice()`方法 +`forecast` 函数中应使用 `slice()` 方法。 ```js assert(/\.slice\(/.test(code)); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md index 014005606c..a52b5bfc02 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.md @@ -7,37 +7,37 @@ forumTopicId: 301159 # --description-- -很好！你已经学到很多关于数组的知识了！但这些只是一个开始，你将在接下来的小节中学习到与数组相关的更多知识。但在继续去学习对象（Objects）之前，让我们再花一点时间看一看，数组怎样能够变得比之前的挑战中更复杂一点。 +很好！你现在已经学到很多关于数组的知识了，但这些只是个开始。我们将在接下来的中挑战中学到更多与数组相关的知识。在继续学习对象（Objects）之前，让我们再花一点时间了解下更复杂的数组嵌套。 -数组的一个强大的特性是，它可以包含其他数组，甚至完全由其他数组组成。我们已经在上一个挑战中看到了包含数组的数组，但它还算是比较简单的。数组中的数组还可以在包含其他数组，数组中是可以嵌套任意层的数组的。数组从而可以被用来实现非常复杂的叫做多维（multi-dimensional）或嵌套（nested）数组的数据结构。请看如下例子： +数组的一个强大的特性是，它可以包含其他数组，甚至完全由其他数组组成。在上一个挑战中，我们已经接触到了包含数组的数组，但它还算是比较简单的。数组中的数组还可以再包含其他数组，即可以嵌套任意多层数组。习惯上，我们称这种数据结构为多维（multi-dimensional）数组或嵌套（nested）数组。请看如下的示例： ```js -let nestedArray = [ // 顶层，或第 1 层——最外层的数组 +let nestedArray = [ // 顶层，或第 1 层，即最外层数组 ['deep'], // 数组中的数组，第 2 层 [ - ['deeper'], ['deeper'] // 第 3 层嵌套的两个数组 + ['deeper'], ['deeper'] // 第 3 层，元素为嵌套的两个数组 ], [ [ - ['deepest'], ['deepest'] // 第 4 层嵌套的两个数组 + ['deepest'], ['deepest'] // 第 4 层，元素为嵌套的两个数组 ], [ [ - ['deepest-est?'] // 第 5 层嵌套的一个数组 + ['deepest-est?'] // 第 5 层，元素为嵌套的一个数组 ] ] ] ]; ``` -虽然这个例子看起来错综复杂，但这样复杂的数组并不算罕见，尤其是在处理大量数据的时候。 但我们仍能简单地用方括号符号来访问到嵌套得最深的数组： +虽然这个例子看起来错综复杂，不过，尤其是在处理大量数据的时候，这种数据结构还是经常会用到的。尽管结构复杂，不过我们仍可以通过方括号表示法来访问嵌套得最深的数组： ```js console.log(nestedArray[2][1][0][0][0]); // logs: deepest-est? ``` -既然我们知道数据在哪里，我们就能修改它： +既然我们知道数据的位置，当然，我们也可以修改它： ```js nestedArray[2][1][0][0][0] = 'deeper still'; @@ -48,11 +48,11 @@ console.log(nestedArray[2][1][0][0][0]); # --instructions-- -我们已经定义了一个`myNestedArray`数组变量。请修改`myNestedArray`，用字符串（string）、数字（number）或者布尔值（boolean）作为数组的数据元素，使得`myNestedArray`刚好有 5 层数组嵌套（记住，最外层的数组是第 1 层）。请在第 3 层的数组中包含字符串`'deep'`，在第 4 层的数组中包含字符串`'deeper'`，在第 5 层的数组中包含字符串`'deepest'`。 +我们已经定义了一个叫做 `myNestedArray` 的数组变量。请修改 `myNestedArray`，使用字符串（string）、数字（number）或布尔值（boolean）作为数组的元素，并让 `myNestedArray` 刚好有 5 层（注意，最外层的数组是第 1 层）。同时，请在第 3 层的数组中包含字符串 `'deep'`；在第 4 层的数组中包含字符串 `'deeper'`，在第 5 层的数组中包含字符串 `'deepest'`。 # --hints-- -`myNestedArray`中的数据元素应当只能是字符串、数字或者布尔值。 +`myNestedArray` 中的数据元素应只包含字符串、数字或者布尔值。 ```js assert.strictEqual( @@ -76,7 +76,7 @@ assert.strictEqual( ); ``` -`myNestedArray`应该刚好有 5 层数组嵌套。 +`myNestedArray` 应刚好包含 5 层嵌套数组。 ```js assert.strictEqual( @@ -99,7 +99,7 @@ assert.strictEqual( ); ``` -`myNestedArray`里应该有且只有一个字符串`"deep"`，并且应该出现在第 3 层数组中。 +`myNestedArray` 中应只有一个字符串 `"deep"`，并且应出现在第 3 层数组中。 ```js assert( @@ -128,7 +128,7 @@ assert( ); ``` -`myNestedArray`里应该有且只有一个字符串`"deeper"`，并且应该出现在第 4 层数组中。 +`myNestedArray` 中应只有一个字符串 `"deeper"`，并且应出现在第 4 层数组中。 ```js assert( @@ -157,7 +157,7 @@ assert( ); ``` -`myNestedArray`里应该有且只有一个字符串`"deepest"`，并且应该出现在第 5 层数组中。 +`myNestedArray` 中应只有一个字符串 `"deepest"`，并且应出现在第 5 层数组中。 ```js assert( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md index c1ff326949..7ed1f9e499 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.md @@ -1,21 +1,21 @@ --- id: 587d7b7d367417b2b2512b1e -title: 使用 Object.Keys() 生成对象所有键组成的数组 +title: 使用 Object.keys() 生成由对象的所有属性组成的数组 challengeType: 1 forumTopicId: 301160 --- # --description-- -我们还可以输入一个对象作为参数来调用`Object.keys()`方法，使其生成一个包含对象中所有键的数组。这会返回一个由对象中所有键的名称（字符串）组成的数组。再次说明，这个数组中的项的顺序是不确定的。 +我们可以给 `Object.keys()` 方法传入一个对象作为参数，这会返回一个由对象中所有属性（字符串）组成的数组。需要注意的是，数组中元素的顺序是不确定的。 # --instructions-- -请你完成`getArrayOfUsers`函数，使其返回一个包含输入的对象的所有属性的数组。 +请完成 `getArrayOfUsers` 函数的实现，使其返回一个由输入对象中的所有属性所组成的数组。 # --hints-- -`users`对象应该只包含`Alan`、`Jeff`、`Sarah`和`Ryan`这 4 个键 +`users` 对象应该只包含 `Alan`、`Jeff`、`Sarah`、`Ryan` 这 4 个属性。 ```js assert( @@ -27,7 +27,7 @@ assert( ); ``` -`getArrayOfUsers`函数应该返回一个包含`users`对象中所有键的数组 +`getArrayOfUsers` 函数应返回一个包含 `users` 对象中所有属性的数组。 ```js assert( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md index ca5c4dbc54..2b2c222690 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.md @@ -1,15 +1,15 @@ --- id: 587d7b7b367417b2b2512b15 -title: 使用 For 循环迭代数组的所有项 +title: 使用 for 循环遍历数组中的全部元素 challengeType: 1 forumTopicId: 301161 --- # --description-- -在进行与数组有关的编程时，我们有时需要遍历数组的所有元素来找出我们需要的元素，或者对数组执行特定的操作。JavaScript 提供了几个内置的方法，它们以不同的方式遍历数组来获得不同的结果（如`every()`、`forEach()`、`map()`等等）。而简单的`for`循环不仅能实现这些功能，而且相比之下也更灵活。 +使用数组时，我们经常需要遍历数组的所有元素来找出我们需要的一个或多个元素，抑或是对数组执行一些特定的操作。JavaScript 为我们提供了几个内置的方法，它们以不同的方式遍历数组，以便我们可以用于不同的场景（如 `every()`、`forEach()`、`map()` 等等）。然而，最简单的 `for` 循环不仅能实现上述这些方法的功能，而且相比之下也会更加灵活。 -请看以下例子： +请看以下的例子： ```js function greaterThanTen(arr) { @@ -26,15 +26,15 @@ greaterThanTen([2, 12, 8, 14, 80, 0, 1]); // 返回 [12, 14, 80] ``` -这个函数使用一个`for`循环来遍历一个数组，逐一对其中的元素进行测试。我们用这个方法简单地以编程的方式找出了数组中大于`10`的元素，并返回了一个包含这些元素的数组。 +在这个函数中，我们用一个 `for` 循环来遍历数组，逐一对其中的元素进行判断。通过上面的代码，我们可以找出数组中大于 `10` 的所有元素，并返回一个包含这些元素的新数组。 # --instructions-- -我们已经定义了一个`filteredArray`函数，它接受一个嵌套的数组参数`arr`以及一个`elem`参数，并要返回一个新数组。`arr`数组中的数组可能包含`elem`元素，也可能不包含。请修改该函数，用一个`for`循环来做筛选，使函数返回一个由`arr`中不包含`elem`的数组组成的新数组。 +我们已经定义了 `filteredArray` 函数，它接受一个嵌套的数组 `arr` 和一个 `elem` 作为参数，并要返回一个新数组。`arr` 数组中嵌套的数组里可能包含 `elem` 元素，也可能不包含。请修改该函数，用一个 `for` 循环来做筛选，使函数返回一个由 `arr` 中不包含 `elem` 的数组所组成的新数组。 # --hints-- -`filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)`应该返回`[ [10, 8, 3], [14, 6, 23] ]` +`filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18)` 应返回 `[ [10, 8, 3], [14, 6, 23] ]`。 ```js assert.deepEqual( @@ -53,7 +53,7 @@ assert.deepEqual( ); ``` -`filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2)`应返回`[ ["flutes", 4] ]` +`filteredArray([ ["trumpets", 2], ["flutes", 4], ["saxophones", 2] ], 2)` 应返回 `[ ["flutes", 4] ]`。 ```js assert.deepEqual( @@ -69,7 +69,7 @@ assert.deepEqual( ); ``` -`filteredArray([ ["amy", "beth", "sam"], ["dave", "sean", "peter"] ], "peter")`应该返回`[ ["amy", "beth", "sam"] ]` +`filteredArray([ ["amy", "beth", "sam"], ["dave", "sean", "peter"] ], "peter")` 应返回 `[ ["amy", "beth", "sam"] ]`。 ```js assert.deepEqual( @@ -84,7 +84,7 @@ assert.deepEqual( ); ``` -`filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)`应该返回`[ ]` +`filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)` 应返回 `[]`。 ```js assert.deepEqual( @@ -101,7 +101,7 @@ assert.deepEqual( ); ``` -`filteredArray`函数应该使用`for`循环 +`filteredArray` 函数中应使用 `for` 循环。 ```js assert.notStrictEqual(filteredArray.toString().search(/for/), -1); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-the-keys-of-an-object-with-a-for...in-statement.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-the-keys-of-an-object-with-a-for...in-statement.md index 38b09d7100..9e7d2153cd 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-the-keys-of-an-object-with-a-for...in-statement.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-the-keys-of-an-object-with-a-for...in-statement.md @@ -1,32 +1,31 @@ --- id: 587d7b7d367417b2b2512b1d -title: 使用 for...in 语句迭代对象 +title: 使用 for...in 语句遍历对象 challengeType: 1 forumTopicId: 301162 --- # --description-- -有时候你需要遍历一个对象中的所有键。这需要 JavaScript 中的一个特殊语法：for...in 语句。以遍历 `users` 对象的键为例： +如果我们想要遍历对象中的所有属性，只需要使用 JavaScript 中的 for...in 语句即可。以遍历 `users` 对象的属性为例： ```js for (let user in users) { console.log(user); } -// logs: +// 输出： Alan Jeff Sarah Ryan ``` -在这个语句中，我们定义了一个`user`变量，你可以看到，这个变量在 for...in 语句对对象的每一个键的遍历中都会被重置。 **注意：** -跟数组不同，对象中的键是无序的，因此一个对象中某个键的位置，或者说它出现的相对顺序，在引用或访问该键时是不确定的。 +在上面的代码中，我们定义了一个 `user` 变量。可以观察到，这个变量在遍历对象的 `for...in` 语句执行过程中会一直被重置并赋予新值，结果就是不同的用户名打印到了 console 中。**注意：**对象中的键是无序的，这与数组不同。因此，一个对象中某个属性的位置，或者说它出现的相对顺序，在引用或访问该属性时是不确定的。 # --instructions-- -我们已经定义了一个`countOnline`函数，请在其中使用一个 for...in 语句来遍历`users`对象中的用户，并返回`online`属性为`true`的用户的数量。 +我们已经定义了一个 `countOnline` 函数，请在其中使用 for...in 语句来遍历 `users` 对象中的用户，并返回 `online` 属性为 `true` 的用户数量。以下是一个传入 `countOnline` 函数的对象示例，注意每个用户都有 `online` 属性，其属性值为 `true` 或 `false`： ```js { @@ -44,7 +43,7 @@ Ryan # --hints-- -函数 `countOnline` 应该使用 `for in` 语句遍历传入对象的key。 +函数 `countOnline` 中应使用 `for in` 语句遍历传入的对象。 ```js assert( @@ -54,19 +53,19 @@ assert( ); ``` -当传入 `{ Alan: { online: false }, Jeff: { online: true }, Sarah: { online: false } }` 时，函数 `countOnline` 应该返回 `1`。 +当传入 `{ Alan: { online: false }, Jeff: { online: true }, Sarah: { online: false } }` 时，函数 `countOnline` 应该返回 `1`。 ```js assert(countOnline(usersObj1) === 1); ``` -当传入 `{ Alan: { online: true }, Jeff: { online: false }, Sarah: { online: true } }` 时，函数 `countOnline` 应该返回 `2`。 +当传入 `{ Alan: { online: true }, Jeff: { online: false }, Sarah: { online: true } }` 时，函数 `countOnline` 应该返回 `2`。 ```js assert(countOnline(usersObj2) === 2); ``` -当传入 `{ Alan: { online: false }, Jeff: { online: false }, Sarah: { online: false } }` 时，函数 `countOnline` 应该返回 `0`。 +当传入 `{ Alan: { online: false }, Jeff: { online: false }, Sarah: { online: false } }` 时，函数 `countOnline` 应该返回 `0`。 ```js assert(countOnline(usersObj3) === 0); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md index 1a2cf97788..9a092d7f2e 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.md @@ -7,21 +7,21 @@ forumTopicId: 301163 # --description-- -现在你已经接触到 JavaScript 对象的所有运算。你可以增加、修改和移除键值对，检查某个键是否存在，并且遍历一个对象中的所有键。在你继续学习 JavaScript 的过程中，你会看到对象的更多用法。另外，后续的《高级数据结构》课程还会介绍 ES6 的 Map 和 Set 对象。这两种对象都跟一般的对象相似，但它们提供了一些额外的特性。现在你已经学到了数组和对象的基础知识，你已经可以继续用 JavaScript 来解决更加复杂的问题了！ +我们已经学习了 JavaScript 对象的这些基本操作：添加、修改、移除键值对、检查某个属性是否存在、遍历对象的所有属性。在继续学习 JavaScript 的过程中，我们会了解对象的更多用法。另外，在之后的数据结构课程中，我们还会学习 ES6 的 Map 和 Set。这两种数据结构与我们现在学到的对象十分类似，但它们在对象的基础上提供了一些额外的功能。目前，我们已经学习了数组和对象的基础知识，让我们试着来用所学的知识解决一些更复杂的问题。 # --instructions-- -请你看一下代码编辑器中我们提供的对象。`user`对象包含 3 个键。`data`对象包含 5 个键，其中一个包含一个`friends`数组。从这个例子你可以看到对象作为数据结构是多么的灵活。我们已经写了`addFriend`函数的一部分，请你完成这个函数，使其接受一个`user`对象，将`friend`参数中的名字添加到`user.data.friends`数组中并返回该数组。 +请看一下代码编辑器中我们为你写好的对象。`user` 对象包含 3 个属性；`data` 对象包含 5 个属性，其中包含一个叫做 `friends` 的数组。这就是对象作为数据结构所展现出的灵活性。我们已经写好了 `addFriend` 函数的一部分，请你完成这个函数，使其接受一个 `user` 对象，将 `friend` 参数中的名字添加到 `user.data.friends` 数组中并返回该数组。 # --hints-- -`user`对象应该包含`name`、`age`和`data`三个键。 +`user` 对象应该包含 `name`、`age` 和 `data` 三个属性。 ```js assert('name' in user && 'age' in user && 'data' in user); ``` -`addFriend`函数应该接受一个`user`对象和一个`friend`字符串作为输入参数，并将 friend 插入到`user`对象的`friends`数组中。 +`addFriend` 函数应该接受一个 `user` 对象和一个 `friend` 字符串作为输入参数，并将这个字符串插入到 `user` 对象的 `friends` 数组中。 ```js assert( @@ -34,7 +34,7 @@ assert( ); ``` -`addFriend(user, "Pete")`应该返回`["Sam", "Kira", "Tomo", "Pete"]`。 +`addFriend(user, "Pete")` 应该返回 `["Sam", "Kira", "Tomo", "Pete"]`。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md index 48133104cf..90df820912 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.md @@ -7,7 +7,7 @@ forumTopicId: 301164 # --description-- -现在我们来看一个稍微复杂一点的对象。对象中也可以嵌套任意层的对象。对象的属性值可以是 JavaScript 支持的任意类型，包括数组和其他对象。请看以下例子： +现在我们来看一个稍复杂的对象。在对象中，我们也可以嵌套任意层数的对象，对象的属性值可以是 JavaScript 支持的任意类型，包括数组和其他对象。请看以下例子： ```js let nestedObject = { @@ -24,15 +24,19 @@ let nestedObject = { }; ``` -`nestedObject`有 3 个唯一的键：值为一个数字的`id`、值为一个字符串的`date`和值为一个嵌套了其他对象的对象的`data`。虽然对象中的数据可能很复杂，我们仍能使用上一个挑战中讲的符号来访问我们需要的信息。 +`nestedObject` 有 3 个属性：`id`（属性值为数字）、`date`（属性值为字符串）、`data`（属性值为嵌套的对象）。虽然对象中的数据可能很复杂，我们仍能使用上一个挑战中讲到的写法来访问我们需要的信息。如果我们想把嵌套在 `onlineStatus` 中 `busy` 的属性值改为 `10`，可以用点号表示法来这样实现： + +```js +nestedObject.data.onlineStatus.busy = 10; +``` # --instructions-- -我们已经定义了一个`userActivity`对象，它包含了另一个对象。你可以用上一个挑战中那样的方式来修改被嵌套的对象的属性。请将`online`属性设为`45`。 +我们已经定义了一个 `userActivity` 对象，它包含了另一个对象。请将 `online` 的属性值改为 `45`。 # --hints-- -`userActivity`应该含有`id`、`date`和`data`属性。 +`userActivity` 应包含 `id`、`date` 和 `data` 属性。 ```js assert( @@ -40,19 +44,19 @@ assert( ); ``` -`userActivity`应该有一个`data`属性，该属性要是一个含有`totalUsers`和`online`属性的对象。 +`userActivity` 应包含 `data` 属性，其属性值应为包含 `totalUsers` 和 `online` 属性的对象。 ```js assert('totalUsers' in userActivity.data && 'online' in userActivity.data); ``` -`userActivity`的`data`属性值中的`online`属性应该被设为`45`。 +`userActivity` 的 `data` 属性值中的 `online` 属性值应被改为 `45`。 ```js assert(userActivity.data.online === 45); ``` -你应该用点符号或者方括号符号来设置`online`属性。 +应使用点号表示法或方括号表示法来修改 `online` 属性值。 ```js assert.strictEqual(code.search(/online: 45/), -1); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md index 092948da03..a558328503 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.md @@ -1,13 +1,13 @@ --- id: 587d78b2367417b2b2512b0f -title: 使用 pop() 和 shift() 从数组中删除项目 +title: 使用 pop() 和 shift() 从数组中删除元素 challengeType: 1 forumTopicId: 301165 --- # --description-- -`push()`和`unshift()`都分别有一个作用基本与之相反的函数：`pop()`和`shift()`。你现在或许已经猜到，与插入元素相反，`pop()`从数组的末尾*移除*一个元素，而`shift()`从数组的开头移除一个元素。`pop()`和`shift()`与对应的`push()`和`unshift()`的关键区别在于，前者不能接受输入参数，而且每次只能修改数组中的一个元素。 +`push()` 和 `unshift()` 都有一个与它们作用相反的函数：`pop()` 和 `shift()`。与插入元素相反，`pop()` 会从数组的末尾*移除*一个元素，而 `shift()` 会从数组的开头移除一个元素。`pop()` 和 `shift()` 与 `push()` 和 `unshift()` 的关键区别在于，用于删除元素的方法不接收参数，而且每次只能删除数组中的一个元素。 让我们来看以下的例子： @@ -15,27 +15,27 @@ forumTopicId: 301165 let greetings = ['whats up?', 'hello', 'see ya!']; greetings.pop(); -// now equals ['whats up?', 'hello'] +// 数组现在是 ['whats up?', 'hello'] greetings.shift(); -// now equals ['hello'] +// 数组现在是 ['hello'] ``` -还可以用这些方法返回移除的元素，像这样： +这些用于删除数组元素的方法会返回被删除的元素： ```js let popped = greetings.pop(); -// returns 'hello' -// greetings now equals [] +// 返回 'hello'，即 popped 的值为 'hello' +// greetings 数组现在为 [] ``` # --instructions-- -我们已经定义了一个`popShift`函数，它会接收一个数组作为输入参数并返回一个新的数组。请你修改这个函数，使用`pop()`和`shift()`来移除输入的数组的第一个元素和最后一个元素，并将这两个被移除的元素赋值给对应的变量，使得返回的数组包含它们的值。 +我们已经定义了一个 `popShift` 函数，它接收一个数组作为输入参数并返回一个新的数组。请修改这个函数，使用 `pop()` 和 `shift()` 来移除输入的数组中的第一个元素和最后一个元素，并将这两个被移除的元素分别赋值给对应的变量，使得最终返回的数组里包含这两个值。 # --hints-- -`popShift(["challenge", "is", "not", "complete"])`应返回`["challenge", "complete"]` +`popShift(["challenge", "is", "not", "complete"])` 应返回 `["challenge", "complete"]`。 ```js assert.deepEqual(popShift(['challenge', 'is', 'not', 'complete']), [ @@ -44,13 +44,13 @@ assert.deepEqual(popShift(['challenge', 'is', 'not', 'complete']), [ ]); ``` -`popShift`函数应该使用`pop()`方法 +`popShift` 函数中应使用 `pop()` 方法。 ```js assert.notStrictEqual(popShift.toString().search(/\.pop\(/), -1); ``` -`popShift`函数应该使用`shift()`方法 +`popShift` 函数中应使用 `shift()` 方法。 ```js assert.notStrictEqual(popShift.toString().search(/\.shift\(/), -1); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md index e55630000c..b35ed7c51f 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.md @@ -1,46 +1,46 @@ --- id: 587d78b2367417b2b2512b10 -title: 使用 splice() 删除项目 +title: 使用 splice() 删除元素 challengeType: 1 forumTopicId: 301166 --- # --description-- -在上面的挑战中，我们已经学到了如何利用`shift()`和`pop()`从数组的开头或者末尾移除元素，但如果我们想移除数组中间的一个元素呢？或者想一次移除多个元素呢？这时候我们就需要`splice()`了。`splice()`让我们可以从数组中的任意位置**移除任意数量的连续的元素**。 +在之前的挑战中，我们已经学习了如何用 `shift()` 和 `pop()` 从数组的开头或末尾移除元素。但如果我们想删除数组中间的一个元素，或者想一次删除多个元素，该如何操作呢？这时候我们就需要使用 `splice()` 方法了，`splice()` 可以让我们从数组中的任意位置**连续删除任意数量的元素**。 -`splice()`最多可以接受 3 个参数，但现在我们先关注前两个。`splice()`接收的前两个参数基于调用`splice()`数组中元素的索引。记住，数组的索引是*从 0 开始的*（*zero-indexed*），所以我们要用`0`来指示数组中的第一个元素。`splice()`的第一个参数代表从数组中的哪个索引开始移除元素，而第二个参数指示要从数组中删除多少个元素。例如： +`splice()` 最多可以接受 3 个参数，但现在我们先关注前两个。`splice()` 接收的前两个参数以调用 `splice()` 数组中的元素索引作为参考。别忘了，数组的索引是*从 0 开始的*，所以我们要用 `0` 来表示数组中的第一个元素。`splice()` 的第一个参数代表从数组中的哪个索引开始移除元素，而第二个参数表示要从数组中的这位位置删除多少个元素。例如： ```js let array = ['today', 'was', 'not', 'so', 'great']; array.splice(2, 2); -// 从第三个索引位置开始移除 2 个元素 -// array 现在是 ['today', 'was', 'great'] +// 从索引为 2 的位置（即第三个元素）开始移除 2 个元素 +// array 的值现在是 ['today', 'was', 'great'] ``` -`splice()`不仅从被调用的数组中移除元素，还会返回一个包含被移除元素的数组： +`splice()` 不仅会修改调用该方法的数组，还会返回一个包含被移除元素的数组： ```js let array = ['I', 'am', 'feeling', 'really', 'happy']; let newArray = array.splice(3, 2); -// newArray 是 ['really', 'happy'] +// newArray 的值是 ['really', 'happy'] ``` # --instructions-- -给定初始化的数组 `arr`。使用 `splice()` 从 `arr` 里移除元素，使剩余的元素的和为 `10`。 +我们已经定义了数组 `arr`。请使用 `splice()` 从 `arr` 里移除元素，使剩余的元素之和为 `10`。 # --hints-- -不应该修改这一行 `const arr = [2, 4, 5, 1, 7, 5, 2, 1];`。 +不应修改这一行 `const arr = [2, 4, 5, 1, 7, 5, 2, 1];`。 ```js assert(code.replace(/\s/g, '').match(/constarr=\[2,4,5,1,7,5,2,1\];?/)); ``` -`arr` 的剩余元素和应该为 `10`。 +`ahr` 的剩余元素之和应为 `10`。 ```js assert.strictEqual( @@ -49,13 +49,13 @@ assert.strictEqual( ); ``` -应该利用 `arr` 的 `splice()`。 +应对 `arr` 调用 `splice()` 方法。 ```js assert(code.replace(/\s/g, '').match(/arr\.splice\(/)); ``` -splice 应该只删除 `arr` 里面的元素，不能给 `arr` 添加元素。 +splice 应只删除 `arr` 里面的元素，不能给 `arr` 添加元素。 ```js assert(!code.replace(/\s/g, '').match(/arr\.splice\(\d+,\d+,\d+.*\)/g)); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md index 574e123a9a..d4d2a9d316 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.md @@ -1,21 +1,21 @@ --- id: 587d7b7e367417b2b2512b20 -title: 使用数组存储数据集合 +title: 使用数组存储不同类型的数据 challengeType: 1 forumTopicId: 301167 --- # --description-- -以下是数组（Array）数据结构的最简单的实现例子。这是一个一维数组（one-dimensional array），它只有一层，或者说在它里面没有包含其它的数组结构。可以看到它里面包含了布尔值（booleans）、字符串（strings）、数字（numbers）以及一些其他的 JavaScript 语言中合法的数据类型： +以下是最简单的数组（Array）示例：这是一个一维数组（one-dimensional array），它只有一层，或者说它里面没有包含其它数组。可以观察到，这个数组中只包含了布尔值（booleans）、字符串（strings）、数字（numbers）以及 JavaScript 中的其他数据类型： ```js let simpleArray = ['one', 2, 'three', true, false, undefined, null]; console.log(simpleArray.length); -// logs 7 +// 输出 7 ``` -可以在上述例子中看到，所有数组都有一个长度（length）属性。可以简单地使用`Array.length`方法来访问它。 下面是一个关于数组的更复杂的例子。这是一个多维数组（multi-dimensional Array），或者说是一个包含了其他数组的数组。可以注意到，在它的内部还包含了 JavaScript 中的对象（objects）结构。我们会在后面的小节中讨论该数据结构，但现在你只需要知道数组能够存储复杂的对象类型数据。 +所有数组都有一个表示长度的属性，我们可以通过 `Array.length` 来访问它。接下来是一个稍复杂的数组示例：这是一个多维数组（multi-dimensional Array），或者说是一个包含了其他数组的数组。可以观察到，在这个数组内部还包含了 JavaScript 的对象（objects），我们会在后面的挑战中详细讨论该数据结构。现在，你只需要知道数组能够存储复杂的对象数据。 ```js let complexArray = [ @@ -44,35 +44,35 @@ let complexArray = [ # --instructions-- -我们已经定义了一个名为`yourArray`的变量。请修改题目中的语句，将一个含有至少 5 个元素的数组赋值给`yourArray`变量。你的数组应该包含至少一个 string 类型的数据、一个 number 类型的数据和一个 boolean 类型的数据。 +我们已经定义了一个名为 `yourArray` 的变量。请修改代码，将一个含有至少 5 个元素的数组赋值给 `yourArray` 变量。你的数组中应包含至少一个 string 类型的数据、一个 number 类型的数据和一个 boolean 类型的数据。 # --hints-- -yourArray 应该是一个数组。 +yourArray 应为数组。 ```js assert.strictEqual(Array.isArray(yourArray), true); ``` -`yourArray`至少要包含 5 个元素。 +`yourArray` 应包含至少 5 个元素。 ```js assert.isAtLeast(yourArray.length, 5); ``` -`yourArray`应该包含至少一个`boolean`。 +`yourArray` 应包含至少一个 `boolean`。 ```js assert(yourArray.filter((el) => typeof el === 'boolean').length >= 1); ``` -`yourArray`应该包含至少一个`number`。 +`yourArray` 应包含至少一个 `number`。 ```js assert(yourArray.filter((el) => typeof el === 'number').length >= 1); ``` -`yourArray`应该包含至少一个`string`。 +`yourArray` 应包含至少一个 `string`。 ```js assert(yourArray.filter((el) => typeof el === 'string').length >= 1); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md index 3337c07421..dc323a7258 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.md @@ -7,11 +7,11 @@ forumTopicId: 301168 # --description-- -现在你已经知道什么是对象以及对象的基本特性和用途。总之，对象是以键值对的形式，灵活、直观地存储结构化数据的一种方式，***并且***查找对象属性的速度是很快的。在本章剩下的挑战中，我们会讲对象的几种常用操作，这样你能更好地在你的程序中使用这种有用的数据结构。 +现在我们已经学习了什么是对象以及对象的基本特性和用途。总之，对象是以键值对的形式，灵活、直观地存储结构化数据的一种方式，***而且***，通过对象的属性查找属性值是速度很快的操作。在本章余下的挑战中，我们来了解一下对象的几种常用操作，这样你能更好地在代码中使用这个十分有用的数据结构：对象。 -在之前的挑战中，我们已经试过新增和修改对象中的键值对。现在我们来看如何从一个对象中*移除*一个键值对。 +在之前的挑战中，我们已经试过添加和修改对象中的键值对。现在我们来看看如何从一个对象中*移除*一个键值对。 -我们再来看上一个挑战中的`foods`对象。如果我们想移除`apples`属性，我们可以使用`delete`关键字： +我们再来回顾一下上一个挑战中的 `foods` 对象。如果我们想移除 `apples` 属性，可以像这样使用 `delete` 关键字： ```js delete foods.apples; @@ -19,11 +19,11 @@ delete foods.apples; # --instructions-- -请你用 delete 关键字来移除`foods`中的`oranges`、`plums`和`strawberries`属性。 +请使用 `delete` 关键字来移除 `foods` 中的 `oranges`、`plums` 和 `strawberries` 属性。 # --hints-- -`foods`对象应该只含有 3 个键：`apples`、`grapes`和`bananas`。 +`foods` 对象应只包含 3 个属性：`apples`、`grapes` 和 `bananas`。 ```js assert( @@ -34,7 +34,7 @@ assert( ); ``` -你应该用`delete`关键字来移除`oranges`、`plums`和`strawberries`属性。 +应使用 `delete` 关键字来移除 `oranges`、`plums` 和 `strawberries` 属性。 ```js assert( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md index 86e79f080e..26776cc356 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/arguments-optional.md @@ -7,45 +7,51 @@ forumTopicId: 14271 # --description-- -创建一个将两个参数相加的函数。如果只传入了一个参数，则返回一个函数，需要传入一个参数并返回总和。 +创建一个将两个参数相加的函数。如果调用时只传入了一个参数，则应返回一个接收新的参数的函数。待传入下一个参数后，再返回与之前传入的参数之和。 -比如，`addTogether(2, 3)`应该返回`5`。而`addTogether(2)`应该返回一个函数。 +比如，`addTogether(2, 3)` 应该返回 `5`。而 `addTogether(2)` 应该返回一个函数。 -调用这个返回的函数，传入一个值，返回总和： +调用这个返回的函数，为它传入一个值，然后再返回总和： `var sumTwoAnd = addTogether(2);` -`sumTwoAnd(3)`此时应返回`5`。 +`sumTwoAnd(3)` 此时应返回 `5`。 -只要其中任何一个参数不是数字，那就应返回`undefined`。 +任何时候，只要任一传入的参数不是数字，就应返回 `undefined`。 # --hints-- -`addTogether(2, 3)`应该返回5。 +`addTogether(2, 3)` 应返回 5。 ```js assert.deepEqual(addTogether(2, 3), 5); ``` -`addTogether(2)(3)`应该返回5。 +`addTogether(23, 30)` 应返回 53。 ```js -assert.deepEqual(addTogether(2)(3), 5); +assert.deepEqual(addTogether(23, 30), 53); ``` -`addTogether("http://bit.ly/IqT6zt")`应返回undefined。 +`addTogether(5)(7)` 应返回 12。 + +```js +assert.deepEqual(addTogether(5)(7), 12); +``` + +`addTogether("http://bit.ly/IqT6zt")` 应返回 undefined。 ```js assert.isUndefined(addTogether('http://bit.ly/IqT6zt')); ``` -`addTogether(2, "3")`应返回undefined。 +`addTogether(2, "3")` 应返回 undefined。 ```js assert.isUndefined(addTogether(2, '3')); ``` -`addTogether(2)([3])`应返回undefined。 +`addTogether(2)([3])` 应返回 undefined。 ```js assert.isUndefined(addTogether(2)([3])); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md index fa4d020418..55dc3c7776 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/binary-agents.md @@ -1,19 +1,19 @@ --- id: a8d97bd4c764e91f9d2bda01 -title: 二进制转化 +title: 翻译二进制字符串 challengeType: 5 forumTopicId: 14273 --- # --description-- -写一个函数，把输入的二进制字符串转换成英文句子。 +请实现一个函数，把传入的二进制字符串转换成英文句子。 -二进制字符串将以空格分隔。 +二进制字符串会以空格分隔。 # --hints-- -`binaryAgent('01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111')`应该返回 'Aren't bonfires fun!?'。 +`binaryAgent('01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111')` 应返回 "Aren't bonfires fun!?"。 ```js assert.deepEqual( @@ -24,7 +24,7 @@ assert.deepEqual( ); ``` -`binaryAgent('01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001')`应该返回 'I love FreeCodeCamp!'。 +`binaryAgent('01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001')` 应返回 "I love FreeCodeCamp!"。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md index f471fea13c..cf27459275 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/convert-html-entities.md @@ -1,22 +1,23 @@ --- id: a6b0bb188d873cb2c8729495 -title: 转换HTML实体 +title: 转换 HTML 实体字符 challengeType: 5 +forumTopicId: 16007 --- # --description-- -在这道题目中，我们需要写一个转换 HTML entity 的函数。需要转换的 HTML entity 有`&`、`<`、`>`、`"`（双引号）和`'`（单引号）。 +请将字符串中的 `&`、`<`、`>`、`"`（双引号）和 `'`（单引号）转换为 [HTML 实体字符](https://developer.mozilla.org/zh-CN/docs/Glossary/Entity)，并返回转换之后的字符串。 # --hints-- -`convertHTML('Dolce & Gabbana')`应该返回`Dolce &​amp; Gabbana`。 +`convertHTML("Dolce & Gabbana")` 应返回 `"Dolce & Gabbana"`。 ```js assert.match(convertHTML('Dolce & Gabbana'), /Dolce & Gabbana/); ``` -`convertHTML('Hamburgers < Pizza < Tacos')`应该返回`Hamburgers &​lt; Pizza &​lt; Tacos`。 +`convertHTML("Hamburgers < Pizza < Tacos")` 应返回 `"Hamburgers < Pizza < Tacos"`。 ```js assert.match( @@ -25,13 +26,13 @@ assert.match( ); ``` -`convertHTML('Sixty > twelve')`应该返回`Sixty &​gt; twelve`。 +`convertHTML("Sixty > twelve")` 应返回 `"Sixty > twelve"`。 ```js assert.match(convertHTML('Sixty > twelve'), /Sixty > twelve/); ``` -`convertHTML('Stuff in "quotation marks"')`应该返回`Stuff in &​quot;quotation marks&​quot;`。 +`convertHTML('Stuff in "quotation marks"')` 应返回 `"Stuff in "quotation marks""`。 ```js assert.match( @@ -40,19 +41,19 @@ assert.match( ); ``` -`convertHTML('Schindler's List')`应该返回`Schindler&​apos;s List`。 +`convertHTML("Schindler's List")` 应返回 `"Schindler's List"`。 ```js assert.match(convertHTML("Schindler's List"), /Schindler's List/); ``` -`convertHTML('<>')`应该返回`&​lt;&​gt;`。 +`convertHTML("<>")` 应返回 `"<>"`。 ```js assert.match(convertHTML('<>'), /<>/); ``` -`convertHTML('abc')`应该返回`abc`。 +`convertHTML("abc")` 应返回 `"abc"`。 ```js assert.strictEqual(convertHTML('abc'), 'abc'); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md index 2520787815..7bedcc7abe 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/diff-two-arrays.md @@ -1,26 +1,26 @@ --- id: a5de63ebea8dbee56860f4f2 -title: 区分两个数组 +title: 数组的对称差 challengeType: 5 forumTopicId: 16008 --- # --description-- -在这道题目中，我们需要写一个函数，比较两个数组，返回一个新的数组。这个新数组需要包含传入的两个数组所有元素中，仅在其中一个数组里出现的元素。如果某个元素同时出现在两个数组中，则不应包含在返回的数组里。换言之，我们需要返回这两个数组的对称差。 +在这道题目中，我们需要实现一个函数，它可以比较两个输入数组并返回一个新数组；返回的新数组需包含传入的两个数组中，仅在一个数组里出现的元素。如果某个元素同时出现在两个数组中，则不应包含在返回的数组里。换言之，我们需要返回两个数组的对称差。 **注意：** -返回数组中的元素可任意排序。 +返回数组中的元素顺序不会影响挑战是否通过。 # --hints-- -`diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])`应该返回一个数组。 +`diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5])` 应返回一个数组。 ```js assert(typeof diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]) === 'object'); ``` -`['diorite', 'andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'], ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']`应该返回`['pink wool']`。 +`["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` 应返回 `["pink wool"]`。 ```js assert.sameMembers( @@ -32,7 +32,7 @@ assert.sameMembers( ); ``` -`['diorite', 'andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'], ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']`应该返回一个长度为 1 的数组。 +`["diorite", "andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` 应返回一个长度为 1 的数组。 ```js assert( @@ -43,7 +43,7 @@ assert( ); ``` -`['andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'], ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']`应该返回`['diorite', 'pink wool']`。 +`["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` 应返回 `["diorite", "pink wool"]`。 ```js assert.sameMembers( @@ -55,7 +55,7 @@ assert.sameMembers( ); ``` -`['andesite', 'grass', 'dirt', 'pink wool', 'dead shrub'], ['diorite', 'andesite', 'grass', 'dirt', 'dead shrub']`应该返回一个长度为 2 的数组。 +`["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]` 应返回一个长度为 2 的数组。 ```js assert( @@ -66,7 +66,7 @@ assert( ); ``` -`['andesite', 'grass', 'dirt', 'dead shrub'], ['andesite', 'grass', 'dirt', 'dead shrub']`应该返回`[]`。 +`["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]` 应返回 `[]`。 ```js assert.sameMembers( @@ -78,7 +78,7 @@ assert.sameMembers( ); ``` -`['andesite', 'grass', 'dirt', 'dead shrub'], ['andesite', 'grass', 'dirt', 'dead shrub']`应该返回一个空数组。 +`["andesite", "grass", "dirt", "dead shrub"], ["andesite", "grass", "dirt", "dead shrub"]` 应返回一个空数组。 ```js assert( @@ -89,19 +89,19 @@ assert( ); ``` -`[1, 2, 3, 5], [1, 2, 3, 4, 5]`应该返回`[4]`。 +`[1, 2, 3, 5], [1, 2, 3, 4, 5]` 应返回 `[4]`。 ```js assert.sameMembers(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]), [4]); ``` -`[1, 2, 3, 5], [1, 2, 3, 4, 5]`应该返回一个长度为 1 的数组。 +`[1, 2, 3, 5], [1, 2, 3, 4, 5]` 应返回一个长度为 1 的数组。 ```js assert(diffArray([1, 2, 3, 5], [1, 2, 3, 4, 5]).length === 1); ``` -`[1, 'calf', 3, 'piglet'], [1, 'calf', 3, 4]`应该返回`['piglet', 4]`。 +`[1, "calf", 3, "piglet"], [1, "calf", 3, 4]` 应返回 `["piglet", 4]`。 ```js assert.sameMembers(diffArray([1, 'calf', 3, 'piglet'], [1, 'calf', 3, 4]), [ @@ -110,13 +110,13 @@ assert.sameMembers(diffArray([1, 'calf', 3, 'piglet'], [1, 'calf', 3, 4]), [ ]); ``` -`[1, 'calf', 3, 'piglet'], [1, 'calf', 3, 4]`应该返回一个长度为 2 的数组。 +`[1, "calf", 3, "piglet"], [1, "calf", 3, 4]` 应返回一个长度为 2 的数组。 ```js assert(diffArray([1, 'calf', 3, 'piglet'], [1, 'calf', 3, 4]).length === 2); ``` -`[], ['snuffleupagus', 'cookie monster', 'elmo']`应该返回`['snuffleupagus', 'cookie monster', 'elmo']`。 +`[], ["snuffleupagus", "cookie monster", "elmo"]` 应返回 `["snuffleupagus", "cookie monster", "elmo"]`。 ```js assert.sameMembers(diffArray([], ['snuffleupagus', 'cookie monster', 'elmo']), [ @@ -126,13 +126,13 @@ assert.sameMembers(diffArray([], ['snuffleupagus', 'cookie monster', 'elmo']), [ ]); ``` -`[], ['snuffleupagus', 'cookie monster', 'elmo']`应该返回一个长度为 3 的数组。 +`[], ["snuffleupagus", "cookie monster", "elmo"]` 应返回一个长度为 3 的数组。 ```js assert(diffArray([], ['snuffleupagus', 'cookie monster', 'elmo']).length === 3); ``` -`[1, 'calf', 3, 'piglet'], [7, 'filly']`应该返回`[1, 'calf', 3, 'piglet', 7, 'filly']`。 +`[1, "calf", 3, "piglet"], [7, "filly"]` 应返回 `[1, "calf", 3, "piglet", 7, "filly"]`。 ```js assert.sameMembers(diffArray([1, 'calf', 3, 'piglet'], [7, 'filly']), [ @@ -145,7 +145,7 @@ assert.sameMembers(diffArray([1, 'calf', 3, 'piglet'], [7, 'filly']), [ ]); ``` -`[1, 'calf', 3, 'piglet'], [7, 'filly']`应该返回一个长度为 6 的数组。 +`[1, "calf", 3, "piglet"], [7, "filly"]` 应返回一个长度为 6 的数组。 ```js assert(diffArray([1, 'calf', 3, 'piglet'], [7, 'filly']).length === 6); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md index 3e9332f6de..0f33385cea 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/dna-pairing.md @@ -7,19 +7,19 @@ forumTopicId: 16009 # --description-- -DNA 链缺少配对元素。对于每个字符，获取与其配对的元素，并将结果作为二维数组返回。 +给出的 DNA 链上缺少配对元素。请基于每个字符，获取与其配对的元素，并将结果作为二维数组返回。 -[碱基对](http://en.wikipedia.org/wiki/Base_pair) 是一对 AT 和 CG。将缺少的元素与提供的字符匹配。 +DNA 的[碱基对](http://en.wikipedia.org/wiki/Base_pair) 有两种形式：一种是 A 与 T，一种是 C 与 G。请为参数中给出的每个字符配对相应的碱基。 -将提供的字符作为每个数组中的第一个元素返回。 +注意，参数中给出的字符应作为每个子数组中的第一个元素返回。 -例如，对于输入 GCG，返回\[\[“G”, “C”]，\[“C”, “G”]，\[“G”, “C”]]。 +例如，传入 GCG 时，应返回 \[\["G", "C"], \["C", "G"], \["G", "C"]]。 -字符及与其配对的元素在一个数组中。再将所有数组放到一个封装数组中。 +参数中的字符及与其配对的碱基应存在于一个数组中，代表碱基对。再将每个配对完成的碱基对数组按顺序放到一个数组中，作为最终的返回结果。 # --hints-- -`pairElement('ATCGA')`应该返回`[['A','T'],['T','A'],['C','G'],['G','C'],['A','T']]`。 +`pairElement("ATCGA")` 应返回 `[["A","T"],["T","A"],["C","G"],["G","C"],["A","T"]]`。 ```js assert.deepEqual(pairElement('ATCGA'), [ @@ -31,7 +31,7 @@ assert.deepEqual(pairElement('ATCGA'), [ ]); ``` -`pairElement('TTGAG')`应该返回`[['T','A'],['T','A'],['G','C'],['A','T'],['G','C']]`。 +`pairElement("TTGAG")` 应返回 `[["T","A"],["T","A"],["G","C"],["A","T"],["G","C"]]`。 ```js assert.deepEqual(pairElement('TTGAG'), [ @@ -43,7 +43,7 @@ assert.deepEqual(pairElement('TTGAG'), [ ]); ``` -`pairElement('CTCTA')`应该返回`[['C','G'],['T','A'],['C','G'],['T','A'],['A','T']]`。 +`pairElement("CTCTA")` 应返回 `[["C","G"],["T","A"],["C","G"],["T","A"],["A","T"]]`。 ```js assert.deepEqual(pairElement('CTCTA'), [ diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md index c99bb55687..6d7b429974 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/drop-it.md @@ -1,19 +1,19 @@ --- id: a5deed1811a43193f9f1c841 -title: 筛选出数组中满足条件的元素 +title: 根据参数删除数组元素 challengeType: 5 forumTopicId: 16010 --- # --description-- -给定数组`arr`，从数组的第一个元素开始，用函数`func`来检查数组的每个元素并删除，直到某个元素传入函数`func`时返回`true`。函数最终的返回值也是一个数组，它由原数组中第一个使得`func`为`true`的元素及其之后的所有元素组成。 +给定数组 `arr`，从数组的第一个元素开始，用函数 `func` 来检查数组的每个元素是否返回 `true`。如果返回 `false`，就把这个元素删除。持续执行删除操作，直到某个元素传入 `func` 时返回 `true` 为止。换言之，函数的最终返回值也应是一个数组，它由原数组中第一个使得 `func` 为 `true` 的元素及其之后的所有元素组成。 -如果数组中的所有元素都不能让`func`为`true`，则返回空数组`[]`。 +如果数组中的所有元素都不能让 `func` 为 `true`，则返回空数组 `[]`。 # --hints-- -`dropElements([1, 2, 3, 4], function(n) {return n >= 3;})`应该返回`[3, 4]`。 +`dropElements([1, 2, 3, 4], function(n) {return n >= 3;})` 应返回 `[3, 4]`。 ```js assert.deepEqual( @@ -24,7 +24,7 @@ assert.deepEqual( ); ``` -`dropElements([0, 1, 0, 1], function(n) {return n === 1;})`应该返回`[1, 0, 1]`。 +`dropElements([0, 1, 0, 1], function(n) {return n === 1;})` 应返回 `[1, 0, 1]`。 ```js assert.deepEqual( @@ -35,7 +35,7 @@ assert.deepEqual( ); ``` -`dropElements([1, 2, 3], function(n) {return n > 0;})`应该返回`[1, 2, 3]`。 +`dropElements([1, 2, 3], function(n) {return n > 0;})` 应返回 `[1, 2, 3]`。 ```js assert.deepEqual( @@ -46,7 +46,7 @@ assert.deepEqual( ); ``` -`dropElements([1, 2, 3, 4], function(n) {return n > 5;})`应该返回`[]`。 +`dropElements([1, 2, 3, 4], function(n) {return n > 5;})` 应返回 `[]`。 ```js assert.deepEqual( @@ -57,7 +57,7 @@ assert.deepEqual( ); ``` -`dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;})`应该返回`[7, 4]`。 +`dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;})` 应返回 `[7, 4]`。 ```js assert.deepEqual( @@ -68,7 +68,7 @@ assert.deepEqual( ); ``` -`dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;})`应该返回`[3, 9, 2]`。 +`dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;})` 应返回 `[3, 9, 2]`。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md index 34ac3b2f73..e5b3f586dc 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/everything-be-true.md @@ -1,23 +1,23 @@ --- id: a10d2431ad0c6a099a4b8b52 -title: 真假值判断 +title: 检查对象属性 challengeType: 5 forumTopicId: 16011 --- # --description-- -检查谓词（第二个参数）是否对集合的所有元素（第一个参数）都是`truthy`（真实的）。 +对于第一个参数（对象数组）中的每个元素，检查第二个参数（字符串）所对应的属性值是否都为 truthy。 -换句话说，你将获得一个对象的数组集合。谓词`pre`是一个对象的属性，如果它的值是`truthy`（真实的） ，则返回`true`，否则，返回`false` 。 +换句话说，函数的第一个参数是一个对象数组，第二个参数是一个字符串 `pre`，表示对象的属性。如果数组中的每个对象里，`pre` 对应属性值均为 `truthy`，则返回 `true`；否则返回 `false`。 -JavaScript 中，如果一个值在 Boolean 的上下文中（比如`if`语句）可以被执行为`true`，那么这个值就被认为是`truthy`的。 +JavaScript 中，如果一个值在 Boolean 的上下文中（比如 `if` 语句）的执行结果为 `true`，那么我们称这个值是 `truthy` 的。 -注意，你可以选择使用`.`或`[]`来访问对象属性对应的值。 +别忘了，你可以使用点号表示法（`.`）或方括号表示法（`[]`）来访问对象的属性。 # --hints-- -`truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")`应该返回`true`。 +`truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")` 应返回 true。 ```js assert.strictEqual( @@ -34,7 +34,7 @@ assert.strictEqual( ); ``` -`truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")`应该返回`false`。 +`truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex")` 应返回 false。 ```js assert.strictEqual( @@ -51,7 +51,7 @@ assert.strictEqual( ); ``` -`truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age")`应该返回`false`。 +`truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age")` 应返回 false。 ```js assert.strictEqual( @@ -68,7 +68,7 @@ assert.strictEqual( ); ``` -`truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastFoward", "onBoat": null}], "onBoat")`应该返回`false`。 +`truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastForward", "onBoat": null}], "onBoat")` 应返回 false。 ```js assert.strictEqual( @@ -76,7 +76,7 @@ assert.strictEqual( [ { name: 'Pete', onBoat: true }, { name: 'Repeat', onBoat: true }, - { name: 'FastFoward', onBoat: null } + { name: 'FastForward', onBoat: null } ], 'onBoat' ), @@ -84,7 +84,7 @@ assert.strictEqual( ); ``` -`truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastFoward", "onBoat": true}], "onBoat")`应该返回`true`。 +`truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastForward", "onBoat": true}], "onBoat")` 应返回 true。 ```js assert.strictEqual( @@ -92,7 +92,7 @@ assert.strictEqual( [ { name: 'Pete', onBoat: true }, { name: 'Repeat', onBoat: true, alias: 'Repete' }, - { name: 'FastFoward', onBoat: true } + { name: 'FastForward', onBoat: true } ], 'onBoat' ), @@ -100,13 +100,13 @@ assert.strictEqual( ); ``` -`truthCheck([{"single": "yes"}], "single")`应该返回`true`。 +`truthCheck([{"single": "yes"}], "single")` 应返回 true。 ```js assert.strictEqual(truthCheck([{ single: 'yes' }], 'single'), true); ``` -`truthCheck([{"single": ""}, {"single": "double"}], "single")`应该返回`false`。 +`truthCheck([{"single": ""}, {"single": "double"}], "single")` 应返回 false。 ```js assert.strictEqual( @@ -115,7 +115,7 @@ assert.strictEqual( ); ``` -`truthCheck([{"single": "double"}, {"single": undefined}], "single")`应该返回`false`。 +`truthCheck([{"single": "double"}, {"single": undefined}], "single")` 应返回 false。 ```js assert.strictEqual( @@ -124,7 +124,7 @@ assert.strictEqual( ); ``` -`truthCheck([{"single": "double"}, {"single": NaN}], "single")`应该返回`false`。 +`truthCheck([{"single": "double"}, {"single": NaN}], "single")` 应返回 false。 ```js assert.strictEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md index be95af24d2..49da0f4e29 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/make-a-person.md @@ -1,13 +1,13 @@ --- id: a2f1d72d9b908d0bd72bb9f6 -title: 构造一个 Person 类 +title: 构建 Person 类 challengeType: 5 forumTopicId: 16020 --- # --description-- -在这道题目中，我们需要写一个构造器（constructor）函数。它只接收一个字符串参数`firstAndLast`，这个参数代表一个英文名的全名（姓和名）。这个构造函数创建出的实例需要具有以下方法： +在这道题目中，我们需要写一个构造器（constructor）函数。它只接收一个字符串参数 `firstAndLast`，这个参数代表一个英文名的全名（包含姓和名）。通过这个构造函数创建出的实例需要具有以下方法： ```js getFirstName() @@ -18,53 +18,53 @@ setLastName(last) setFullName(firstAndLast) ``` -你可以点击 “运行测试”，然后就可以在底下的控制台中看到每个测试用例执行的情况。 方法接收一个字符串格式的参数。 这些方法必须是与对象进行交互的唯一可用方法。 如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +你可以点击“运行测试”，然后就可以在底下的控制台中看到每个测试用例执行的情况。以上方法中，接收一个参数的方法只会接收一个字符串作为参数。同时，我们只会通过以上定义的这些方法与实例进行交互。 # --hints-- -`Object.keys(bob).length`应该返回 6。 +`Object.keys(bob).length` 应返回 6。 ```js assert.deepEqual(Object.keys(bob).length, 6); ``` -`bob instanceof Person`应该返回`true`。 +`bob instanceof Person` 应返回 true。 ```js assert.deepEqual(bob instanceof Person, true); ``` -`bob.firstName`应该返回`undefined`。 +`bob.firstName` 应返回 undefined。 ```js assert.deepEqual(bob.firstName, undefined); ``` -`bob.lastName`应该返回`undefined`。 +`bob.lastName` 应返回 undefined。 ```js assert.deepEqual(bob.lastName, undefined); ``` -`bob.getFirstName()`应该返回 'Bob'。 +`bob.getFirstName()` 应返回 "Bob"。 ```js assert.deepEqual(bob.getFirstName(), 'Bob'); ``` -`bob.getLastName()`应该返回 'Ross'。 +`bob.getLastName()` 应返回 "Ross"。 ```js assert.deepEqual(bob.getLastName(), 'Ross'); ``` -`bob.getFullName()`应该返回 'Bob Ross'。 +`bob.getFullName()` 应返回 "Bob Ross"。 ```js assert.deepEqual(bob.getFullName(), 'Bob Ross'); ``` -调用`bob.setFirstName('Haskell')`之后，`bob.getFullName()`应该返回 'Haskell Ross'。 +在执行 `bob.setFirstName("Haskell")` 后，`bob.getFullName()` 应返回 "Haskell Ross"。 ```js assert.strictEqual( @@ -76,7 +76,7 @@ assert.strictEqual( ); ``` -调用`bob.setLastName('Curry')`之后，`bob.getFullName()`应该返回 'Haskell Curry'。 +在执行 `bob.setLastName("Curry")` 后，`bob.getFullName()` 应返回 "Haskell Curry"。 ```js assert.strictEqual( @@ -89,7 +89,7 @@ assert.strictEqual( ); ``` -调用`bob.setFullName('Haskell Curry')`之后，`bob.getFullName()`应该返回 'Haskell Curry'。 +在执行 `bob.setFullName("Haskell Curry")` 后，`bob.getFullName()` 应返回 "Haskell Curry"。 ```js assert.strictEqual( @@ -101,7 +101,7 @@ assert.strictEqual( ); ``` -调用`bob.setFullName('Haskell Curry')`之后，`bob.getFirstName()`应该返回 'Haskell'。 +在执行 `bob.setFullName("Haskell Curry")` 后，`bob.getFirstName()` 应返回 "Haskell"。 ```js assert.strictEqual( @@ -113,7 +113,7 @@ assert.strictEqual( ); ``` -调用`bob.setFullName('Haskell Curry')`之后，`bob.getLastName()`应该返回 'Curry'。 +在执行 `bob.setFullName("Haskell Curry")` 后，`bob.getLastName()` 应返回 "Curry"。 ```js assert.strictEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md index 4005f43bae..7e0fec7c09 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/map-the-debris.md @@ -1,27 +1,31 @@ --- id: af4afb223120f7348cdfc9fd -title: 绘制碎片图 +title: 计算轨道周期 challengeType: 5 forumTopicId: 16021 --- # --description-- -在这道题目中，我们需要写一个计算天体轨道周期的函数，它接收一个对象数组参数`arr`，对象中包含表示天体名称的`name`属性，及表示天体表面平均海拔的`avgAlt`属性。就像这样：`{name: 'name', avgAlt: avgAlt}`。 +在这道题目中，我们需要写一个计算天体轨道周期（单位是秒）的函数。 -这个函数的返回值也是一个对象数组，应保留原对象中的`name`属性和值，然后根据`avgAlt`属性的值求出轨道周期（单位是秒），并赋值给`orbitalPeriod`属性。返回值中不应保留原数据中的`avgAlt`属性及其对应的值。 +它接收一个对象数组参数 `arr`，对象中包含表示天体名称的 `name` 属性，及表示天体表面平均海拔的 `avgAlt` 属性。就像这样：`{name: 'name', avgAlt: avgAlt}`。 -你可以在这条[维基百科](http://en.wikipedia.org/wiki/Orbital_period)的链接中找到轨道周期的计算公式。 +这个函数的返回值也是一个对象数组，应保留原对象中的 `name` 属性及其属性值，然后根据 `avgAlt` 的属性值求出轨道周期（单位是秒），并赋值给 `orbitalPeriod` 属性。返回值中不应保留原数据中的 `avgAlt` 属性。 -轨道周期的计算以地球为基准（即环绕地球的轨道周期），计算结果应取整到最接近的整数。 +你可以在这条[维基百科](http://en.wikipedia.org/wiki/Orbital_period)的链接中找到轨道周期的计算公式： + +``` +T = 2π*(a^3/GM)^(1/2) +``` + +轨道周期的计算以地球为基准（即环绕地球的轨道周期），因此公式中的 `a` 为数组对象中的 `avgAlt` 加上地球半径。最终的计算结果应取整到最接近的整数。 地球的半径是 6367.4447 千米，地球的 GM 值为 398600.4418 km3s-2。 -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 - # --hints-- -`orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}])`应该返回`[{name: "sputnik", orbitalPeriod: 86400}]`。 +`orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}])` 应返回 `[{name: "sputnik", orbitalPeriod: 86400}]`。 ```js assert.deepEqual(orbitalPeriod([{ name: 'sputnik', avgAlt: 35873.5553 }]), [ @@ -29,7 +33,7 @@ assert.deepEqual(orbitalPeriod([{ name: 'sputnik', avgAlt: 35873.5553 }]), [ ]); ``` -`orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}])`应该返回`[{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}]`。 +`orbitalPeriod([{name: "iss", avgAlt: 413.6}, {name: "hubble", avgAlt: 556.7}, {name: "moon", avgAlt: 378632.553}])` 应返回 `[{name : "iss", orbitalPeriod: 5557}, {name: "hubble", orbitalPeriod: 5734}, {name: "moon", orbitalPeriod: 2377399}]`。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md index 16b97d897d..c875ad479f 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/missing-letters.md @@ -1,44 +1,42 @@ --- id: af7588ade1100bde429baf20 -title: 丢失的字母 +title: 寻找缺失的字母 challengeType: 5 --- # --description-- -在这道题目中，我们需要写一个函数，找到传入的字符串里缺失的字母并返回它。 +在这道题目中，我们需要写一个函数，找出传入的字符串里缺失的字母并返回它。 -判断缺失的依据是字母顺序，比如 abcdfg 中缺失了 e。而 abcdef 中就没有字母缺失，此时我们需要返回`undefined`。 - -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +判断缺失的依据是字母顺序。对于没有缺失的情况，请返回 `undefined`。 # --hints-- -`fearNotLetter('abce')`应该返回 'd'。 +`fearNotLetter("abce")` 应返回 "d"。 ```js assert.deepEqual(fearNotLetter('abce'), 'd'); ``` -`fearNotLetter('abcdefghjklmno')`应该返回 'i'。 +`fearNotLetter("abcdefghjklmno")` 应返回 "i"。 ```js assert.deepEqual(fearNotLetter('abcdefghjklmno'), 'i'); ``` -`fearNotLetter('stvwx')`应该返回 'u'。 +`fearNotLetter("stvwx")` 应返回 "u"。 ```js assert.deepEqual(fearNotLetter('stvwx'), 'u'); ``` -`fearNotLetter('bcdf')`应该返回 'e'。 +`fearNotLetter("bcdf")` 应返回 "e"。 ```js assert.deepEqual(fearNotLetter('bcdf'), 'e'); ``` -`fearNotLetter('abcdefghijklmnopqrstuvwxyz')`应该返回`undefined`。 +`fearNotLetter("abcdefghijklmnopqrstuvwxyz")` 应返回 undefined。 ```js assert.isUndefined(fearNotLetter('abcdefghijklmnopqrstuvwxyz')); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md index e2f527db25..e14c1422f5 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/pig-latin.md @@ -7,57 +7,57 @@ forumTopicId: 16039 # --description-- -在这道题目中，我们需要写一个函数，把传入的字符串翻译成“儿童黑话”。 +[儿童黑话](http://en.wikipedia.org/wiki/Pig_Latin)，也叫 Pig Latin，是一种英语语言游戏。规则如下： -[儿童黑话](http://en.wikipedia.org/wiki/Pig_Latin)的基本转换规则很简单，只需要把一个英文单词的第一个辅音字母或第一组辅音簇移到单词的结尾，并在后面加上`ay`即可。在英语中，字母 a、e、i、o、u 为元音，其余的字母均为辅音。辅音簇的意思是连续的多个辅音字母。 +\- 如果单词以辅音开头，就把第一个辅音字母或第一组辅音簇移到单词的结尾，并在后面加上 "ay"。 -额外地，如果单词本身是以元音开头的，那只需要在结尾加上`way`。 +\- 如果单词以元音开头，只需要在结尾加上 "way"。 -额外地，如果单词不包含元音，那只需要在结尾加上`ay`。 +在英语中，字母 a、e、i、o、u 为元音，其余的字母均为辅音。辅音簇的意思是连续的多个辅音字母。 -在本题中，传入的单词一定会是英文单词，且所有字母均为小写。 +# --instructions-- -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +请把传入的字符串根据上述规则翻译成儿童黑话并返回结果。输入的字符串一定是一个小写的英文单词。 # --hints-- -`translatePigLatin('california')`应该返回 'aliforniacay'。 +`translatePigLatin("california")` 应返回 "aliforniacay"。 ```js assert.deepEqual(translatePigLatin('california'), 'aliforniacay'); ``` -`translatePigLatin('paragraphs')`应该返回 'aragraphspay'。 +`translatePigLatin("paragraphs")` 应返回 "aragraphspay"。 ```js assert.deepEqual(translatePigLatin('paragraphs'), 'aragraphspay'); ``` -`translatePigLatin('glove')`应该返回 'oveglay'。 +`translatePigLatin("glove")` 应返回 "oveglay"。 ```js assert.deepEqual(translatePigLatin('glove'), 'oveglay'); ``` -`translatePigLatin('algorithm')`应该返回 'algorithmway'。 +`translatePigLatin("algorithm")` 应返回 "algorithmway"。 ```js assert.deepEqual(translatePigLatin('algorithm'), 'algorithmway'); ``` -`translatePigLatin('eight')`应该返回 'eightway'。 +`translatePigLatin("eight")` 应返回 "eightway"。 ```js assert.deepEqual(translatePigLatin('eight'), 'eightway'); ``` -你的代码应该能处理第一个 vowel 在单词中间的情况。比如`translatePigLatin('schwartz')` 应该返回 'artzschway' +Should handle words where the first vowel comes in the middle of the word. `translatePigLatin("schwartz")` 应返回 "artzschway"。 ```js assert.deepEqual(translatePigLatin('schwartz'), 'artzschway'); ``` -你的代码应当能够处理单词中不含元音字母的情况。比如`translatePigLatin('rhythm')`应该返回 'rhythmay'。 +应可以处理不含元音的单词，`translatePigLatin("rhythm")` 应返回 "rhythmay"。 ```js assert.deepEqual(translatePigLatin('rhythm'), 'rhythmay'); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md index 2b933003d8..a500b7bed7 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/search-and-replace.md @@ -1,6 +1,6 @@ --- id: a0b5010f579e69b815e7c5d6 -title: 搜索和替换 +title: 搜索与替换 challengeType: 5 forumTopicId: 16045 --- @@ -18,11 +18,9 @@ forumTopicId: 16045 **注意：** 你需要保留被替换单词首字母的大小写格式。即如果传入的第二个参数为 "Book"，第三个参数为 "dog"，那么替换后的结果应为 "Dog" -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 - # --hints-- -`myReplace('Let us go to the store', 'store', 'mall')`应该返回 'Let us go to the mall'。 +`myReplace("Let us go to the store", "store", "mall")` 应返回 "Let us go to the mall"。 ```js assert.deepEqual( @@ -31,7 +29,7 @@ assert.deepEqual( ); ``` -`myReplace('He is Sleeping on the couch', 'Sleeping', 'sitting')`应该返回 'He is Sitting on the couch'。 +`myReplace("He is Sleeping on the couch", "Sleeping", "sitting")` 应返回 "He is Sitting on the couch"。 ```js assert.deepEqual( @@ -40,7 +38,16 @@ assert.deepEqual( ); ``` -`myReplace('This has a spellngi error', 'spellngi', 'spelling')`应该返回 'This has a spelling error'。 +`myReplace("I think we should look up there", "up", "Down")` 应返回 "I think we should look down there"。 + +```js +assert.deepEqual( + myReplace('I think we should look up there', 'up', 'Down'), + 'I think we should look down there' +); +``` + +`myReplace("This has a spellngi error", "spellngi", "spelling")` 应返回 "This has a spelling error"。 ```js assert.deepEqual( @@ -49,7 +56,7 @@ assert.deepEqual( ); ``` -`myReplace('His name is Tom', 'Tom', 'john')`应该返回 'His name is John'。 +`myReplace("His name is Tom", "Tom", "john")` 应返回 "His name is John"。 ```js assert.deepEqual( @@ -58,7 +65,7 @@ assert.deepEqual( ); ``` -`myReplace('Let us get back to more Coding', 'Coding', 'algorithms')`应该返回 'Let us get back to more Algorithms'。 +`myReplace("Let us get back to more Coding", "Coding", "algorithms")` 应返回 "Let us get back to more Algorithms"。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md index 4b619d7ca4..27c99aa4a5 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/seek-and-destroy.md @@ -1,46 +1,44 @@ --- id: a39963a4c10bc8b4d4f06d7e -title: 瞄准和消灭 +title: 过滤数组元素 challengeType: 5 forumTopicId: 16046 --- # --description-- -在这道题目中，我们要写一个叫`destroyer`的函数。传给它的第一个参数是数组，我们称他为初始数组。后续的参数数量是不确定的，可能有一个或多个。你需要做的是，从初始数组中移除所有与后续参数相等的元素，并返回移除元素后的数组。 +在这道题目中，我们要写一个叫 `destroyer` 的函数。传入的第一个参数是一个数组，我们称他为初始数组。后续的参数数量是不确定的，可能有一个或多个。你需要做的是，从初始数组中移除所有与后续参数相等的元素，并返回移除元素后的数组。 **注意：** -你可以使用`arguments`对象，也可以使用`...`，即“剩余参数”（Rest Parameters）语法。 - -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +你可以使用 `arguments` 对象，也可以使用 `...`，即“剩余参数”（Rest Parameters）语法。 # --hints-- -`destroyer([1, 2, 3, 1, 2, 3], 2, 3)`应该返回`[1, 1]`。 +`destroyer([1, 2, 3, 1, 2, 3], 2, 3)` 应返回 `[1, 1]`。 ```js assert.deepEqual(destroyer([1, 2, 3, 1, 2, 3], 2, 3), [1, 1]); ``` -`destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)`应该返回`[1, 5, 1]`。 +`destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3)` 应返回 `[1, 5, 1]`。 ```js assert.deepEqual(destroyer([1, 2, 3, 5, 1, 2, 3], 2, 3), [1, 5, 1]); ``` -`destroyer([3, 5, 1, 2, 2], 2, 3, 5)`应该返回`[1]`。 +`destroyer([3, 5, 1, 2, 2], 2, 3, 5)` 应返回 `[1]`。 ```js assert.deepEqual(destroyer([3, 5, 1, 2, 2], 2, 3, 5), [1]); ``` -`destroyer([2, 3, 2, 3], 2, 3)`应该返回`[]`。 +`destroyer([2, 3, 2, 3], 2, 3)` 应返回 `[]`。 ```js assert.deepEqual(destroyer([2, 3, 2, 3], 2, 3), []); ``` -`destroyer(['tree', 'hamburger', 53], 'tree', 53)`应该返回`['hamburger']`。 +`destroyer(["tree", "hamburger", 53], "tree", 53)` 应返回 `["hamburger"]`。 ```js assert.deepEqual(destroyer(['tree', 'hamburger', 53], 'tree', 53), [ @@ -48,7 +46,7 @@ assert.deepEqual(destroyer(['tree', 'hamburger', 53], 'tree', 53), [ ]); ``` -`destroyer(['possum', 'trollo', 12, 'safari', 'hotdog', 92, 65, 'grandma', 'bugati', 'trojan', 'yacht'], 'yacht', 'possum', 'trollo', 'safari', 'hotdog', 'grandma', 'bugati', 'trojan')`应该返回`[12,92,65]`。 +`destroyer(["possum", "trollo", 12, "safari", "hotdog", 92, 65, "grandma", "bugati", "trojan", "yacht"], "yacht", "possum", "trollo", "safari", "hotdog", "grandma", "bugati", "trojan")` 应返回 `[12,92,65]`。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md index 3bc46f68fc..624920eaf9 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/smallest-common-multiple.md @@ -1,53 +1,51 @@ --- id: ae9defd7acaf69703ab432ea -title: 最小公倍数 +title: 找出数字范围内的最小公倍数 challengeType: 5 forumTopicId: 16075 --- # --description-- -在这道题目中，我们需要写一个函数，它接收一个包含两个数字的数组参数`arr`，它的返回值为这两个数字范围内所有数字（包含这两个数字）的最小公倍数。 +在这道题目中，我们需要写一个函数，它接收一个包含两个数字的数组参数 `arr`；它的返回值为这两个数字范围内所有数字（包含这两个数字）的最小公倍数。 注意，较小数不一定总是出现在数组的第一个元素。 -比如，传入`[1, 3]`，那么函数的返回结果应为 1、2、3 的最小公倍数，即为 6。 - -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +比如，传入 `[1, 3]`，那么函数的返回结果应为 1、2、3 的最小公倍数，即为 6。 # --hints-- -`smallestCommons([1, 5])`应该返回一个数字。 +`smallestCommons([1, 5])` 应返回 a number。 ```js assert.deepEqual(typeof smallestCommons([1, 5]), 'number'); ``` -`smallestCommons([1, 5])`应该返回 60。 +`smallestCommons([1, 5])` 应返回 60。 ```js assert.deepEqual(smallestCommons([1, 5]), 60); ``` -`smallestCommons([5, 1])`应该返回 60。 +`smallestCommons([5, 1])` 应返回 60。 ```js assert.deepEqual(smallestCommons([5, 1]), 60); ``` -`smallestCommons([2, 10])`应该返回 2520。. +`smallestCommons([2, 10])` 应返回 2520。 ```js assert.deepEqual(smallestCommons([2, 10]), 2520); ``` -`smallestCommons([1, 13])`应该返回 360360。 +`smallestCommons([1, 13])` 应返回 360360。 ```js assert.deepEqual(smallestCommons([1, 13]), 360360); ``` -`smallestCommons([23, 18])`应该返回 6056820。 +`smallestCommons([23, 18])` 应返回 6056820。 ```js assert.deepEqual(smallestCommons([23, 18]), 6056820); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md index d7de9b5e3d..0aec46b366 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sorted-union.md @@ -7,31 +7,29 @@ forumTopicId: 16077 # --description-- -在这道题目中，我们需要写一个函数，它接收两个或多个数组为参数。我们需要对这些数组中所有元素进行去除重复元素的处理，并以数组的形式返回去重结果。 +在这道题目中，我们需要写一个函数，它接收两个或多个数组为参数。我们需要首先求出所有数组的并集，然后进行去除重复元素的处理，并以数组的形式返回去重结果。 换句话说，所有数组中出现的所有值都应按其原始顺序包括在内，但最终数组中不得重复。 -唯一数字应按其原始顺序排序，但最终数组不应按数字顺序排序。 +去重后的数字应按其出现在参数中的原始顺序排序，最终数组不应按数字大小进行排序。 如有疑问，请先浏览下方的测试用例。 -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 - # --hints-- -`uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1])`应该返回`[1, 3, 2, 5, 4]`。 +`uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1])` 应返回 `[1, 3, 2, 5, 4]`。 ```js assert.deepEqual(uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]), [1, 3, 2, 5, 4]); ``` -`uniteUnique([1, 2, 3], [5, 2, 1])`应该返回`[1, 2, 3, 5]`。 +`uniteUnique([1, 2, 3], [5, 2, 1])` 应返回 `[1, 2, 3, 5]`。 ```js assert.deepEqual(uniteUnique([1, 2, 3], [5, 2, 1]), [1, 2, 3, 5]); ``` -`uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8])`应该返回`[1, 2, 3, 5, 4, 6, 7, 8]`。 +`uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8])` 应返回 `[1, 2, 3, 5, 4, 6, 7, 8]`。 ```js assert.deepEqual(uniteUnique([1, 2, 3], [5, 2, 1, 4], [2, 1], [6, 7, 8]), [ diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md index 587aa1f4c1..79cf3fc8a7 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/spinal-tap-case.md @@ -7,25 +7,23 @@ forumTopicId: 16078 # --description-- -在这道题目中，我们需要写一个函数，把一个字符串转换为“短线连接格式”。短线连接格式的意思是，所有字母都是小写，且用`-`连接。比如，对于`Hello World`，应该转换为`hello-world`；对于`I love_Javascript-VeryMuch`，应该转换为`i-love-javascript-very-much`。 - -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +在这道题目中，我们需要写一个函数，把一个字符串转换为“短线连接格式”。短线连接格式的意思是，所有字母都是小写，且用 `-` 连接。比如，`Hello World` 的短线连接格式为 `hello-world`；`I love_Javascript-VeryMuch` 的短线连接格式为 `i-love-javascript-very-much`。 # --hints-- -`spinalCase('This Is Spinal Tap')`应该返回`'this-is-spinal-tap'`。 +`spinalCase("This Is Spinal Tap")` 应返回 `"this-is-spinal-tap"`。 ```js assert.deepEqual(spinalCase('This Is Spinal Tap'), 'this-is-spinal-tap'); ``` -`spinalCase('thisIsSpinalTap')`应该返回`'this-is-spinal-tap'`。 +`spinalCase("thisIsSpinalTap")` 应返回 `"this-is-spinal-tap"`。 ```js assert.strictEqual(spinalCase('thisIsSpinalTap'), 'this-is-spinal-tap'); ``` -`spinalCase('The_Andy_Griffith_Show')`应该返回`'the-andy-griffith-show'`。 +`spinalCase("The_Andy_Griffith_Show")` 应返回 `"the-andy-griffith-show"`。 ```js assert.strictEqual( @@ -34,7 +32,7 @@ assert.strictEqual( ); ``` -`spinalCase('Teletubbies say Eh-oh')`应该返回`'teletubbies-say-eh-oh'`。 +`spinalCase("Teletubbies say Eh-oh")` 应返回 `"teletubbies-say-eh-oh"`。 ```js assert.strictEqual( @@ -43,7 +41,7 @@ assert.strictEqual( ); ``` -`spinalCase('AllThe-small Things')`应该返回`'all-the-small-things'`。 +`spinalCase("AllThe-small Things")` 应返回 `"all-the-small-things"`。 ```js assert.strictEqual(spinalCase('AllThe-small Things'), 'all-the-small-things'); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md index 989c05bb2f..7c797625b3 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/steamroller.md @@ -1,41 +1,45 @@ --- id: ab306dbdcc907c7ddfc30830 -title: 扁平化 +title: 数组扁平化 challengeType: 5 forumTopicId: 16079 --- # --description-- -在这道题目中，我们需要写一个数组扁平化的函数。 - -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +在这道题目中，我们需要写一个数组扁平化的函数。请注意考虑多层数组嵌套的情景。 # --hints-- -`steamrollArray([[['a']], [['b']]])`应该返回`['a', 'b']`。 +`steamrollArray([[["a"]], [["b"]]])` 应返回 `["a", "b"]`。 ```js assert.deepEqual(steamrollArray([[['a']], [['b']]]), ['a', 'b']); ``` -`steamrollArray([1, [2], [3, [[4]]]])`应该返回`[1, 2, 3, 4]`。 +`steamrollArray([1, [2], [3, [[4]]]])` 应返回 `[1, 2, 3, 4]`。 ```js assert.deepEqual(steamrollArray([1, [2], [3, [[4]]]]), [1, 2, 3, 4]); ``` -`steamrollArray([1, [], [3, [[4]]]])`应该返回`[1, 3, 4]`。 +`steamrollArray([1, [], [3, [[4]]]])` 应返回 `[1, 3, 4]`。 ```js assert.deepEqual(steamrollArray([1, [], [3, [[4]]]]), [1, 3, 4]); ``` -`steamrollArray([1, {}, [3, [[4]]]])`应该返回`[1, {}, 3, 4]`。 +`steamrollArray([1, {}, [3, [[4]]]])` 应返回 `[1, {}, 3, 4]`。 ```js assert.deepEqual(steamrollArray([1, {}, [3, [[4]]]]), [1, {}, 3, 4]); ``` +代码中不应使用 `Array.prototype.flat()` 或 `Array.prototype.flatMap()` 方法。 + +```js +assert(!code.match(/\.\s*flat\s*\(/) && !code.match(/\.\s*flatMap\s*\(/)); +``` + # --solutions-- diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md index 231ea6c4e3..db887c14aa 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-numbers-in-a-range.md @@ -7,39 +7,37 @@ forumTopicId: 16083 # --description-- -给出一个含有两个数字的数组，我们需要写一个函数，让它返回这两个数字间所有数字（包含这两个数字）的总和。 +给出一个含有两个数字的数组，我们需要写一个函数，让它返回这两个数字间所有数字（包含这两个数字）的总和。注意，较小数不一定总是出现在数组的第一个元素。 -例如，`sumAll([4,1])` 应该返回 `10`，因为从 1 到 4 （包含 1、4）的所有数字的和是 `10`。 - -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +例如，`sumAll([4,1])` 应返回 `10`，因为从 1 到 4（包含 1、4）的所有数字的和是 `10`。 # --hints-- -`sumAll([1, 4])`应该返回一个数字。 +`sumAll([1, 4])` 应返回一个数字。 ```js assert(typeof sumAll([1, 4]) === 'number'); ``` -`sumAll([1, 4])`应该返回 10。 +`sumAll([1, 4])` 应返回 10。 ```js assert.deepEqual(sumAll([1, 4]), 10); ``` -`sumAll([4, 1])`应该返回 10。 +`sumAll([4, 1])` 应返回 10。 ```js assert.deepEqual(sumAll([4, 1]), 10); ``` -`sumAll([5, 10])`应该返回 45。 +`sumAll([5, 10])` 应返回 45。 ```js assert.deepEqual(sumAll([5, 10]), 45); ``` -`sumAll([10, 5])`应该返回 45。 +`sumAll([10, 5])` 应返回 45。 ```js assert.deepEqual(sumAll([10, 5]), 45); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md index 412a4d634d..e42191164a 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-odd-fibonacci-numbers.md @@ -1,53 +1,51 @@ --- id: a5229172f011153519423690 -title: 求斐波那契数组中的奇数之和 +title: 求斐波那契数列中的奇数之和 challengeType: 5 forumTopicId: 16084 --- # --description-- -在这道题目中，我们需要写一个函数，参数为一个正整数`num`。它的作用是计算斐波那契数列中，小于或等于`num`的奇数之和。 +在这道题目中，我们需要写一个函数，参数为一个正整数 `num`，返回值为斐波那契数列中，小于或等于 `num` 的奇数之和。 斐波那契数列中，第一和第二个数字都是 1，后面的每个数字由之前两数相加得出。斐波那契数列的前六个数字分别为：1、1、2、3、5、8。 -比如，`sumFibs(10)`应该返回`10`。因为斐波那契数列中，比`10`小的数字只有 1、1、3、5。 - -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +比如，`sumFibs(10)` 应该返回 `10`。因为斐波那契数列中，比 `10` 小的数字只有 1、1、3、5。 # --hints-- -`sumFibs(1)`应该返回一个数字。 +`sumFibs(1)` 应返回一个数字。 ```js assert(typeof sumFibs(1) === 'number'); ``` -`sumFibs(1000)`应该返回 1785。 +`sumFibs(1000)` 应返回 1785。 ```js assert(sumFibs(1000) === 1785); ``` -`sumFibs(4000000)`应该返回 4613732。 +`sumFibs(4000000)` 应返回 4613732。 ```js assert(sumFibs(4000000) === 4613732); ``` -`sumFibs(4)`应该返回 5。 +`sumFibs(4)` 应返回 5。 ```js assert(sumFibs(4) === 5); ``` -`sumFibs(75024)`应该返回 60696。 +`sumFibs(75024)` 应返回 60696。 ```js assert(sumFibs(75024) === 60696); ``` -`sumFibs(75025)`应该返回 135721。 +`sumFibs(75025)` 应返回 135721。 ```js assert(sumFibs(75025) === 135721); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md index 30cb1cb48f..df6a2fa4ae 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/sum-all-primes.md @@ -1,33 +1,31 @@ --- id: a3bfc1673c0526e06d3ac698 -title: 对所有素数求和 +title: 质数求和 challengeType: 5 forumTopicId: 16085 --- # --description-- -质数是大于 1 且仅可以被 1 和自己整除的数。 比如，2 就是一个质数，因为它只可以被 1 和 2（它本身）整除。 相反，4 不是质数，因为它可以被 1, 2 和 4 整除。 +质数是大于 1 且仅可以被 1 和自己整除的数。比如，2 就是一个质数，因为它只可以被 1 和 2（它本身）整除。相反，4 不是质数，因为它可以被 1, 2 和 4 整除。 -重写 `sumPrimes` 使其返回所有小于或等于该数字的质数 的和。 - -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +请完成 `sumPrimes` 方法，使其返回小于等于传入参数数字的所有质数之和。 # --hints-- -`sumPrimes(10)`应该返回一个数字。 +`sumPrimes(10)` 应返回一个数字。 ```js assert.deepEqual(typeof sumPrimes(10), 'number'); ``` -`sumPrimes(10)`应该返回 17。 +`sumPrimes(10)` 应返回 17。 ```js assert.deepEqual(sumPrimes(10), 17); ``` -`sumPrimes(977)`应该返回 73156。 +`sumPrimes(977)` 应返回 73156。 ```js assert.deepEqual(sumPrimes(977), 73156); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md index 7527144e56..797a8d226e 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/intermediate-algorithm-scripting/wherefore-art-thou.md @@ -1,21 +1,19 @@ --- id: a8e512fbe388ac2f9198f0fa -title: 罗密欧与朱丽叶 +title: 找出包含特定键值对的对象 challengeType: 5 forumTopicId: 16092 --- # --description-- -在这道题目中，我们要写一个函数，它接收两个参数：第一个参数是对象数组，第二个参数是一个对象。我们需要从对象数组中找出与第二个参数相等或包含第二个参数的所有对象，并以对象数组的形式返回。其中，相等的意思是原数组中的对象与第二个参数中对象的所有键值对完全相等；包含的意思是只要第二个参数中对象的所有键存在于原数组对象中，且它们对应的值相同即可。 +在这道题目中，我们要写一个函数，它接收两个参数：第一个参数是对象数组，第二个参数是一个对象。我们需要从对象数组中找出与第二个参数的属性和属性值均相等或包含第二个参数的所有对象，并以对象数组的形式返回。其中，相等的意思是原数组中的对象与第二个参数中对象的所有键值对完全相等；包含的意思是只要第二个参数中对象的所有键存在于原数组对象中，且它们对应的值相同即可。 -比如，如果第一个参数是`[{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]`，第二个参数是`{ last: "Capulet" }`。那么你需要以对象数组的形式返回第一个参数中的第三个元素，因为它包含第二个参数中定义的键`last`，且对应的值`"Capulet"`相同 - -如果你遇到了问题，请点击[帮助](https://forum.freecodecamp.one/t/topic/157)。 +比如，如果第一个参数是 `[{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }]`，第二个参数是 `{ last: "Capulet" }`。那么你需要以对象数组的形式返回第一个参数中的第三个元素，因为它包含第二个参数中定义的键 `last`，且对应的值 `"Capulet"` 相同 # --hints-- -`whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" })`应该返回`[{ first: "Tybalt", last: "Capulet" }]`。 +`whatIsInAName([{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], { last: "Capulet" })` 应返回 `[{ first: "Tybalt", last: "Capulet" }]`。 ```js assert.deepEqual( @@ -31,7 +29,7 @@ assert.deepEqual( ); ``` -`whatIsInAName([{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }], { "apple": 1 })`应该返回`[{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }]`。 +`whatIsInAName([{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }], { "apple": 1 })` 应返回 `[{ "apple": 1 }, { "apple": 1 }, { "apple": 1, "bat": 2 }]`。 ```js assert.deepEqual( @@ -42,7 +40,7 @@ assert.deepEqual( ); ``` -`whatIsInAName([{ "apple": 1, "bat": 2 }, { "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "bat": 2 })`应该返回`[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }]`。 +`whatIsInAName([{ "apple": 1, "bat": 2 }, { "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "bat": 2 })` 应返回 `[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie": 2 }]`。 ```js assert.deepEqual( @@ -57,7 +55,7 @@ assert.deepEqual( ); ``` -`whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "cookie": 2 })`应该返回`[{ "apple": 1, "bat": 2, "cookie": 2 }]`。 +`whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }], { "apple": 1, "cookie": 2 })` 应返回 `[{ "apple": 1, "bat": 2, "cookie": 2 }]`。 ```js assert.deepEqual( @@ -69,7 +67,7 @@ assert.deepEqual( ); ``` -`whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }, { "bat":2 }], { "apple": 1, "bat": 2 })`应该返回`[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie":2 }]`。 +`whatIsInAName([{ "apple": 1, "bat": 2 }, { "apple": 1 }, { "apple": 1, "bat": 2, "cookie": 2 }, { "bat":2 }], { "apple": 1, "bat": 2 })` 应返回 `[{ "apple": 1, "bat": 2 }, { "apple": 1, "bat": 2, "cookie":2 }]`。 ```js assert.deepEqual( @@ -89,7 +87,7 @@ assert.deepEqual( ); ``` -`whatIsInAName([{"a": 1, "b": 2, "c": 3}], {"a": 1, "b": 9999, "c": 3})`应该返回`[]`。 +`whatIsInAName([{"a": 1, "b": 2, "c": 3}], {"a": 1, "b": 9999, "c": 3})` 应返回 `[]`。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md index 9a88504c60..42becdcd97 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/caesars-cipher.md @@ -7,9 +7,9 @@ forumTopicId: 16003 # --description-- -`凯撒密码`是最简单和最广为人知的密码之一，也被称为`移位密码`。在`移位密码`中，明文中的字母通过按照一个固定数目进行偏移后被替换成新的字母。 +凯撒密码是最简单且最广为人知的密码，也被称为移位密码。在移位密码中，明文中的字母通过按照一个固定数目进行偏移后被替换成新的字母。 -[ROT13](https://en.wikipedia.org/wiki/ROT13) 是一个被广泛使用的编码技术，明文中的所有字母都被移动 13 位。因此，'A' ↔ 'N', 'B' ↔ 'O' 等等。 +[ROT13](https://en.wikipedia.org/wiki/ROT13) 是一个被广泛使用的加密技术，明文中的所有字母都被移动 13 位。因此有：'A' ↔ 'N'、'B' ↔ 'O' 等等。 请编写一个函数，用于解码一个被 [ROT13](https://en.wikipedia.org/wiki/ROT13) 编码的字符串，然后返回解码后的结果。 @@ -17,25 +17,25 @@ forumTopicId: 16003 # --hints-- -`rot13('SERR PBQR PNZC')`应解码为`FREE CODE CAMP`。 +`rot13("SERR PBQR PNZC")` 应解码为 `FREE CODE CAMP`。 ```js assert(rot13('SERR PBQR PNZC') === 'FREE CODE CAMP'); ``` -`rot13('SERR CVMMN!')`应解码为`FREE PIZZA!`。 +`rot13("SERR CVMMN!")` 应解码为 `FREE PIZZA!`。 ```js assert(rot13('SERR CVMMN!') === 'FREE PIZZA!'); ``` -`rot13('SERR YBIR?')`应解码为`FREE LOVE?`。 +`rot13("SERR YBIR?")` 应解码为 `FREE LOVE?`。 ```js assert(rot13('SERR YBIR?') === 'FREE LOVE?'); ``` -`rot13('GUR DHVPX OEBJA SBK WHZCF BIRE GUR YNML QBT.')`应解码为`THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.`。 +`rot13("GUR DHVPX OEBJA SBK WHZCF BIRE GUR YNML QBT.")` 应解码为 `THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.`。 ```js assert( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md index 540283344d..a76c4f2d08 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/cash-register.md @@ -1,29 +1,45 @@ --- id: aa2e6f85cab2ab736c9a9b24 -title: 收银机 +title: 计算找零 challengeType: 5 forumTopicId: 16012 --- # --description-- -编写一个用于收银机的函数`checkCashRegister()`，传入售价为第一个参数（`price`）、支付金额为第二个参数（`cash`）、收银机內的金额为第三个参数（`cid`）。 +请编写一个用于收银机的函数 `checkCashRegister()`：它的第一个参数为售价 `price`、第二个参数为支付金额 `cash`、第三个参数为收银机內的金额 `cid`。 -`cid`是包含货币面值的二维数组。 +`cid` 是包含货币面值的二维数组。 -函数`checkCashRegister()`必须返回含有`status`键值和`change`键值的对象。 +函数 `checkCashRegister()` 应返回含有 `status` 属性和 `change` 属性的对象。 -如果收银机內的金额少于应找回的零钱数，或者你无法返回确切的数目时，返回`{status: "INSUFFICIENT_FUNDS", change: []}`。 +如果收银机內的金额少于应找回的零钱数，或者你无法返回确切的数目时，返回 `{status: "INSUFFICIENT_FUNDS", change: []}`。 -如果收银机內的金额等于应找回的零钱数，返回`{status: "CLOSED", change: [...]}`，其中`change`键值是收银机內的金额。 +如果收银机內的金额恰好等于应找回的零钱数，返回 `{status: "CLOSED", change: [...]}`，其中 `change` 的属性值就是收银机內的金额。 -否则，返回`{status: "OPEN", change: [...]}`，其中`change`键值是应找回的零钱数，并且它的面值由高到低排序。 +否则，返回 `{status: "OPEN", change: [...]}`，其中 `change` 键值是应找回的零钱数，并将找零的面值由高到低排序。 -
货币单位面值
Penny$0.01 (PENNY)
Nickel$0.05 (NICKEL)
Dime$0.1 (DIME)
Quarter$0.25 (QUARTER)
Dollar$1 (DOLLAR)
Five Dollars$5 (FIVE)
Ten Dollars$10 (TEN)
Twenty Dollars$20 (TWENTY)
One-hundred Dollars$100 (ONE HUNDRED)
+
货币单位 Unit面值
Penny$0.01 (PENNY)
Nickel$0.05 (NICKEL)
Dime$0.1 (DIME)
Quarter$0.25 (QUARTER)
Dollar$1 (ONE)
Five Dollars$5 (FIVE)
Ten Dollars$10 (TEN)
Twenty Dollars$20 (TWENTY)
One-hundred Dollars$100 (ONE HUNDRED)
+ +以下为 `cid` 参数的示例： + +```js +[ + ["PENNY", 1.01], + ["NICKEL", 2.05], + ["DIME", 3.1], + ["QUARTER", 4.25], + ["ONE", 90], + ["FIVE", 55], + ["TEN", 20], + ["TWENTY", 60], + ["ONE HUNDRED", 100] +] +``` # --hints-- -`checkCashRegister(19.5, 20, [['PENNY', 1.01], ['NICKEL', 2.05], ['DIME', 3.1], ['QUARTER', 4.25], ['ONE', 90], ['FIVE', 55], ['TEN', 20], ['TWENTY', 60], ['ONE HUNDRED', 100]])`应该返回一个对象。 +`checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])` 应返回一个对象。 ```js assert.deepEqual( @@ -44,7 +60,7 @@ assert.deepEqual( ); ``` -`checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])`应该返回`{status: "OPEN", change: [["QUARTER", 0.5]]}`。 +`checkCashRegister(19.5, 20, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])` 应返回 `{status: "OPEN", change: [["QUARTER", 0.5]]}`。 ```js assert.deepEqual( @@ -63,7 +79,7 @@ assert.deepEqual( ); ``` -`checkCashRegister(3.26, 100, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])`应该返回`{status: "OPEN", change: [["TWENTY", 60], ["TEN", 20], ["FIVE", 15], ["ONE", 1], ["QUARTER", 0.5], ["DIME", 0.2], ["PENNY", 0.04]]}`。 +`checkCashRegister(3.26, 100, [["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]])` 应返回 `{status: "OPEN", change: [["TWENTY", 60], ["TEN", 20], ["FIVE", 15], ["ONE", 1], ["QUARTER", 0.5], ["DIME", 0.2], ["PENNY", 0.04]]}`。 ```js assert.deepEqual( @@ -93,7 +109,7 @@ assert.deepEqual( ); ``` -`checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])`应该返回`{status: "INSUFFICIENT_FUNDS", change: []}`。 +`checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])` 应返回 `{status: "INSUFFICIENT_FUNDS", change: []}`。 ```js assert.deepEqual( @@ -112,7 +128,7 @@ assert.deepEqual( ); ``` -`checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 1], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])`应该返回`{status: "INSUFFICIENT_FUNDS", change: []}`。 +`checkCashRegister(19.5, 20, [["PENNY", 0.01], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 1], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])` 应返回 `{status: "INSUFFICIENT_FUNDS", change: []}`。 ```js assert.deepEqual( @@ -131,7 +147,7 @@ assert.deepEqual( ); ``` -`checkCashRegister(19.5, 20, [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])`应该返回`{status: "CLOSED", change: [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]}`。 +`checkCashRegister(19.5, 20, [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]])` 应返回 `{status: "CLOSED", change: [["PENNY", 0.5], ["NICKEL", 0], ["DIME", 0], ["QUARTER", 0], ["ONE", 0], ["FIVE", 0], ["TEN", 0], ["TWENTY", 0], ["ONE HUNDRED", 0]]}`。 ```js assert.deepEqual( diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md index 4bdba4855b..b72f386111 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/palindrome-checker.md @@ -7,92 +7,91 @@ forumTopicId: 16004 # --description-- -如果给定的一个字符串是回文，那么返回`true`，否则返回`false`。 +如果传入的字符串是回文字符串，则返回 `true`，否则返回 `false`。 -palindrome（回文），指在忽略标点符号、大小写和空格的前提下，正着读和反着读一模一样。 +Palindrome（回文），指在忽略标点符号、大小写和空格的前提下，正着读和反着读一模一样。 -**注意：** -检查回文时，你需要先除去**所有非字母数字的字符**（标点、空格和符号）并且将所有字符转换成字母大写或字母小写。 +**注意：**检查回文时，你需要先去除**所有非字母数字的字符**（标点、空格和符号），并将所有字母都转换成大写或都转换成小写。 -我们将会传入不同格式的字符串，例如：`"racecar"`、`"RaceCar"`、`"race CAR"`等等。 +我们会传入不同格式的字符串，例如：`"racecar"`、`"RaceCar"`、`"race CAR"` 等等。 -我们也会传入一些包含特殊符号的字符串，例如`"2A3*3a2"`，`"2A3 3a2"`和`"2_A3*3#A2"`。 +我们也会传入一些包含特殊符号的字符串，例如 `"2A3*3a2"`、`"2A3 3a2"`、`"2_A3*3#A2"`。 # --hints-- -`palindrome('eye')`应该返回一个布尔值。 +`palindrome("eye")` 应返回一个布尔值。 ```js assert(typeof palindrome('eye') === 'boolean'); ``` -`palindrome('eye')`应该返回 true。 +`palindrome("eye")` 应返回 true。 ```js assert(palindrome('eye') === true); ``` -`palindrome('_eye')`应该返回 true。 +`palindrome("_eye")` 应返回 true。 ```js assert(palindrome('_eye') === true); ``` -`palindrome('race car')`应该返回 true。 +`palindrome("race car")` 应返回 true。 ```js assert(palindrome('race car') === true); ``` -`palindrome('not a palindrome')`应该返回 false。 +`palindrome("not a palindrome")` 应返回 false。 ```js assert(palindrome('not a palindrome') === false); ``` -`palindrome('A man, a plan, a canal. Panama')`应该返回 true。 +`palindrome("A man, a plan, a canal. Panama")` 应返回 true。 ```js assert(palindrome('A man, a plan, a canal. Panama') === true); ``` -`palindrome('never odd or even')`应该返回 true。 +`palindrome("never odd or even")` 应返回 true。 ```js assert(palindrome('never odd or even') === true); ``` -`palindrome('nope')`应该返回 false。 +`palindrome("nope")` 应返回 false。 ```js assert(palindrome('nope') === false); ``` -`palindrome('almostomla')`应该返回 false。 +`palindrome("almostomla")` 应返回 false。 ```js assert(palindrome('almostomla') === false); ``` -`palindrome('My age is 0, 0 si ega ym.')`应该返回 true。 +`palindrome("My age is 0, 0 si ega ym.")` 应返回 true。 ```js assert(palindrome('My age is 0, 0 si ega ym.') === true); ``` -`palindrome('1 eye for of 1 eye.')`应该返回 false。 +`palindrome("1 eye for of 1 eye.")` 应返回 false。 ```js assert(palindrome('1 eye for of 1 eye.') === false); ``` -`palindrome("0_0 (: /-\ :) 0-0")`应该返回 true。 +`palindrome("0_0 (: /-\ :) 0-0")` 应返回 true。 ```js assert(palindrome('0_0 (: /- :) 0-0') === true); ``` -`palindrome('five| /|four')`应该返回 false。 +`palindrome("five|\_/|four")` 应返回 false。 ```js assert(palindrome('five|_/|four') === false); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md index 0c5d2213da..6aed537eea 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/roman-numeral-converter.md @@ -7,163 +7,163 @@ forumTopicId: 16044 # --description-- -把传入的数字转变为罗马数字。 +把传入的数字转为罗马数字。 转换后的[罗马数字](http://www.mathsisfun.com/roman-numerals.html)字母必须都是大写。 # --hints-- -`convertToRoman(2)`应该返回 'II'。 +`convertToRoman(2)` 应返回 "II"。 ```js assert.deepEqual(convertToRoman(2), 'II'); ``` -`convertToRoman(3)`应该返回 'III'。 +`convertToRoman(3)` 应返回 "III"。 ```js assert.deepEqual(convertToRoman(3), 'III'); ``` -`convertToRoman(4)`应该返回 'IV'。 +`convertToRoman(4)` 应返回 "IV"。 ```js assert.deepEqual(convertToRoman(4), 'IV'); ``` -`convertToRoman(5)`应该返回 'V'。 +`convertToRoman(5)` 应返回 "V"。 ```js assert.deepEqual(convertToRoman(5), 'V'); ``` -`convertToRoman(9)`应该返回 'IX'。 +`convertToRoman(9)` 应返回 "IX"。 ```js assert.deepEqual(convertToRoman(9), 'IX'); ``` -`convertToRoman(12)`应该返回 'XII'。 +`convertToRoman(12)` 应返回 "XII"。 ```js assert.deepEqual(convertToRoman(12), 'XII'); ``` -`convertToRoman(16)`应该返回 'XVI'。 +`convertToRoman(16)` 应返回 "XVI"。 ```js assert.deepEqual(convertToRoman(16), 'XVI'); ``` -`convertToRoman(29)`应该返回 'XXIX'。 +`convertToRoman(29)` 应返回 "XXIX"。 ```js assert.deepEqual(convertToRoman(29), 'XXIX'); ``` -`convertToRoman(44)`应该返回 'XLIV'。 +`convertToRoman(44)` 应返回 "XLIV"。 ```js assert.deepEqual(convertToRoman(44), 'XLIV'); ``` -`convertToRoman(45)`应该返回 'XLV'。 +`convertToRoman(45)` 应返回 "XLV"。 ```js assert.deepEqual(convertToRoman(45), 'XLV'); ``` -`convertToRoman(68)`应该返回 'LXVIII'。 +`convertToRoman(68)` 应返回 "LXVIII"。 ```js assert.deepEqual(convertToRoman(68), 'LXVIII'); ``` -`convertToRoman(83)`应该返回 'LXXXIII'。 +`convertToRoman(83)` 应返回 "LXXXIII"。 ```js assert.deepEqual(convertToRoman(83), 'LXXXIII'); ``` -`convertToRoman(97)`应该返回 'XCVII'。 +`convertToRoman(97)` 应返回 "XCVII"。 ```js assert.deepEqual(convertToRoman(97), 'XCVII'); ``` -`convertToRoman(99)`应该返回 'XCIX'。 +`convertToRoman(99)` 应返回 "XCIX"。 ```js assert.deepEqual(convertToRoman(99), 'XCIX'); ``` -`convertToRoman(400)`应该返回 'CD'。 +`convertToRoman(400)` 应返回 "CD"。 ```js assert.deepEqual(convertToRoman(400), 'CD'); ``` -`convertToRoman(500)`应该返回 'D'。 +`convertToRoman(500)` 应返回 "D"。 ```js assert.deepEqual(convertToRoman(500), 'D'); ``` -`convertToRoman(501)`应该返回 'DI'。 +`convertToRoman(501)` 应返回 "DI"。 ```js assert.deepEqual(convertToRoman(501), 'DI'); ``` -`convertToRoman(649)`应该返回 'DCXLIX'。 +`convertToRoman(649)` 应返回 "DCXLIX"。 ```js assert.deepEqual(convertToRoman(649), 'DCXLIX'); ``` -`convertToRoman(798)`应该返回 'DCCXCVIII'。 +`convertToRoman(798)` 应返回 "DCCXCVIII"。 ```js assert.deepEqual(convertToRoman(798), 'DCCXCVIII'); ``` -`convertToRoman(891)`应该返回 'DCCCXCI'。 +`convertToRoman(891)` 应返回 "DCCCXCI"。 ```js assert.deepEqual(convertToRoman(891), 'DCCCXCI'); ``` -`convertToRoman(1000)`应该返回 'M'。 +`convertToRoman(1000)` 应返回 "M"。 ```js assert.deepEqual(convertToRoman(1000), 'M'); ``` -`convertToRoman(1004)`应该返回 'MIV'。 +`convertToRoman(1004)` 应返回 "MIV"。 ```js assert.deepEqual(convertToRoman(1004), 'MIV'); ``` -`convertToRoman(1006)`应该返回 'MVI'。 +`convertToRoman(1006)` 应返回 "MVI"。 ```js assert.deepEqual(convertToRoman(1006), 'MVI'); ``` -`convertToRoman(1023)`应该返回 'MXXIII'。 +`convertToRoman(1023)` 应返回 "MXXIII"。 ```js assert.deepEqual(convertToRoman(1023), 'MXXIII'); ``` -`convertToRoman(2014)`应该返回 'MMXIV'。 +`convertToRoman(2014)` 应返回 "MMXIV"。 ```js assert.deepEqual(convertToRoman(2014), 'MMXIV'); ``` -`convertToRoman(3999)`应该返回 'MMMCMXCIX'。 +`convertToRoman(3999)` 应返回 "MMMCMXCIX"。 ```js assert.deepEqual(convertToRoman(3999), 'MMMCMXCIX'); diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md index 2edc989a79..d79899dc24 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/javascript-algorithms-and-data-structures-projects/telephone-number-validator.md @@ -1,6 +1,6 @@ --- id: aff0395860f5d3034dc0bfc9 -title: 电话号码验证器 +title: 电话号码检查器 challengeType: 5 forumTopicId: 16090 --- @@ -13,167 +13,167 @@ forumTopicId: 16090
555-555-5555
(555)555-5555
(555) 555-5555
555 555 5555
5555555555
1 555 555 5555
-在这个挑战中，你将会看到例如`800-692-7753`或者`8oo-six427676;laskdjf`的号码。你的任务是根据上面不同的格式组合，判断它是否美国号码。区号是必须的。如果提供国家代码，则必须确认国家代码为`1`。如果这是有效的美国电话就返回`true`，否则返回`false`。 +在这个挑战中，参数可能是 `800-692-7753` 或者 `8oo-six427676;laskdjf` 的号码。你的任务是根据上面不同的格式组合，判断它是否为有效的电话号码。其中，地区码（电话号码中的前三位）是必须的。如果提供国家代码，则国家代码只能为 `1`。如果传入的参数是有效的美国电话号码就返回 `true`，否则返回 `false`。 # --hints-- -`telephoneCheck('555-555-5555')`应该返回布尔值。 +`telephoneCheck("555-555-5555")` 应返回一个布尔值。 ```js assert(typeof telephoneCheck('555-555-5555') === 'boolean'); ``` -`telephoneCheck('1 555-555-5555')`应该返回 true。 +`telephoneCheck("1 555-555-5555")` 应返回 true。 ```js assert(telephoneCheck('1 555-555-5555') === true); ``` -`telephoneCheck('1 (555) 555-5555')`应该返回 true。 +`telephoneCheck("1 (555) 555-5555")` 应返回 true。 ```js assert(telephoneCheck('1 (555) 555-5555') === true); ``` -`telephoneCheck('5555555555')`应该返回 true。 +`telephoneCheck("5555555555")` 应返回 true。 ```js assert(telephoneCheck('5555555555') === true); ``` -`telephoneCheck('555-555-5555')`应该返回 true。 +`telephoneCheck("555-555-5555")` 应返回 true。 ```js assert(telephoneCheck('555-555-5555') === true); ``` -`telephoneCheck('(555)555-5555')`应该返回 true。 +`telephoneCheck("(555)555-5555")` 应返回 true。 ```js assert(telephoneCheck('(555)555-5555') === true); ``` -`telephoneCheck('1(555)555-5555')`应该返回 true。 +`telephoneCheck("1(555)555-5555")` 应返回 true。 ```js assert(telephoneCheck('1(555)555-5555') === true); ``` -`telephoneCheck('555-5555')`应该返回 false。 +`telephoneCheck("555-5555")` 应返回 false。 ```js assert(telephoneCheck('555-5555') === false); ``` -`telephoneCheck('5555555')`应该返回 false。 +`telephoneCheck("5555555")` 应返回 false。 ```js assert(telephoneCheck('5555555') === false); ``` -`telephoneCheck('1 555)555-5555')`应该返回 false。 +`telephoneCheck("1 555)555-5555")` 应返回 false。 ```js assert(telephoneCheck('1 555)555-5555') === false); ``` -`telephoneCheck('1 555 555 5555')`应该返回 true。 +`telephoneCheck("1 555 555 5555")` 应返回 true。 ```js assert(telephoneCheck('1 555 555 5555') === true); ``` -`telephoneCheck('1 456 789 4444')`应该返回 true。 +`telephoneCheck("1 456 789 4444")` 应返回 true。 ```js assert(telephoneCheck('1 456 789 4444') === true); ``` -`telephoneCheck('123**&!!asdf#')`应该返回 false。 +`telephoneCheck("123**&!!asdf#")` 应返回 false。 ```js assert(telephoneCheck('123**&!!asdf#') === false); ``` -`telephoneCheck('55555555')`应该返回 false。 +`telephoneCheck("55555555")` 应返回 false。 ```js assert(telephoneCheck('55555555') === false); ``` -`telephoneCheck('(6054756961)')`应该返回 false。 +`telephoneCheck("(6054756961)")` 应返回 false。 ```js assert(telephoneCheck('(6054756961)') === false); ``` -`telephoneCheck('2 (757) 622-7382')`应该返回 false。 +`telephoneCheck("2 (757) 622-7382")` 应返回 false。 ```js assert(telephoneCheck('2 (757) 622-7382') === false); ``` -`telephoneCheck('0 (757) 622-7382')`应该返回 false。 +`telephoneCheck("0 (757) 622-7382")` 应返回 false。 ```js assert(telephoneCheck('0 (757) 622-7382') === false); ``` -`telephoneCheck('-1 (757) 622-7382')`应该返回 false。 +`telephoneCheck("-1 (757) 622-7382")` 应返回 false。 ```js assert(telephoneCheck('-1 (757) 622-7382') === false); ``` -`telephoneCheck('2 757 622-7382')`应该返回 false。 +`telephoneCheck("2 757 622-7382")` 应返回 false。 ```js assert(telephoneCheck('2 757 622-7382') === false); ``` -`telephoneCheck('10 (757) 622-7382')`应该返回 false。 +`telephoneCheck("10 (757) 622-7382")` 应返回 false。 ```js assert(telephoneCheck('10 (757) 622-7382') === false); ``` -`telephoneCheck('27576227382')`应该返回 false。 +`telephoneCheck("27576227382")` 应返回 false。 ```js assert(telephoneCheck('27576227382') === false); ``` -`telephoneCheck('(275)76227382')`应该返回 false。 +`telephoneCheck("(275)76227382")` 应返回 false。 ```js assert(telephoneCheck('(275)76227382') === false); ``` -`telephoneCheck('2(757)6227382')`应该返回 false。 +`telephoneCheck("2(757)6227382")` 应返回 false。 ```js assert(telephoneCheck('2(757)6227382') === false); ``` -`telephoneCheck('2(757)622-7382')`应该返回 false。 +`telephoneCheck("2(757)622-7382")` 应返回 false。 ```js assert(telephoneCheck('2(757)622-7382') === false); ``` -`telephoneCheck('555)-555-5555')`应该返回 false。 +`telephoneCheck("555)-555-5555")` 应返回 false。 ```js assert(telephoneCheck('555)-555-5555') === false); ``` -`telephoneCheck('(555-555-5555')`应该返回 false。 +`telephoneCheck("(555-555-5555")` 应返回 false。 ```js assert(telephoneCheck('(555-555-5555') === false); ``` -`telephoneCheck('(555)5(55?)-5555')`应该返回 false。 +`telephoneCheck("(555)5(55?)-5555")` 应返回 false。 ```js assert(telephoneCheck('(555)5(55?)-5555') === false);