From 14bfa61ceab5809018cc8ed6505e73916b082ac9 Mon Sep 17 00:00:00 2001 From: ZhichengChen Date: Tue, 4 Aug 2020 15:14:21 +0800 Subject: [PATCH] fix(i18n): update Chinese translation of basic data structures (#38054) Co-authored-by: Zhicheng Chen --- ...contents-using-bracket-notation.chinese.md | 39 ++++- ...rty-names-with-bracket-notation.chinese.md | 33 ++++- ...-an-array-with-push-and-unshift.chinese.md | 35 ++++- .../add-items-using-splice.chinese.md | 32 +++- ...lue-pairs-to-javascript-objects.chinese.md | 61 ++++++-- ...ence-of-an-element-with-indexof.chinese.md | 30 +++- ...eck-if-an-object-has-a-property.chinese.md | 72 +++++++-- ...arrays-with-the-spread-operator.chinese.md | 32 +++- ...-array-with-the-spread-operator.chinese.md | 48 ++++-- .../copy-array-items-using-slice.chinese.md | 28 +++- ...omplex-multi-dimensional-arrays.chinese.md | 70 +++++++-- ...ll-object-keys-with-object.keys.chinese.md | 43 +++++- ...an-arrays-items-using-for-loops.chinese.md | 44 +++++- ...bject-with-a-for...in-statement.chinese.md | 138 +++++++++++++----- ...fy-an-array-stored-in-an-object.chinese.md | 43 +++++- ...-object-nested-within-an-object.chinese.md | 48 ++++-- ...rom-an-array-with-pop-and-shift.chinese.md | 40 ++++- .../remove-items-using-splice.chinese.md | 63 +++++--- ...y-to-store-a-collection-of-data.chinese.md | 59 ++++++-- ...ord-to-remove-object-properties.chinese.md | 39 ++++- 20 files changed, 807 insertions(+), 190 deletions(-) diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.chinese.md index 5ca7237575..696a403049 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-an-arrays-contents-using-bracket-notation.chinese.md @@ -2,15 +2,42 @@ id: 5a661e0f1068aca922b3ef17 title: Access an Array's Contents Using Bracket Notation challengeType: 1 -videoUrl: '' -localeTitle: 使用括号表示法访问数组的内容 +forumTopicId: 301149 +localeTitle: 使用方括号访问数组的内容 --- ## Description -
当然，任何数据结构的基本特征是不仅能够存储数据，而且能够根据命令检索该数据。所以，既然我们已经学会了如何创建数组，那么让我们开始考虑如何访问该数组的信息。当我们定义一个如下所示的简单数组时，其中有3个项目：
让ourArray = [“a”，“b”，“c”];
在数组中，每个数组项都有一个索引 。此索引兼作数组中该项的位置，以及您如何引用它。但是，值得注意的是，JavaScript数组是零索引的 ，这意味着数组的第一个元素实际上处于第零位，而不是第一个。为了从数组中检索元素，我们可以将一个索引括在括号中，并将其附加到数组的末尾，或者更常见的是附加到引用数组对象的变量。这称为括号表示法 。例如，如果我们想从ourArray检索"a"并将其分配给变量，我们可以使用以下代码执行此操作：
让ourVariable = ourArray [0];
// ourVariable等于“a”
除了访问与索引相关的值，你还可以设置索引使用相同的符号中的值：
ourArray [1] =“不再是b”;
// ourArray现在等于[“a”，“不再b”，“c”];
使用括号表示法，我们现在将索引1处的项目从"b"重置为"not b anymore" 。
+
+所有数据结构的基本特性是，它们不仅能够存储数据，我们还能够按照需求来访问存放在其中的数据。我们已经学习了如何创建一个数组结构，现在让我们开始学习如何访问这个数组结构中的数据。 +我们先定义一个包含 3 个元素的数组： + +```js +let ourArray = ["a", "b", "c"]; +``` + +在一个数组结构中，其内部的每个元素都有一个与之对应的索引（index）。索引是该元素在数组中的位置，可被用于引用该元素。但需要注意的是，JavaScript 数组的索引是从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"。 +
## Instructions -
为了完成此挑战，将myArray的第二个位置（索引1 ）设置为您想要的任何内容，除了"b" 。
+
+在本挑战中，请你将myArray中第二个元素（索引1）设置为除了"b"以外的任意值。 +
## Tests
@@ -41,7 +68,6 @@ let myArray = ["a", "b", "c", "d"]; //change code above this line console.log(myArray); - ``` @@ -55,5 +81,8 @@ console.log(myArray); ```js // solution required +let myArray = ["a", "b", "c", "d"]; +myArray[1] = "e"; ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.chinese.md index 4023801c79..6c49e442f5 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/access-property-names-with-bracket-notation.chinese.md @@ -2,15 +2,26 @@ id: 587d7b7c367417b2b2512b1a title: Access Property Names with Bracket Notation challengeType: 1 -videoUrl: '' -localeTitle: 使用括号表示法访问属性名称 +forumTopicId: 301150 +localeTitle: 使用方括号访问属性名称 --- ## Description -
在第一个对象挑战中，我们提到使用括号表示法作为使用变量求值来访问属性值的方法。例如，假设我们的foods对象被用于超市收银机的程序中。我们有一些设置selectedFood功能，我们想检查我们的foods对象是否存在该食物。这可能看起来像：
let selectedFood = getCurrentFood（scanningItem）;
让库存=食物[selectedFood];
此代码将评估存储在selectedFood变量中的值，并在foods对象中返回该键的值，如果不存在则返回undefined 。括号表示法非常有用，因为有时候对象属性在运行时之前是未知的，或者我们需要以更动态的方式访问它们。
+
+在关于对象的第一个挑战中，我们提到可以在方括号符号中用一个变量作为属性名来访问属性值。假设一个超市的收银台的程序中使用了一个foods对象，并且有一些程序逻辑会设置selectedFood，我们需要查询foods对象来检查某种食物是否存在，我们可以这样写检查逻辑： + +```js +let selectedFood = getCurrentFood(scannedItem); +let inventory = foods[selectedFood]; +``` + +上述代码会先计算selectedFood变量的值，并返回foods对象中以该值命名的属性对应的值，若没有以该值命名的属性则会返回undefined。有时候对象的属性名在运行之前是不确定的，或者我们需要动态地访问对象的属性，这时方括号符号就会很有用。 +
## Instructions -
我们定义了一个函数checkInventory ，它接收一个扫描的项目作为参数。返回foods对象中的scannedItem键的当前值。您可以假设只有有效键将作为checkInventory的参数提供。
+
+我们已经定义了一个checkInventory函数，它接受一个被扫描到的商品名作为输入参数。它要返回foods对象中以scannedItem的值命名的属性的值。只有有效的属性名会作为参数传入checkInventory，你在完成挑战时不需处理参数无效的情况。 +
## Tests
@@ -55,7 +66,6 @@ function checkInventory(scannedItem) { // change code below this line to test different cases: console.log(checkInventory("apples")); - ``` @@ -69,5 +79,18 @@ console.log(checkInventory("apples")); ```js // solution required +let foods = { + apples: 25, + oranges: 32, + plums: 28, + bananas: 13, + grapes: 35, + strawberries: 27 +}; + +function checkInventory(scannedItem) { + return foods[scannedItem]; +} ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.chinese.md index 6f488ee7f1..e9264e7838 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-to-an-array-with-push-and-unshift.chinese.md @@ -2,15 +2,32 @@ id: 587d78b2367417b2b2512b0e title: Add Items to an Array with push() and unshift() challengeType: 1 -videoUrl: '' -localeTitle: 使用push（）和unshift（）将项添加到数组 +forumTopicId: 301151 +localeTitle: 使用 push() 和 unshift() 添加项目到数组中 --- ## Description -
数组的长度与它可以包含的数据类型一样，并不固定。可以使用任意数量的元素的长度来定义数组，并且可以随时间添加或移除元素;换句话说，数组是可变的 。在这个挑战中，我们将研究两种方法，我们可以用它们以编程方式修改数组： Array.push()和Array.unshift() 。两种方法都将一个或多个元素作为参数，并将这些元素添加到调用该方法的数组中; push()方法将元素添加到数组的末尾， unshift()将元素添加到开头。考虑以下：
让二十三'='XXIII';
让romanNumerals = ['XXI'，'XXII'];

romanNumerals.unshift（'XIX'，'XX'）;
//现在等于['XIX'，'XX'，'XXI'，'XXII']

romanNumerals.push（二十三）;
//现在等于['XIX'，'XX'，'XXI'，'XXII'，'XXIII']请注意，我们也可以传递变量，这使我们可以更灵活地动态修改数组的数据。
+
+一个数组的长度与其包含的数据类型一样，是不固定的。数组可以包含任意数量的元素，可以不限次数地往数组中添加元素或者从中移除元素，或者说数组是可变的（mutable）。在本挑战中，我们要学习两个以编程方式修改数组的方法：Array.push()和Array.unshift()。 +这两个方法都接收一个或多个元素作为参数；对一个数组调用这两个方法都可以将输入的元素插入到该数组中；push()方法将元素插入到一个数组的末尾，而unshift()方法将元素插入到一个数组的开头。请看以下例子： + +```js +let twentyThree = 'XXIII'; +let romanNumerals = ['XXI', 'XXII']; + +romanNumerals.unshift('XIX', 'XX'); +// 数组现在为 ['XIX', 'XX', 'XXI', 'XXII'] + +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 的数组。 +
## Tests
@@ -43,7 +60,6 @@ function mixedNumbers(arr) { // do not change code below this line console.log(mixedNumbers(['IV', 5, 'six'])); - ``` @@ -56,6 +72,13 @@ console.log(mixedNumbers(['IV', 5, 'six']));
```js -// solution required +function mixedNumbers(arr) { + // change code below this line + arr.push(7,'VIII',9); + arr.unshift('I',2,'three'); + // change code above this line + return arr; +} ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.chinese.md index c0f7bca818..4a7065aec8 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-items-using-splice.chinese.md @@ -2,15 +2,32 @@ id: 587d78b3367417b2b2512b11 title: Add Items Using splice() challengeType: 1 -videoUrl: '' -localeTitle: 使用splice（）添加项目 +forumTopicId: 301152 +localeTitle: 使用 splice() 增加项目 --- ## Description -
还记得在上一次挑战中我们提到过splice()最多需要三个参数吗？好吧，我们可以更进一步使用splice() - 除了删除元素之外，我们还可以使用代表一个或多个元素的第三个参数来添加它们。这对于快速切换另一个元素或一组元素非常有用。例如，假设您正在为数组中的一组DOM元素存储颜色方案，并希望根据某些操作动态更改颜色：
function colorChange（arr，index，newColor）{
arr.splice（index，1，newColor）;
返回
}

让colorScheme = ['＃878787'，'＃a08794'，'＃bb7e8c'，'＃c9b6be'，'＃d1becf'];

colorScheme = colorChange（colorScheme，2，'＃332327'）;
//我们删除了'＃bb7e8c'并在其位置添加了'＃332327'
// colorScheme现在等于['＃878787'，'＃a08794'，'＃332327'，'＃c9b6be'，'＃d1becf']
此函数采用十六进制值数组，删除元素的索引以及用于替换已删除元素的新颜色。返回值是一个包含新修改的颜色方案的数组！虽然这个例子有点过于简单，但我们可以看到利用splice()到其最大潜力的值。
+
+你还记得在上个挑战中我们提到splice()方法可以接受最多 3 个参数吗？我们现在可以进一步了解splice()。除了移除元素，我们还可以利用它的第三个参数来向数组中添加元素。第三个参数可以是一个或多个元素，这些元素会被添加到数组中。这使我们能够便捷地将数组中的一个或一系列元素换成其他的元素。例如： + +```js +const numbers = [10, 11, 12, 12, 15]; +const startIndex = 3; +const amountToDelete = 1; + +numbers.splice(startIndex, amountToDelete, 13, 14); +// 第二个 12 被移除，在第二个 12 的索引处添加 13、14。 +console.log(numbers); +// 返回 [ 10, 11, 12, 13, 14, 15 ] +``` + +以一个数字数组开始。接着调用 splice() 方法，在 (3) 的索引位置开始删除元素，删除的元素数量是 (1)，(13, 14) 是在删除位置插入的元素，可以在 amountToDelete 后面插入任意数量的元素（以逗号分隔），每个都会被插入。 +
## Instructions -
我们定义了一个函数htmlColorNames ，它将一组HTML颜色作为参数。使用splice()修改函数以删除数组的前两个元素，并在各自的位置添加'DarkSalmon'和'BlanchedAlmond' 'DarkSalmon' 。
+
+我们已经定义了一个htmlColorNames函数，它以一个 HTML 颜色的数组作为输入参数。请修改这个函数，利用splice()来移除数组中的前两个元素，并在对应的位置上添加'DarkSalmon'和'BlanchedAlmond'。 +
## Tests
@@ -45,7 +62,6 @@ function htmlColorNames(arr) { // do not change code below this line console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'PaleTurqoise', 'FireBrick'])); - ``` @@ -58,6 +74,10 @@ console.log(htmlColorNames(['DarkGoldenRod', 'WhiteSmoke', 'LavenderBlush', 'Pal
```js -// solution required +function htmlColorNames(arr) { + arr.splice(0,2,'DarkSalmon', 'BlanchedAlmond'); + return arr; +} ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.chinese.md index 2e6595a8d5..4fed55c6ed 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/add-key-value-pairs-to-javascript-objects.chinese.md @@ -2,30 +2,59 @@ id: 587d7b7c367417b2b2512b18 title: Add Key-Value Pairs to JavaScript Objects challengeType: 1 -videoUrl: '' -localeTitle: 将键值对添加到JavaScript对象 +forumTopicId: 301153 +localeTitle: 将键值对添加到对象中 --- ## Description -
在最基本的情况下，对象只是键值对的集合，换句话说，映射到我们称为属性或键的唯一标识符的数据片段。我们来看一个非常简单的例子：
让FCC_User = {
用户名：'awesome_coder'，
粉丝：572，
积分：1741，
已完成项目：15
};
上面的代码定义了一个名为FCC_User的对象，它有四个属性 ，每个属性都映射到一个特定的值。如果我们想知道的数量followers FCC_User了，我们可以通过写访问属性：
let userData = FCC_User.followers;
// userData等于572
这称为点符号 。或者，我们也可以使用括号访问该属性，如下所示：
让userData = FCC_User ['粉丝']
// userData等于572
请注意，带支架的符号 ，我们封闭followers在引号。这是因为括号实际上允许我们传递一个变量以作为属性名称进行评估（提示：请记住这一点以供日后使用！）。如果我们在没有引号的情况下传递了followers ，那么JavaScript引擎会尝试将其作为变量进行评估，而ReferenceError: followers is not defined将被抛出。
+
+对象（object）本质上是键值对（key-value pair）的集合，或者说，一系列被映射到唯一标识符（叫做属性（property）或者键（key））的数据。让我们来看一个很简单的例子： + +```js +let FCC_User = { + username: 'awesome_coder', + followers: 572, + points: 1741, + completedProjects: 15 +}; +``` + +上面的代码定义了一个叫做FCC_User的对象，它有 4 个属性，每个属性映射一个特定的值。如果我们想知道FCC_User有多少followers，我们可以这样访问其followers属性： + +```js +let userData = FCC_User.followers; +// userData 等于 572 +``` + +这叫做点符号（dot notation）。我们还可以用方括号符号来访问对象中的属性： + +```js +let userData = FCC_User['followers']; +// userData 等于 572 +``` + +注意，在用方括号符号时，我们在括号里写的是字符串followers（用引号括起）。方括号符号让我们能用一个变量作为属性名来访问对象的属性（请记住）。若我们在方括号中不写引号而直接写followers，JavaScript 引擎会将其看作一个变量，并抛出一个ReferenceError: followers is not defined的错误。 +
## Instructions -
使用相同的语法，我们还可以向对象添加新的键值对。我们用三个条目创建了一个foods对象。再添加三个条目：价值为13 bananas ，价值为35 grapes和价值为27 strawberries 。
+
+用这样的语法，我们还可以向对象中新增键值对。我们已经创建了一个有 3 个属性的foods对象，请为其新增 3 项：值为13的bananas属性、值为35的grapes属性和值为27的strawberries属性。 +
## Tests
```yml tests: - - text: foods是一个对象 + - text: foods应该是一个对象。 testString: assert(typeof foods === 'object'); - - text: foods对象有一个值为13的关键"bananas" + - text: foods应该有一个值为13的"bananas"属性。 testString: assert(foods.bananas === 13); - - text: foods对象有一个关键的"grapes" ，价值35 + - text: foods应该有一个值为35的"grapes"属性。 testString: assert(foods.grapes === 35); - - text: foods对象有一个关键的"strawberries" ，值为27 + - text: foods应该有一个值为27的"strawberries"属性。 testString: assert(foods.strawberries === 27); - - text: 应使用点或括号表示法设置键值对 + - text: 你应该用点符号或者方括号符号来设置对象的属性。 testString: assert(code.search(/bananas:/) === -1 && code.search(/grapes:/) === -1 && code.search(/strawberries:/) === -1); ``` @@ -49,7 +78,6 @@ let foods = { // change code above this line console.log(foods); - ``` @@ -62,6 +90,17 @@ console.log(foods);
```js -// solution required +let foods = { + apples: 25, + oranges: 32, + plums: 28 +}; + +// change code below this line +foods['bananas'] = 13; +foods['grapes'] = 35; +foods['strawberries'] = 27; +// change code above this line ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.chinese.md index 1ca7cfa296..08203458af 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-for-the-presence-of-an-element-with-indexof.chinese.md @@ -2,15 +2,29 @@ id: 587d7b7b367417b2b2512b14 title: Check For The Presence of an Element With indexOf() challengeType: 1 -videoUrl: '' -localeTitle: 使用indexOf（）检查元素是否存在 +forumTopicId: 301154 +localeTitle: 使用 indexOf() 检查元素是否存在 --- ## Description -
由于数组可以随时更改或变异 ，因此无法保证特定数据在特定数组中的位置，或者该元素是否仍然存在。幸运的是，JavaScript为我们提供了另一种内置方法indexOf() ，它允许我们快速，轻松地检查数组中元素的存在。 indexOf()接受一个元素作为参数，并在调用时返回该元素的位置或索引，如果该元素在数组中不存在，则返回-1 。例如：
让水果= ['苹果'，'梨'，'橙子'，'桃子'，'梨子'];

fruits.indexOf（'dates'）//返回-1
fruits.indexOf（'oranges'）//返回2
fruits.indexOf（'pears'）//返回1，元素所在的第一个索引
+
+由于数组可以在任意时间被修改或者说被改变（mutated），我们不能保证某个数据在一个给定数组中的位置，甚至不能保证该元素还存在于该数组中。幸运的是，JavaScript 给我们提供了另一个内置方法indexOf()。这个方法让我们可以便捷地检查某个元素是否存在于一个数组中。indexOf()方法接受一个元素作为输入参数，并返回该元素在数组中的位置（索引）；若该元素不存在于数组中则返回-1。 +例如： + +```js +let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears']; + +fruits.indexOf('dates'); // 返回 -1 +fruits.indexOf('oranges'); // 返回 2 +fruits.indexOf('pears'); // 返回 1，即第一个出现的 'pears' 元素在数组中的索引为 1 +``` + +
## Instructions -
indexOf()对于快速检查数组中是否存在元素非常有用。我们定义了一个函数quickCheck ，它将一个数组和一个元素作为参数。使用indexOf()修改函数，以便在传递的元素存在于数组时返回true如果不存在则返回false 。
+
+indexOf()在快速检查一个数组中是否存在某个元素时非常有用。我们已经定义了一个quickCheck函数，它接受一个数组和一个元素作为输入参数。请修改这个函数，利用indexOf()方法，使得当输入的数组中含有输入的元素时，函数返回true；不含有输入的元素时，函数返回false。 +
## Tests
@@ -46,7 +60,6 @@ function quickCheck(arr, elem) { // change code here to test different cases: console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms')); - ``` @@ -59,6 +72,11 @@ console.log(quickCheck(['squash', 'onions', 'shallots'], 'mushrooms'));
```js -// solution required +function quickCheck(arr, elem) { + // change code below this line + return arr.indexOf(elem) >= 0; + // change code above this line +} ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.chinese.md index 2d3cf49b41..aaaabb1e5d 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/check-if-an-object-has-a-property.chinese.md @@ -2,33 +2,49 @@ id: 587d7b7d367417b2b2512b1c title: Check if an Object has a Property challengeType: 1 -videoUrl: '' -localeTitle: 检查对象是否具有属性 +forumTopicId: 301155 +localeTitle: 检查对象是否具有某个属性 --- ## Description -
现在我们可以添加，修改和删除对象中的键。但是，如果我们只是想知道某个对象是否具有特定属性呢？ JavaScript为我们提供了两种不同的方法。一个使用hasOwnProperty()方法，另一个使用in关键字。如果我们有一个具有Alan属性的对象users ，我们可以通过以下任一方式检查其存在：
users.hasOwnProperty（ '艾伦'）;
'艾伦'在用户;
//都返回true
+
+现在我们可以新增、修改和移除对象中的属性。但如果我们想知道一个对象中是否含有某个属性呢？JavaScript 为我们提供了两种不同的方式来实现这个功能，一个是hasOwnProperty()方法，另一个是in关键字。如果我们有一个users对象，它有一个Alan属性，我们可以用以下两种方式之一来检查该属性在对象中是否存在： + +```js +users.hasOwnProperty('Alan'); +'Alan' in users; +// 都返回 true +``` + +
## Instructions -
我们创建了一个对象， users ，其中包含一些用户和一个函数isEveryoneHere ，我们将users对象作为参数传递给它。完成编写此函数，以便仅当users对象包含所有四个名称（ Alan ， Jeff ， Sarah和Ryan ）作为键时才返回true ，否则返回false 。
+
+我们已经创建了一个含有一些用户的users对象和一个isEveryoneHere函数，该函数接受users对象作为参数。请完成该函数使其在users对象中包含以下 4 个键Alan、Jeff、Sarah和Ryan时才返回true，否则返回false。 +
## Tests
```yml tests: - - text: users对象仅包含Alan ， Jeff ， Sarah和Ryan - testString: 'assert("Alan" in users && "Jeff" in users && "Sarah" in users && "Ryan" in users && Object.keys(users).length === 4, "The users object only contains the keys Alan, Jeff, Sarah, and Ryan");' - - text: 如果Alan ， Jeff ， Sarah和Ryan是users对象的属性，则函数isEveryoneHere返回true - testString: 'assert(isEveryoneHere(users) === true, "The function isEveryoneHere returns true if Alan, Jeff, Sarah, and Ryan are properties on the users object");' - - text: 如果Alan ， Jeff ， Sarah和Ryan不是users对象的属性，则函数isEveryoneHere返回false - testString: 'assert((function() { delete users.Alan; delete users.Jeff; delete users.Sarah; delete users.Ryan; return isEveryoneHere(users) })() === false, "The function isEveryoneHere returns false if Alan, Jeff, Sarah, and Ryan are not properties on the users object");' - + - text: users对象应该只含有Alan、Jeff、Sarah和Ryan4 个键。 + testString: assert("Alan" in users && "Jeff" in users && "Sarah" in users && "Ryan" in users && Object.keys(users).length === 4); + - text: isEveryoneHere函数在users对象包含Alan、Jeff、Sarah和Ryan4 个键时应该返回true。 + testString: assert(isEveryoneHere(users) === true); + - text: isEveryoneHere函数在users对象不包含Alan、Jeff、Sarah或Ryan4 个键时应该返回false。 + testString: assert((function() { delete users.Alan; return isEveryoneHere(users) })() === false); + - text: 如果 Jeff 不是 users 对象的属性，函数 isEveryoneHere 应该返回 false。 + testString: assert((function() { delete users.Jeff; return isEveryoneHere(users) })() === false); + - text: 如果 Sarah 不是 users 对象的属性，函数 isEveryoneHere 应该返回 false。 + testString: assert((function() { delete users.Sarah; return isEveryoneHere(users) })() === false); + - text: 如果 Ryan 不是 users 对象的属性，函数 isEveryoneHere 应该返回 false。 + testString: assert((function() { delete users.Ryan; return isEveryoneHere(users) })() === false); ```
-## Challenge Seed +# Challenge Seed
@@ -60,7 +76,6 @@ function isEveryoneHere(obj) { } console.log(isEveryoneHere(users)); - ```
@@ -73,6 +88,35 @@ console.log(isEveryoneHere(users));
```js -// solution required +let users = { + Alan: { + age: 27, + online: true + }, + Jeff: { + age: 32, + online: true + }, + Sarah: { + age: 48, + online: true + }, + Ryan: { + age: 19, + online: true + } +}; + +function isEveryoneHere(obj) { + return [ + 'Alan', + 'Jeff', + 'Sarah', + 'Ryan' + ].every(i => obj.hasOwnProperty(i)); +} + +console.log(isEveryoneHere(users)); ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.chinese.md index ae3cdb7bdd..cee1192397 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/combine-arrays-with-the-spread-operator.chinese.md @@ -2,15 +2,28 @@ id: 587d7b7b367417b2b2512b17 title: Combine Arrays with the Spread Operator challengeType: 1 -videoUrl: '' -localeTitle: 将数组与Spread运算符组合在一起 +forumTopicId: 301156 +localeTitle: 组合使用数组和扩展运算符 --- ## Description -
扩展运算符的另一个巨大优势是能够组合数组，或者在任何索引处将一个数组的所有元素插入到另一个数组中。使用更传统的语法，我们可以连接数组，但这只允许我们在一个数组的末尾和另一个数组的开头组合数组。 Spread语法使以下操作非常简单：
让thisArray = ['sage'，'迷迭香'，'欧芹'，'百里香'];

让那个阵容= ['罗勒'，'香菜'，......这个阿雷，'香菜'];
//现在等于['罗勒'，'香菜'，'鼠尾草'，'迷迭香'，'欧芹'，'百里香'，'香菜']
使用扩展语法，我们刚刚实现了一个操作，如果我们使用传统方法，这个操作会更复杂，更冗长。
+
+展开运算符的另一个大用处是合并数组，或者将某个数组的所有元素插入到另一个数组的任意位置。用传统的语法我们也可以连接两个数组，但只能两个数组首尾相接。而展开语法能使下面的操作变得极其简单： + +```js +let thisArray = ['sage', 'rosemary', 'parsley', 'thyme']; + +let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander']; +// thatArray 现在是 ['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander'] +``` + +使用展开语法，我们这样就实现了一个用传统方法要写得很复杂冗长的操作。 +
## Instructions -
我们定义了一个函数spreadOut ，它返回变量sentence ，使用spread运算符修改函数，使它返回数组['learning', 'to', 'code', 'is', 'fun'] 。
+
+我们已经定义了一个返回sentence变量的spreadOut函数，请修改该函数，利用展开运算符使该函数返回数组['learning', 'to', 'code', 'is', 'fun']。 +
## Tests
@@ -19,7 +32,7 @@ localeTitle: 将数组与Spread运算符组合在一起 tests: - text: 'spreadOut应该返回["learning", "to", "code", "is", "fun"]' testString: assert.deepEqual(spreadOut(), ['learning', 'to', 'code', 'is', 'fun']); - - text: spreadOut函数应该使用扩展语法 + - text: spreadOut函数里应该用到展开语法 testString: assert.notStrictEqual(spreadOut.toString().search(/[...]/), -1); ``` @@ -40,7 +53,6 @@ function spreadOut() { // do not change code below this line console.log(spreadOut()); - ``` @@ -54,5 +66,13 @@ console.log(spreadOut()); ```js // solution required + +function spreadOut() { + let fragment = ['to', 'code']; + let sentence = ['learning', ...fragment, 'is', 'fun']; + return sentence; +} + ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.chinese.md index 52170e1f19..47799242d3 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-an-array-with-the-spread-operator.chinese.md @@ -2,30 +2,43 @@ id: 587d7b7b367417b2b2512b13 title: Copy an Array with the Spread Operator challengeType: 1 -videoUrl: '' -localeTitle: 使用Spread Operator复制数组 +forumTopicId: 301157 +localeTitle: 使用扩展运算符复制数组 --- ## Description -
虽然slice()允许我们选择要复制的数组元素，但在其他几个有用的任务中，ES6的新扩展运算符允许我们使用简单且高度可读的语法轻松地按顺序复制所有数组的元素。扩展语法看起来像这样： ...在实践中，我们可以使用spread运算符来复制数组，如下所示：
let thisArray = [true，true，undefined，false，null];
让thatArray = [... thisArray];
// thatArray等于[true，true，undefined，false，null]
// thisArray保持不变，与thatArray相同
+
+slice()已经能让我们从一个数组中选择一些元素来复制到新数组中了，而 ES6 中又新引入了一个简洁且可读性强的语法展开运算符（spread operator），它能让我们方便地复制数组中的所有元素。展开语法是这样的：... +在实践中，我们可以这样用展开运算符来复制一个数组： + +```js +let thisArray = [true, true, undefined, false, null]; +let thatArray = [...thisArray]; +// thatArray 等于 [true, true, undefined, false, null] +// thisArray 保持不变，等于 thatArray +``` + +
## Instructions -
我们定义了一个函数copyMachine ，它将arr （数组）和num （数字）作为参数。该函数应该返回一个由arr的num副本组成的新数组。我们为您完成了大部分工作，但它还没有正常工作。使用扩展语法修改函数以使其正常工作（提示：我们已经介绍过的另一种方法可能会派上用场！）。
+
+我们已经定义了一个copyMachine函数，它接受arr（一个数组）和num（一个数字）作为输入参数。该函数应该返回一个由num个arr组成的新数组。我们已经为你写好了大部分的代码，但它还不能正确地工作。请修改这个函数，使用展开语法，使该函数正确工作（提示：我们已经学到过的一个方法很适合用在这里！） +
## Tests
```yml tests: - - text: 'copyMachine([true, false, true], 2)应返回[[true, false, true], [true, false, true]]' + - text: 'copyMachine([true, false, true], 2)应该返回[[true, false, true], [true, false, true]]' testString: assert.deepEqual(copyMachine([true, false, true], 2), [[true, false, true], [true, false, true]]); - - text: 'copyMachine([1, 2, 3], 5)应返回[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]' + - text: 'copyMachine([1, 2, 3], 5)应该返回[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]' testString: assert.deepEqual(copyMachine([1, 2, 3], 5), [[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]); - text: 'copyMachine([true, true, null], 1)应该返回[[true, true, null]]' testString: assert.deepEqual(copyMachine([true, true, null], 1), [[true, true, null]]); - text: 'copyMachine(["it works"], 3)应该返回[["it works"], ["it works"], ["it works"]]' testString: assert.deepEqual(copyMachine(['it works'], 3), [['it works'], ['it works'], ['it works']]); - - text: copyMachine函数应该使用带有数组arr的spread operator + - text: copyMachine函数中应该对数组arr使用spread operator。 testString: assert(removeJSComments(code).match(/\.\.\.arr/)); ``` @@ -51,12 +64,18 @@ function copyMachine(arr, num) { // change code here to test different cases: console.log(copyMachine([true, false, true], 2)); - ``` +### After Test +
+```js +const removeJSComments = str => str.replace(/\/\*[\s\S]*?\*\/|\/\/.*$/gm, ''); +``` + +
@@ -64,6 +83,17 @@ console.log(copyMachine([true, false, true], 2));
```js -// solution required +function copyMachine(arr,num){ + let newArr=[]; + while(num >=1){ + // change code below this line + newArr.push([...arr]); + //change code above this line + num--; + } + return newArr; +} +console.log(copyMachine([true, false, true], 2)); ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.chinese.md index 8fb9a8db1e..29532696d4 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/copy-array-items-using-slice.chinese.md @@ -2,15 +2,29 @@ id: 587d7b7a367417b2b2512b12 title: Copy Array Items Using slice() challengeType: 1 -videoUrl: '' -localeTitle: 使用slice（）复制数组项 +forumTopicId: 301158 +localeTitle: 使用 slice() 拷贝数组项目 --- ## Description -
我们将介绍的下一个方法是slice() 。 slice() ，而不是修改数组，将给定数量的元素复制或提取到新数组，而不改变它所调用的数组。 slice()只接受2个参数 - 第一个是开始提取的索引，第二个是停止提取的索引（提取将发生，但不包括此索引处的元素）。考虑一下：
让weatherConditions = ['rain'，'snow'，'sleet'，'hail'，'clear'];

让todaysWeather = weatherConditions.slice（1,3）;
//今天天气等于['雪'，'雨夹雪'];
// weatherConditions仍等于['rain'，'snow'，'sleet'，'hail'，'clear']
实际上，我们通过从现有数组中提取元素来创建一个新数组。
+
+接下来我们要介绍slice()方法。slice()并不修改数组，而是复制或者说提取（extract）给定数量的元素到一个新数组里，而调用方法的数组则保持不变。slice()只接受 2 个输入参数—第一个是开始提取元素的位置（索引），第二个是结束提取元素的位置（索引）。slice 方法会提取直到截止索引的元素，但被提取的元素不包括截止索引对应的元素。请看以下例子： + +```js +let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear']; + +let todaysWeather = weatherConditions.slice(1, 3); +// todaysWeather 等于 ['snow', 'sleet']; +// weatherConditions 仍然等于 ['rain', 'snow', 'sleet', 'hail', 'clear'] +``` + +现在我们从一个已有的数组中提取了一些元素，并用这些元素创建了一个新数组。 +
## Instructions -
我们定义了一个以数组作为参数的函数forecast 。使用slice()修改函数以从参数数组中提取信息，并返回包含元素'warm'和'sunny'的新数组。
+
+我们已经定义了一个forecast函数，它接受一个数组作为参数。请修改这个函数，利用slice()来从输入的数组中提取信息，并返回一个包含元素'warm'和'sunny' 的新数组。 +
## Tests
@@ -40,7 +54,6 @@ function forecast(arr) { // do not change code below this line console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms'])); - ``` @@ -53,6 +66,9 @@ console.log(forecast(['cold', 'rainy', 'warm', 'sunny', 'cool', 'thunderstorms']
```js -// solution required +function forecast(arr) { + return arr.slice(2,4); +} ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.chinese.md index 93476ca33c..bec152564e 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/create-complex-multi-dimensional-arrays.chinese.md @@ -2,30 +2,72 @@ id: 587d7b7b367417b2b2512b16 title: Create complex multi-dimensional arrays challengeType: 1 -videoUrl: '' +forumTopicId: 301159 localeTitle: 创建复杂的多维数组 --- ## Description -
真棒！你刚学了很多关于阵列的知识！这是一个相当高级别的概述，有很多关于使用数组的知识，其中大部分将在后面的章节中看到。但在继续观察对象之前 ，让我们再看一下，看看阵列如何变得比我们在之前的挑战中看到的更复杂。将数组视为数据结构时，最强大的功能之一是数组可以包含甚至完全由其他数组组成。我们已经看到在之前的挑战中包含数组的数组，但相当简单。但是，数组可以包含无限深度的数组，这些数组可以包含其他数组，每个数组都有自己的任意深度级别，依此类推。通过这种方式，数组可以非常快速地变成非常复杂的数据结构，称为多维或嵌套数组。请考虑以下示例：
让nestedArray = [// top，或first level - 最外面的数组
['deep']，//数组中的数组，2个深度级别
[
['更深']，['更深'] // 2个数组嵌套3层深
]
[
[
['deepest']，['最深'] // 2个数组嵌套了4个级别
]
[
[
['deepest-est？'] //一个数组嵌套5层深
]
]
]
]。
虽然这个例子看似令人费解，但在处理大量数据时，这种复杂程度并非闻所未闻，甚至不同寻常。但是，我们仍然可以使用括号表示法轻松访问此复杂数组的最深层次：
的console.log（nestedArray [2] [1] [0] [0] [0]）;
//日志：最深？
现在我们知道那条数据在哪里，如果需要，我们可以重置它：
nestedArray [2] [1] [0] [0] [0] =“更深”;

的console.log（nestedArray [2] [1] [0] [0] [0]）;
//现在记录：更深入
+
+很好！你已经学到很多关于数组的知识了！但这些只是一个开始，你将在接下来的小节中学习到与数组相关的更多知识。但在继续去学习对象（Objects）之前，让我们再花一点时间看一看，数组怎样能够变得比之前的挑战中更复杂一点。 +数组的一个强大的特性是，它可以包含其他数组，甚至完全由其他数组组成。我们已经在上一个挑战中看到了包含数组的数组，但它还算是比较简单的。数组中的数组还可以在包含其他数组，数组中是可以嵌套任意层的数组的。数组从而可以被用来实现非常复杂的叫做多维（multi-dimensional）或嵌套（nested）数组的数据结构。请看如下例子： + +```js +let nestedArray = [ // 顶层，或第 1 层——最外层的数组 + ['deep'], // 数组中的数组，第 2 层 + [ + ['deeper'], ['deeper'] // 第 3 层嵌套的两个数组 + ], + [ + [ + ['deepest'], ['deepest'] // 第 4 层嵌套的两个数组 + ], + [ + [ + ['deepest-est?'] // 第 5 层嵌套的一个数组 + ] + ] + ] +]; +``` + +虽然这个例子看起来错综复杂，但这样复杂的数组并不算罕见，尤其是在处理大量数据的时候。 +但我们仍能简单地用方括号符号来访问到嵌套得最深的数组： + +```js +console.log(nestedArray[2][1][0][0][0]); +// logs: deepest-est? +``` + +既然我们知道数据在哪里，我们就能修改它： + +```js +nestedArray[2][1][0][0][0] = 'deeper still'; + +console.log(nestedArray[2][1][0][0][0]); +// now logs: deeper still +``` + +
## Instructions -
我们已经定义了一个变量myNestedArray ，它等于一个数组。修改myNestedArray ，使用数据元素的字符串 ， 数字和布尔值的任意组合，以便它具有五个深度级别（请记住，最外层的数组是级别1）。某处在第三级上，包括字符串'deep' ，在第四级，包括字符串'deeper' ，并且在第五层上，包括字符串'deepest' 。
+
+我们已经定义了一个myNestedArray数组变量。请修改myNestedArray，用字符串（string）、数字（number）或者布尔值（boolean）作为数组的数据元素，使得myNestedArray刚好有 5 层数组嵌套（记住，最外层的数组是第 1 层）。请在第 3 层的数组中包含字符串'deep'，在第 4 层的数组中包含字符串'deeper'，在第 5 层的数组中包含字符串'deepest'。 +
## Tests
```yml tests: - - text: myNestedArray应仅包含数字，布尔值和字符串作为数据元素 + - text: myNestedArray中的数据元素应当只能是字符串、数字或者布尔值。 testString: 'assert.strictEqual((function(arr) { let flattened = (function flatten(arr) { const flat = [].concat(...arr); return flat.some (Array.isArray) ? flatten(flat) : flat; })(arr); for (let i = 0; i < flattened.length; i++) { if ( typeof flattened[i] !== ''number'' && typeof flattened[i] !== ''string'' && typeof flattened[i] !== ''boolean'') { return false } } return true })(myNestedArray), true);' - - text: myNestedArray应该有5个级别的深度 + - text: myNestedArray应该刚好有 5 层数组嵌套。 testString: 'assert.strictEqual((function(arr) {let depth = 0;function arrayDepth(array, i, d) { if (Array.isArray(array[i])) { arrayDepth(array[i], 0, d + 1);} else { depth = (d > depth) ? d : depth;}if (i < array.length) { arrayDepth(array, i + 1, d);} }arrayDepth(arr, 0, 0);return depth;})(myNestedArray), 4);' - - text: myNestedArray应该在嵌套3级深度的数组中恰好包含一个字符串"deep" + - text: myNestedArray里应该有且只有一个字符串"deep"，并且应该出现在第 3 层数组中。 testString: assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, 'deep').length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, 'deep')[0] === 2); - - text: myNestedArray应该在嵌套4级深度的数组中恰好包含一个字符串"deeper" deep” + - text: myNestedArray里应该有且只有一个字符串"deeper"，并且应该出现在第 4 层数组中。 testString: assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, 'deeper').length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, 'deeper')[0] === 3); - - text: myNestedArray应该在嵌套5级深度的数组中恰好包含一个字符串"deepest" myNestedArray "deepest" + - text: myNestedArray里应该有且只有一个字符串"deepest"，并且应该出现在第 5 层数组中。 testString: assert((function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, 'deepest').length === 1 && (function howDeep(array, target, depth = 0) {return array.reduce((combined, current) => {if (Array.isArray(current)) { return combined.concat(howDeep(current, target, depth + 1));} else if (current === target) { return combined.concat(depth);} else { return combined;}}, []);})(myNestedArray, 'deepest')[0] === 4); ``` @@ -47,7 +89,6 @@ let myNestedArray = [ ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth'] // change code above this line ]; - ``` @@ -60,6 +101,15 @@ let myNestedArray = [
```js -// solution required +let myNestedArray = [ + // change code below this line + ['unshift', ['deep', ['deeper', ['deepest']]],false, 1, 2, 3, 'complex', 'nested'], + ['loop', 'shift', 6, 7, 1000, 'method'], + ['concat', false, true, 'spread', 'array'], + ['mutate', 1327.98, 'splice', 'slice', 'push'], + ['iterate', 1.3849, 7, '8.4876', 'arbitrary', 'depth'] + // change code above this line +]; ``` +
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.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.chinese.md index a9c7ff99af..1959b20c6e 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/generate-an-array-of-all-object-keys-with-object.keys.chinese.md @@ -2,24 +2,28 @@ id: 587d7b7d367417b2b2512b1e title: Generate an Array of All Object Keys with Object.keys() challengeType: 1 -videoUrl: '' -localeTitle: 使用Object.keys（）生成所有对象键的数组 +forumTopicId: 301160 +localeTitle: 使用 Object.Keys() 生成对象所有键组成的数组 --- ## Description -
我们还可以使用Object.keys()方法生成一个数组，其中包含存储在对象中的所有键，并传入一个对象作为参数。这将返回一个数组，其中的字符串表示对象中的每个属性。同样，数组中的条目没有特定的顺序。
+
+我们还可以输入一个对象作为参数来调用Object.keys()方法，使其生成一个包含对象中所有键的数组。这会返回一个由对象中所有键的名称（字符串）组成的数组。再次说明，这个数组中的项的顺序是不确定的。 +
## Instructions -
完成编写getArrayOfUsers函数，以便它返回一个数组，该数组包含它作为参数接收的对象中的所有属性。
+
+请你完成getArrayOfUsers函数，使其返回一个包含输入的对象的所有属性的数组。 +
## Tests
```yml tests: - - text: users对象仅包含Alan ， Jeff ， Sarah和Ryan + - text: users对象应该只包含Alan、Jeff、Sarah和Ryan这 4 个键 testString: assert('Alan' in users && 'Jeff' in users && 'Sarah' in users && 'Ryan' in users && Object.keys(users).length === 4); - - text: getArrayOfUsers函数返回一个数组，其中包含users对象中的所有键 + - text: getArrayOfUsers函数应该返回一个包含users对象中所有键的数组 testString: assert((function() { users.Sam = {}; users.Lewis = {}; let R = getArrayOfUsers(users); return (R.indexOf('Alan') !== -1 && R.indexOf('Jeff') !== -1 && R.indexOf('Sarah') !== -1 && R.indexOf('Ryan') !== -1 && R.indexOf('Sam') !== -1 && R.indexOf('Lewis') !== -1); })() === true); ``` @@ -58,7 +62,6 @@ function getArrayOfUsers(obj) { } console.log(getArrayOfUsers(users)); - ``` @@ -71,6 +74,30 @@ console.log(getArrayOfUsers(users));
```js -// solution required +let users = { + Alan: { + age: 27, + online: false + }, + Jeff: { + age: 32, + online: true + }, + Sarah: { + age: 48, + online: false + }, + Ryan: { + age: 19, + online: true + } +}; + +function getArrayOfUsers(obj) { + return Object.keys(obj); +} + +console.log(getArrayOfUsers(users)); ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.chinese.md index fb6f3e7aa5..df052794c2 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/iterate-through-all-an-arrays-items-using-for-loops.chinese.md @@ -2,15 +2,37 @@ id: 587d7b7b367417b2b2512b15 title: Iterate Through All an Array's Items Using For Loops challengeType: 1 -videoUrl: '' -localeTitle: 使用for循环遍历所有数组的项目 +forumTopicId: 301161 +localeTitle: 使用 For 循环迭代数组的所有项 --- ## Description -
有时在使用数组时，能够遍历每个项目以查找我们可能需要的一个或多个元素，或者根据哪些数据项符合某组标准来操作数组非常方便。 JavaScript提供了几种内置方法，每种方法都以稍微不同的方式迭代数组以实现不同的结果（例如every() ， forEach() ， map()等），但是这种技术最灵活并且为我们提供了最大的控制量是一个简单的for循环。考虑以下：
function greaterThanTen（arr）{
让newArr = [];
for（let i = 0; i <arr.length; i ++）{
if（arr [i]> 10）{
（ARR [I]）newArr.push;
}
}
返回newArr;
}

greaterThanTen（[2,12,8,14,80,0,1]）;
//返回[12,14,80]
使用for循环，此函数遍历并访问数组的每个元素，并使其经受我们创建的简单测试。通过这种方式，我们可以轻松地以编程方式确定哪些数据项大于10 ，并返回包含这些项的新数组。
+
+在进行与数组有关的编程时，我们有时需要遍历数组的所有元素来找出我们需要的元素，或者对数组执行特定的操作。JavaScript 提供了几个内置的方法，它们以不同的方式遍历数组来获得不同的结果（如every()、forEach()、map()等等）。而简单的for循环不仅能实现这些功能，而且相比之下也更灵活。 +请看以下例子： + +```js +function greaterThanTen(arr) { + let newArr = []; + for (let i = 0; i < arr.length; i++) { + if (arr[i] > 10) { + newArr.push(arr[i]); + } + } + return newArr; +} + +greaterThanTen([2, 12, 8, 14, 80, 0, 1]); +// 返回 [12, 14, 80] +``` + +这个函数使用一个for循环来遍历一个数组，逐一对其中的元素进行测试。我们用这个方法简单地以编程的方式找出了数组中大于10的元素，并返回了一个包含这些元素的数组。 +
## Instructions -
我们定义了一个函数filteredArray ，它接受arr ，一个嵌套数组和elem作为参数，并返回一个新数组。 elem表示在arr嵌套的一个或多个数组上可能存在或不存在的元素。使用for循环修改函数，以返回已传递数组的过滤版本，以便删除嵌套在包含elem arr中的任何数组。
+
+我们已经定义了一个filteredArray函数，它接受一个嵌套的数组参数arr以及一个elem参数，并要返回一个新数组。arr数组中的数组可能包含elem元素，也可能不包含。请修改该函数，用一个for循环来做筛选，使函数返回一个由arr中不包含elem的数组组成的新数组。 +
## Tests
@@ -48,7 +70,6 @@ function filteredArray(arr, elem) { // change code here to test different cases: console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3)); - ``` @@ -61,6 +82,17 @@ console.log(filteredArray([[3, 2, 3], [1, 6, 3], [3, 13, 26], [19, 3, 9]], 3));
```js -// solution required +function filteredArray(arr, elem) { + let newArr = []; + // change code below this line + for (let i = 0; i 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.chinese.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.chinese.md index bc0bf4215e..e03d8a0a82 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.chinese.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.chinese.md @@ -2,26 +2,66 @@ id: 587d7b7d367417b2b2512b1d title: 'Iterate Through the Keys of an Object with a for...in Statement' challengeType: 1 -videoUrl: '' -localeTitle: 使用for ... in Statement中的对象键迭代 +forumTopicId: 301162 +localeTitle: '使用 for...in 语句迭代对象' --- ## Description -
有时您可能需要遍历对象中的所有键。这需要JavaScript中的特定语法，称为for ... in语句。对于我们的users对象，这可能看起来像：
for（让用户在用户中）{
的console.log（用户）;
};

//日志：
艾伦
杰夫
莎拉
瑞安
在这个语句中，我们定义了一个变量user ，正如您所看到的，在每次迭代期间，当该语句循环遍历该对象时，该变量被重置为每个对象的键，从而导致每个用户的名称被打印到控制台。 注意：
对象不像数组那样保持对存储键的排序;因此，当引用或访问该密钥时，对象上的键位置或其出现的相对顺序是无关紧要的。
+
+ +有时候你需要遍历一个对象中的所有键。这需要 JavaScript 中的一个特殊语法：for...in 语句。以遍历 users 对象的键为例： + +```js +for (let user in users) { + console.log(user); +} + +// logs: +Alan +Jeff +Sarah +Ryan +``` + +在这个语句中，我们定义了一个user变量，你可以看到，这个变量在 for...in 语句对对象的每一个键的遍历中都会被重置。 +注意：
跟数组不同，对象中的键是无序的，因此一个对象中某个键的位置，或者说它出现的相对顺序，在引用或访问该键时是不确定的。 +
## Instructions -
我们定义了一个函数countOnline ;在此函数中使用for ... in语句循环访问users对象中的users并返回其online属性设置为true的用户数。
+
+ +我们已经定义了一个countOnline函数，请在其中使用一个 for...in 语句来遍历users对象中的用户，并返回online属性为true的用户的数量。 + + +```js +{ + Alan: { + online: false + }, + Jeff: { + online: true + }, + Sarah: { + online: false + } +} +``` + +
## Tests
```yml tests: - - text: users对象包含用户Jeff和Ryan ， online设置为true ，用户Alan和Sarah online设置为false - testString: 'assert(users.Alan.online === false && users.Jeff.online === true && users.Sarah.online === false && users.Ryan.online === true, "The users object contains users Jeff and Ryan with online set to true and users Alan and Sarah with online set to false");' - - text: 函数countOnline返回online属性设置为true的用户数 - testString: 'assert((function() { users.Harry = {online: true}; users.Sam = {online: true}; users.Carl = {online: true}; return countOnline(users) })() === 5, "The function countOnline returns the number of users with the online property set to true");' - + - text: 函数 countOnline 应该使用 `for in` 语句遍历传入对象的key。 + testString: assert(code.match(/for\s*\(\s*(var|let)\s+[a-zA-Z_$]\w*\s+in\s+[a-zA-Z_$]\w*\s*\)\s*{/)); + - text: '当传入 { Alan: { online: false }, Jeff: { online: true }, Sarah: { online: false } } 时，函数 countOnline 应该返回 1。' + testString: assert(countOnline(usersObj1) === 1); + - text: '当传入 { Alan: { online: true }, Jeff: { online: false }, Sarah: { online: true } } 时，函数 countOnline 应该返回 2。' + testString: assert(countOnline(usersObj2) === 2); + - text: '当传入 { Alan: { online: false }, Jeff: { online: false }, Sarah: { online: false } } 时，函数 countOnline 应该返回 0。' + testString: assert(countOnline(usersObj3) === 0); ```
@@ -32,37 +72,58 @@ tests:
```js -let users = { - Alan: { - age: 27, - online: false - }, - Jeff: { - age: 32, - online: true - }, - Sarah: { - age: 48, - online: false - }, - Ryan: { - age: 19, - online: true - } -}; - -function countOnline(obj) { +function countOnline(usersObj) { // change code below this line // change code above this line } - -console.log(countOnline(users)); - ```
+### After Test +
+ +```js +const usersObj1 = { + Alan: { + online: false + }, + Jeff: { + online: true + }, + Sarah: { + online: false + } +} + +const usersObj2 = { + Alan: { + online: true + }, + Jeff: { + online: false + }, + Sarah: { + online: true + } +} + + +const usersObj3 = { + Alan: { + online: false + }, + Jeff: { + online: false + }, + Sarah: { + online: false + } +} +``` + +
@@ -71,6 +132,17 @@ console.log(countOnline(users));
```js -// solution required + +function countOnline(usersObj) { + let online = 0; + for(let user in usersObj){ + if(usersObj[user].online) { + online++; + } + } + return online; +} + ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.chinese.md index 8965c0cc25..3e832da427 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-array-stored-in-an-object.chinese.md @@ -2,26 +2,30 @@ id: 587d7b7d367417b2b2512b1f title: Modify an Array Stored in an Object challengeType: 1 -videoUrl: '' +forumTopicId: 301163 localeTitle: 修改存储在对象中的数组 --- ## Description -
现在您已经看到了JavaScript对象的所有基本操作。您可以添加，修改和删除键值对，检查键是否存在，并迭代对象中的所有键。随着您继续学习JavaScript，您将看到更多功能的对象应用程序。此外，课程后面的可选高级数据结构课程还涵盖ES6 Map和Set对象，这两个对象与普通对象类似，但提供了一些附加功能。既然您已经学习了数组和对象的基础知识，那么您已经准备好开始使用JavaScript解决更复杂的问题了！
+
+现在你已经接触到 JavaScript 对象的所有运算。你可以增加、修改和移除键值对，检查某个键是否存在，并且遍历一个对象中的所有键。在你继续学习 JavaScript 的过程中，你会看到对象的更多用法。另外，后续的《高级数据结构》课程还会介绍 ES6 的 Map 和 Set 对象。这两种对象都跟一般的对象相似，但它们提供了一些额外的特性。现在你已经学到了数组和对象的基础知识，你已经可以继续用 JavaScript 来解决更加复杂的问题了！ +
## Instructions -
看看我们在代码编辑器中提供的对象。 user对象包含三个键。 data键包含五个键，其中一个键包含一组friends 。从这里，您可以看到灵活的对象如何作为数据结构。我们已经开始编写一个函数addFriend 。完成编写它以便它获取user对象并将friend参数的名称添加到存储在user.data.friends中的数组并返回该数组。
+
+请你看一下代码编辑器中我们提供的对象。user对象包含 3 个键。data对象包含 5 个键，其中一个包含一个friends数组。从这个例子你可以看到对象作为数据结构是多么的灵活。我们已经写了addFriend函数的一部分，请你完成这个函数，使其接受一个user对象，将friend参数中的名字添加到user.data.friends数组中并返回该数组。 +
## Tests
```yml tests: - - text: user对象具有name ， age和data键 + - text: user对象应该包含name、age和data三个键。 testString: assert('name' in user && 'age' in user && 'data' in user); - - text: addFriend函数接受user对象和friend字符串作为参数，并将朋友添加到user对象中的friends数组 + - text: addFriend函数应该接受一个user对象和一个friend字符串作为输入参数，并将 friend 插入到user对象的friends数组中。 testString: assert((function() { let L1 = user.data.friends.length; addFriend(user, 'Sean'); let L2 = user.data.friends.length; return (L2 === L1 + 1); })()); - - text: 'addFriend(user, "Pete")应该返回["Sam", "Kira", "Tomo", "Pete"]' + - text: 'addFriend(user, "Pete")应该返回["Sam", "Kira", "Tomo", "Pete"]。" testString: assert.deepEqual((function() { delete user.data.friends; user.data.friends = ['Sam', 'Kira', 'Tomo']; return addFriend(user, 'Pete') })(), ['Sam', 'Kira', 'Tomo', 'Pete']); ``` @@ -61,7 +65,6 @@ function addFriend(userObj, friend) { } console.log(addFriend(user, 'Pete')); - ``` @@ -74,6 +77,30 @@ console.log(addFriend(user, 'Pete'));
```js -// solution required +let user = { + name: 'Kenneth', + age: 28, + data: { + username: 'kennethCodesAllDay', + joinDate: 'March 26, 2016', + organization: 'freeCodeCamp', + friends: [ + 'Sam', + 'Kira', + 'Tomo' + ], + location: { + city: 'San Francisco', + state: 'CA', + country: 'USA' + } + } +}; + +function addFriend(userObj, friend) { + userObj.data.friends.push(friend); + return userObj.data.friends; +} ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.chinese.md index 13f98ceadd..71b957b354 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/modify-an-object-nested-within-an-object.chinese.md @@ -2,28 +2,49 @@ id: 587d7b7c367417b2b2512b19 title: Modify an Object Nested Within an Object challengeType: 1 -videoUrl: '' +forumTopicId: 301164 localeTitle: 修改嵌套在对象中的对象 --- ## Description -
现在让我们来看一个稍微复杂的对象。对象属性可以嵌套到任意深度，它们的值可以是JavaScript支持的任何类型的数据，包括数组甚至其他对象。考虑以下：
让nestedObject = {
id：28802695164，
日期：'2016年12月31日'，
数据：{
总用户：99，
在线：80，
onlineStatus：{
活跃：67，
离开：13
}
}
};
nestedObject有三个唯一的键： id ，其值为数字， date为字符串的data ， data ，其值为另一个嵌套在其中的对象。虽然结构很快就会变得复杂，但我们仍然可以使用相同的符号来访问我们需要的信息。
+
+现在我们来看一个稍微复杂一点的对象。对象中也可以嵌套任意层的对象。对象的属性值可以是 JavaScript 支持的任意类型，包括数组和其他对象。请看以下例子： + +```js +let nestedObject = { + id: 28802695164, + date: 'December 31, 2016', + data: { + totalUsers: 99, + online: 80, + onlineStatus: { + active: 67, + away: 13 + } + } +}; +``` + +nestedObject有 3 个唯一的键：值为一个数字的id、值为一个字符串的date和值为一个嵌套了其他对象的对象的data。虽然对象中的数据可能很复杂，我们仍能使用上一个挑战中讲的符号来访问我们需要的信息。 +
## Instructions -
在这里，我们定义了一个对象userActivity ，其中包含嵌套在其中的另一个对象。您可以像修改上一个挑战中的属性一样修改此嵌套对象的属性。将online密钥的值设置为45 。
+
+我们已经定义了一个userActivity对象，它包含了另一个对象。你可以用上一个挑战中那样的方式来修改被嵌套的对象的属性。请将online属性设为45。 +
## Tests
```yml tests: - - text: userActivity具有id ， date和data属性 + - text: userActivity应该含有id、date和data属性。 testString: assert('id' in userActivity && 'date' in userActivity && 'data' in userActivity); - - text: userActivity具有设置为具有密钥totalUsers和online的对象的data密钥 + - text: userActivity应该有一个data属性，该属性要是一个含有totalUsers和online属性的对象。 testString: assert('totalUsers' in userActivity.data && 'online' in userActivity.data); - - text: 嵌套在userActivity data键中的online属性应设置为45 + - text: userActivity的data属性值中的online属性应该被设为45。 testString: assert(userActivity.data.online === 45); - - text: online属性使用点或括号表示法设置 + - text: 你应该用点符号或者方括号符号来设置online属性。 testString: 'assert.strictEqual(code.search(/online: 45/), -1);' ``` @@ -50,7 +71,6 @@ let userActivity = { // change code above this line console.log(userActivity); - ``` @@ -63,6 +83,16 @@ console.log(userActivity);
```js -// solution required +let userActivity = { + id: 23894201352, + date: 'January 1, 2017', + data: { + totalUsers: 51, + online: 42 + } +}; + +userActivity.data.online = 45; ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.chinese.md index 858b776407..6a3493198e 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-from-an-array-with-pop-and-shift.chinese.md @@ -2,15 +2,39 @@ id: 587d78b2367417b2b2512b0f title: Remove Items from an Array with pop() and shift() challengeType: 1 -videoUrl: '' -localeTitle: 使用pop（）和shift（）从数组中删除项 +forumTopicId: 301165 +localeTitle: 使用 pop() 和 shift() 从数组中删除项目 --- ## Description -
push()和unshift()都有相应的几乎相反的方法： pop()和shift() 。正如您现在可能已经猜到的那样， pop()不是添加，而是从数组的末尾删除元素，而shift()从头开始删除元素。 pop()和shift()及其兄弟push()和unshift()之间的关键区别在于，两个方法都不接受参数，并且每个方法只允许一次由单个元素修改数组。让我们来看看：
让问候= ['什么事情？'，'你好'，'看到你！'];

greetings.pop（）;
//现在等于['whats up？'，'hello']

greetings.shift（）;
//现在等于['你好']
我们还可以使用以下任一方法返回已删除元素的值：
let popped = greetings.pop（）;
//返回'你好'
//问候现在等于[]
+
+push()和unshift()都分别有一个作用基本与之相反的函数：pop()和shift()。你现在或许已经猜到，与插入元素相反，pop()从数组的末尾移除一个元素，而shift()从数组的开头移除一个元素。pop()和shift()与对应的push()和unshift()的关键区别在于，前者不能接受输入参数，而且每次只能修改数组中的一个元素。 +让我们来看以下的例子： + +```js +let greetings = ['whats up?', 'hello', 'see ya!']; + +greetings.pop(); +// now equals ['whats up?', 'hello'] + +greetings.shift(); +// now equals ['hello'] +``` + +还可以用这些方法返回移除的元素，像这样： + +```js +let popped = greetings.pop(); +// returns 'hello' +// greetings now equals [] +``` + +
## Instructions -
我们定义了一个函数popShift ，它将一个数组作为参数并返回一个新数组。使用pop()和shift()修改函数，删除参数数组的第一个和最后一个元素，并将删除的元素分配给它们对应的变量，以便返回的数组包含它们的值。
+
+我们已经定义了一个popShift函数，它会接收一个数组作为输入参数并返回一个新的数组。请你修改这个函数，使用pop()和shift()来移除输入的数组的第一个元素和最后一个元素，并将这两个被移除的元素赋值给对应的变量，使得返回的数组包含它们的值。 +
## Tests
@@ -42,7 +66,6 @@ function popShift(arr) { // do not change code below this line console.log(popShift(['challenge', 'is', 'not', 'complete'])); - ``` @@ -55,6 +78,11 @@ console.log(popShift(['challenge', 'is', 'not', 'complete']));
```js -// solution required +function popShift(arr) { + let popped = arr.pop(); // change this line + let shifted = arr.shift(); // change this line + return [shifted, popped]; +} ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.chinese.md index f6e31fe306..3614cca78d 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/remove-items-using-splice.chinese.md @@ -2,26 +2,54 @@ id: 587d78b2367417b2b2512b10 title: Remove Items Using splice() challengeType: 1 -videoUrl: '' -localeTitle: 使用splice（）删除项目 +forumTopicId: 301166 +localeTitle: 使用 splice() 删除项目 --- ## Description -
好的，所以我们已经学会了如何使用shift()和pop()从数组的开头和结尾删除元素，但是如果我们想要从中间某处删除元素呢？或者一次删除多个元素？好吧，这就是splice()用武之地splice()允许我们这样做：从数组中的任何位置删除任意数量的连续元素 。 splice()可能需要长达3个参数，但现在，我们将重点放在刚第一2.第2个参数splice()是其代表索引的整数，或位置中，阵列的该splice()是为呼吁。请记住，数组是零索引的 ，所以为了表示数组的第一个元素，我们将使用0 。 splice()的第一个参数表示从中开始删除元素的数组的索引，而第二个参数表示要删除的元素的数量。例如：
让array = ['今天'，'是'，'不'，'所以'，'伟大'];

array.splice（2,2）;
//删除以第3个元素开头的2个元素
//数组现在等于['今天'，'是'，'很棒']
splice()不仅修改了它被调用的数组，而且还返回一个包含被删除元素值的新数组：
让array = ['我'，'我'，'感觉'，'真的'，'快乐'];

let newArray = array.splice（3,2）;
// newArray等于['真''，'快乐']
+
+在上面的挑战中，我们已经学到了如何利用shift()和pop()从数组的开头或者末尾移除元素，但如果我们想移除数组中间的一个元素呢？或者想一次移除多个元素呢？这时候我们就需要splice()了。splice()让我们可以从数组中的任意位置移除任意数量的连续的元素。 +splice()最多可以接受 3 个参数，但现在我们先关注前两个。splice()接收的前两个参数基于调用splice()数组中元素的索引。记住，数组的索引是从 0 开始的（zero-indexed），所以我们要用0来指示数组中的第一个元素。splice()的第一个参数代表从数组中的哪个索引开始移除元素，而第二个参数指示要从数组中删除多少个元素。例如： + +```js +let array = ['today', 'was', 'not', 'so', 'great']; + +array.splice(2, 2); +// 从第三个索引位置开始移除 2 个元素 +// array 现在是 ['today', 'was', 'great'] +``` + +splice()不仅从被调用的数组中移除元素，还会返回一个包含被移除元素的数组： + +```js +let array = ['I', 'am', 'feeling', 'really', 'happy']; + +let newArray = array.splice(3, 2); +// newArray 是 ['really', 'happy'] +``` + +
## Instructions -
我们定义了一个函数sumOfTen ，它将一个数组作为参数，并返回该数组元素的总和。使用splice()修改函数，使其返回值10 。
+
+ +给定初始化的数组 `arr`。使用 `splice()` 从 `arr` 里移除元素，使剩余的元素的和为 10。 + +
## Tests
```yml tests: - - text: sumOfTen应该返回10 - testString: 'assert.strictEqual(sumOfTen([2, 5, 1, 5, 2, 1]), 10, "sumOfTen should return 10");' - - text: sumOfTen函数应该使用splice()方法 - testString: 'assert.notStrictEqual(sumOfTen.toString().search(/\.splice\(/), -1, "The sumOfTen function should utilize the splice() method");' - + - text: 不应该修改这一行 const arr = [2, 4, 5, 1, 7, 5, 2, 1];。 + testString: assert(code.replace(/\s/g, '').match(/constarr=\[2,4,5,1,7,5,2,1\];?/)); + - text: arr 的剩余元素和应该为 10。 + testString: assert.strictEqual(arr.reduce((a, b) => a + b), 10); + - text: 应该利用 arr 的 splice()。 + testString: assert(code.replace(/\s/g, '').match(/arr\.splice\(/)); + - text: splice 应该只删除 arr 里面的元素，不能给 arr 添加元素。 + testString: assert(!code.replace(/\s/g, '').match(/arr\.splice\(\d+,\d+,\d+.*\)/g)); ```
@@ -32,16 +60,11 @@ tests:
```js -function sumOfTen(arr) { - // change code below this line - - // change code above this line - return arr.reduce((a, b) => a + b); -} - -// do not change code below this line -console.log(sumOfTen([2, 5, 1, 5, 2, 1])); +const arr = [2, 4, 5, 1, 7, 5, 2, 1]; +// only change code below this line +// only change code above this line +console.log(arr); ```
@@ -54,6 +77,8 @@ console.log(sumOfTen([2, 5, 1, 5, 2, 1]));
```js -// solution required +const arr = [2, 4, 5, 1, 7, 5, 2, 1]; +arr.splice(1, 4); ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.chinese.md index a78b6739c9..ab39be00d8 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-an-array-to-store-a-collection-of-data.chinese.md @@ -2,30 +2,69 @@ id: 587d7b7e367417b2b2512b20 title: Use an Array to Store a Collection of Data challengeType: 1 -videoUrl: '' +forumTopicId: 301167 localeTitle: 使用数组存储数据集合 --- ## Description -
以下是阵列数据结构最简单实现的示例。这被称为一维数组 ，意味着它只有一个级别，或者它没有嵌套在其中的任何其他数组。请注意，它包含布尔值 ， 字符串和数字 ，以及其他有效的JavaScript数据类型：
let simpleArray = ['one'，2，'three'，true，false，undefined，null];
的console.log（simpleArray.length）;
//记录7
所有数组都有一个length属性，如上所示，可以使用语法Array.length轻松访问Array.length 。下面可以看到更复杂的数组实现。这称为多维数组 ，或包含其他数组的数组。请注意，此数组还包含JavaScript 对象 ，我们将在下一节中详细介绍，但是现在，您需要知道的是，数组也能够存储复杂对象。
让complexArray = [
[
{
一：1，
二：2
}，
{
三：3，
四：4
}
]
[
{
a：“a”，
b：“b”
}，
{
c：“c”，
d：“d”
}
]
]。
+
+以下是数组（Array）数据结构的最简单的实现例子。这是一个一维数组（one-dimensional array），它只有一层，或者说在它里面没有包含其它的数组结构。可以看到它里面包含了布尔值（booleans）、字符串（strings）、数字（numbers）以及一些其他的 JavaScript 语言中合法的数据类型： + +```js +let simpleArray = ['one', 2, 'three', true, false, undefined, null]; +console.log(simpleArray.length); +// logs 7 +``` + +可以在上述例子中看到，所有数组都有一个长度（length）属性。可以简单地使用Array.length方法来访问它。 +下面是一个关于数组的更复杂的例子。这是一个多维数组（multi-dimensional Array），或者说是一个包含了其他数组的数组。可以注意到，在它的内部还包含了 JavaScript 中的对象（objects）结构。我们会在后面的小节中讨论该数据结构，但现在你只需要知道数组能够存储复杂的对象类型数据。 + +```js +let complexArray = [ + [ + { + one: 1, + two: 2 + }, + { + three: 3, + four: 4 + } + ], + [ + { + a: "a", + b: "b" + }, + { + c: "c", + d: "d" + } + ] +]; +``` + +
## Instructions -
我们定义了一个名为yourArray的变量。通过为yourArray变量指定长度至少为5个元素的数组来完成该语句。您的数组应至少包含一个字符串 ，一个数字和一个布尔值 。
+
+我们已经定义了一个名为yourArray的变量。请修改题目中的语句，将一个含有至少 5 个元素的数组赋值给yourArray变量。你的数组应该包含至少一个 string 类型的数据、一个 number 类型的数据和一个 boolean 类型的数据。 +
## Tests
```yml tests: - - text: yourArray是一个数组 + - text: yourArray 应该是一个数组。 testString: assert.strictEqual(Array.isArray(yourArray), true); - - text: yourArray至少有5个元素 + - text: yourArray至少要包含 5 个元素。 testString: assert.isAtLeast(yourArray.length, 5); - - text: yourArray至少包含一个boolean + - text: yourArray应该包含至少一个boolean。 testString: assert(yourArray.filter( el => typeof el === 'boolean').length >= 1); - - text: yourArray至少包含一个number + - text: yourArray应该包含至少一个number。 testString: assert(yourArray.filter( el => typeof el === 'number').length >= 1); - - text: yourArray至少包含一个string + - text: yourArray应该包含至少一个string。 testString: assert(yourArray.filter( el => typeof el === 'string').length >= 1); ``` @@ -39,7 +78,6 @@ tests: ```js let yourArray; // change this line - ``` @@ -52,6 +90,7 @@ let yourArray; // change this line
```js -// solution required +let yourArray = ['a string', 100, true, ['one', 2], 'another string']; ``` +
diff --git a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.chinese.md b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.chinese.md index afef6fd1f3..28448ae1ef 100644 --- a/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.chinese.md +++ b/curriculum/challenges/chinese/02-javascript-algorithms-and-data-structures/basic-data-structures/use-the-delete-keyword-to-remove-object-properties.chinese.md @@ -2,24 +2,35 @@ id: 587d7b7c367417b2b2512b1b title: Use the delete Keyword to Remove Object Properties challengeType: 1 -videoUrl: '' -localeTitle: 使用删除关键字删除对象属性 +forumTopicId: 301168 +localeTitle: 使用 delete 关键字删除对象属性 --- ## Description -
现在你知道了什么是对象及其基本特征和优点。简而言之，它们是键值存储，它提供了一种灵活，直观的数据结构方式， 并且它们提供了非常快速的查找时间。在其余的挑战中，我们将描述您可以对对象执行的几个常见操作，以便您可以轻松地在程序中应用这些有用的数据结构。在早期的挑战中，我们都添加并修改了对象的键值对。在这里，我们将看到如何从对象中删除键值对。让我们最后一次重新审视我们的foods对象示例。如果我们想删除apples键，我们可以使用delete关键字删除它，如下所示：
删除foods.apples;
+
+现在你已经知道什么是对象以及对象的基本特性和用途。总之，对象是以键值对的形式，灵活、直观地存储结构化数据的一种方式，并且查找对象属性的速度是很快的。在本章剩下的挑战中，我们会讲对象的几种常用操作，这样你能更好地在你的程序中使用这种有用的数据结构。 +在之前的挑战中，我们已经试过新增和修改对象中的键值对。现在我们来看如何从一个对象中移除一个键值对。 +我们再来看上一个挑战中的foods对象。如果我们想移除apples属性，我们可以使用delete关键字： + +```js +delete foods.apples; +``` + +
## Instructions -
使用delete关键字从foods对象中删除oranges ， plums和strawberries键。
+
+请你用 delete 关键字来移除foods中的oranges、plums和strawberries属性。 +
## Tests
```yml tests: - - text: foods对象只有三个键： apples ， grapes和bananas + - text: foods对象应该只含有 3 个键：apples、grapes和bananas。 testString: 'assert(!foods.hasOwnProperty(''oranges'') && !foods.hasOwnProperty(''plums'') && !foods.hasOwnProperty(''strawberries'') && Object.keys(foods).length === 3);' - - text: 使用delete oranges ， plums和strawberries键 + - text: 你应该用delete关键字来移除oranges、plums和strawberries属性。 testString: assert(code.search(/oranges:/) !== -1 && code.search(/plums:/) !== -1 && code.search(/strawberries:/) !== -1); ``` @@ -46,7 +57,6 @@ let foods = { // change code above this line console.log(foods); - ``` @@ -60,5 +70,20 @@ console.log(foods); ```js // solution required +let foods = { + apples: 25, + oranges: 32, + plums: 28, + bananas: 13, + grapes: 35, + strawberries: 27 +}; + +delete foods.oranges; +delete foods.plums; +delete foods.strawberries; + +console.log(foods); ``` +