diff --git a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md index 27a7b418a..4bca28053 100644 --- a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md +++ b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/solution.md @@ -10,19 +10,19 @@ function sumSalaries(salaries) { } let salaries = { - "John": 100, - "Pete": 300, - "Mary": 250 + "Іван": 100, + "Петро": 300, + "Марія": 250 }; alert( sumSalaries(salaries) ); // 650 ``` -Or, optionally, we could also get the sum using `Object.values` and `reduce`: +Або ж ми можемо також отримати суму, використовуючи `Object.values` та `reduce`: ```js -// reduce loops over array of salaries, -// adding them up -// and returns the result +// reduce перебирає масив значень salaries, +// складає їх +// і повертає результат function sumSalaries(salaries) { return Object.values(salaries).reduce((a, b) => a + b, 0) // 650 } diff --git a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md index 211357d03..2ce08b4c7 100644 --- a/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md +++ b/1-js/05-data-types/09-keys-values-entries/01-sum-salaries/task.md @@ -2,21 +2,21 @@ importance: 5 --- -# Sum the properties +# Підсумуйте властивості -There is a `salaries` object with arbitrary number of salaries. +Є об’єкт `salaries` з довільною кількістю властивостей, що містять заробітні плати. -Write the function `sumSalaries(salaries)` that returns the sum of all salaries using `Object.values` and the `for..of` loop. +Напишіть функцію `sumSalaries(salaries)`, що повертає суму всіх зарплат за допомогою `Object.values` та циклу`for..of`. -If `salaries` is empty, then the result must be `0`. +Якщо об’єкт `salaries` порожній, тоді результат повинен бути `0`. -For instance: +Наприклад: ```js let salaries = { - "John": 100, - "Pete": 300, - "Mary": 250 + "Іван": 100, + "Петро": 300, + "Марія": 250 }; alert( sumSalaries(salaries) ); // 650 diff --git a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md index d7aebb1fa..fbf811df4 100644 --- a/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md +++ b/1-js/05-data-types/09-keys-values-entries/02-count-properties/task.md @@ -2,20 +2,19 @@ importance: 5 --- -# Count properties +# Порахуйте властивості -Write a function `count(obj)` that returns the number of properties in the object: +Напишіть функцію `count(obj)`, що повертає кількість властивостей об’єкта: ```js let user = { - name: 'John', + name: 'Іван', age: 30 }; alert( count(user) ); // 2 ``` -Try to make the code as short as possible. - -P.S. Ignore symbolic properties, count only "regular" ones. +Намагайтеся зробити код якомога коротшим. +P.S. Ігноруйте символьні властивості, враховуйте лише “звичайні”. diff --git a/1-js/05-data-types/09-keys-values-entries/article.md b/1-js/05-data-types/09-keys-values-entries/article.md index 28c48a533..7712635a5 100644 --- a/1-js/05-data-types/09-keys-values-entries/article.md +++ b/1-js/05-data-types/09-keys-values-entries/article.md @@ -1,86 +1,86 @@ # Object.keys, values, entries -Let's step away from the individual data structures and talk about the iterations over them. +Відійдемо від окремих структур даних і поговоримо про ітерації над ними. -In the previous chapter we saw methods `map.keys()`, `map.values()`, `map.entries()`. +У минулому розділі ми бачили методи `map.keys()`, `map.values()`, `map.entries()`. -These methods are generic, there is a common agreement to use them for data structures. If we ever create a data structure of our own, we should implement them too. +Ці методи є загальними, існує спільна згода використовувати їх для структур даних. Якщо ми створюватимемо власну структуру даних, нам слід їх також реалізувати. -They are supported for: +Вони підтримуються для: - `Map` - `Set` - `Array` -Plain objects also support similar methods, but the syntax is a bit different. +Звичайні об’єкти також підтримують подібні методи, але синтаксис дещо інший. ## Object.keys, values, entries -For plain objects, the following methods are available: +Для простих об’єктів доступні наступні методи: -- [Object.keys(obj)](mdn:js/Object/keys) -- returns an array of keys. -- [Object.values(obj)](mdn:js/Object/values) -- returns an array of values. -- [Object.entries(obj)](mdn:js/Object/entries) -- returns an array of `[key, value]` pairs. +- [Object.keys(obj)](mdn:js/Object/keys) -- повертає масив ключів. +- [Object.values(obj)](mdn:js/Object/values) -- повертає масив значень. +- [Object.entries(obj)](mdn:js/Object/entries) -- повертає масив пар `[ключ, значення]`. -Please note the distinctions (compared to map for example): +Зверніть увагу на відмінності (порівняно з map, наприклад): | | Map | Object | |-------------|------------------|--------------| -| Call syntax | `map.keys()` | `Object.keys(obj)`, but not `obj.keys()` | -| Returns | iterable | "real" Array | +| Синтаксис виклику | `map.keys()` | `Object.keys(obj)`, а не `obj.keys()` | +| Повертає | ітерабельний | "реальний" масив | -The first difference is that we have to call `Object.keys(obj)`, and not `obj.keys()`. +Перша відмінність полягає в тому, що ми повинні викликати `Object.keys(obj)`, а не `obj.keys()`. -Why so? The main reason is flexibility. Remember, objects are a base of all complex structures in JavaScript. So we may have an object of our own like `data` that implements its own `data.values()` method. And we still can call `Object.values(data)` on it. +Чому так? Основною причиною цього є гнучкість. Пам’ятайте, об’єкти є базою всіх складних структур у JavaScript. Ми можемо мати власний об’єкт, такий як `data`, який реалізує власний метод `data.values()`. І ми все ще можемо застосовувати до нього `Object.values(data)`. -The second difference is that `Object.*` methods return "real" array objects, not just an iterable. That's mainly for historical reasons. +Друга відмінність полягає в тому, що `Object.*` методи повертають "реальний" масив об’єктів, а не просто ітерабельний. Це переважно з історичних причин. -For instance: +Наприклад: ```js let user = { - name: "John", + name: "Іван", age: 30 }; ``` - `Object.keys(user) = ["name", "age"]` -- `Object.values(user) = ["John", 30]` -- `Object.entries(user) = [ ["name","John"], ["age",30] ]` +- `Object.values(user) = ["Іван", 30]` +- `Object.entries(user) = [ ["name","Іван"], ["age",30] ]` -Here's an example of using `Object.values` to loop over property values: +Це приклад використання `Object.values` для перебору значень властивостей у циклі: ```js run let user = { - name: "John", + name: "Іван", age: 30 }; -// loop over values +// Перебираємо значення for (let value of Object.values(user)) { - alert(value); // John, then 30 + alert(value); // Іван, тоді 30 } ``` -```warn header="Object.keys/values/entries ignore symbolic properties" -Just like a `for..in` loop, these methods ignore properties that use `Symbol(...)` as keys. +```warn header="Object.keys/values/entries ігнорують символьні властивості" +Як і цикл `for..in`, ці методи ігнорують властивості, що використовують `Symbol(...)` як ключі. -Usually that's convenient. But if we want symbolic keys too, then there's a separate method [Object.getOwnPropertySymbols](mdn:js/Object/getOwnPropertySymbols) that returns an array of only symbolic keys. Also, there exist a method [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) that returns *all* keys. +Зазвичай це зручно. Якщо ми хочемо враховувати символьні ключі також, то для цього існує окремий метод [Object.getOwnPropertySymbols](mdn:js/Object/getOwnPropertySymbols), що повертає масив лише символьних ключів. Також існує метод [Reflect.ownKeys(obj)](mdn:js/Reflect/ownKeys) , що повертає *усі* ключі. ``` -## Transforming objects +## Трансформація об’єктів -Objects lack many methods that exist for arrays, e.g. `map`, `filter` and others. +У об’єктів немає багатьох методів, які є у масивів, наприклад `map`, `filter` та інші. -If we'd like to apply them, then we can use `Object.entries` followed by `Object.fromEntries`: +Якщо б ми хотіли їх застосувати, тоді б ми використовували `Object.entries` з подальшим викликом `Object.fromEntries`: -1. Use `Object.entries(obj)` to get an array of key/value pairs from `obj`. -2. Use array methods on that array, e.g. `map`. -3. Use `Object.fromEntries(array)` on the resulting array to turn it back into an object. +1. Викликаємо `Object.entries(obj)`, щоб отримати масив пар ключ/значення з `obj`. +2. На ньому використовуємо методи масиву, наприклад `map`. +3. Використаємо `Object.fromEntries(array)` на отриманому масиві, щоб перетворити його знову на об’єкт. -For example, we have an object with prices, and would like to double them: +Наприклад, у нас є об’єкт з цінами, і ми б хотіли їх подвоїти: ```js run let prices = { @@ -91,7 +91,7 @@ let prices = { *!* let doublePrices = Object.fromEntries( - // convert to array, map, and then fromEntries gives back the object + // перетворити на масив, потім застосувати map, а потім fromEntries повертає об’єкт Object.entries(prices).map(([key, value]) => [key, value * 2]) ); */!* @@ -99,4 +99,4 @@ let doublePrices = Object.fromEntries( alert(doublePrices.meat); // 8 ``` -It may look difficult at first sight, but becomes easy to understand after you use it once or twice. We can make powerful chains of transforms this way. +З першого погляду це може здатися важким, але стане зрозумілим після того, як ви використаєте це декілька разів. Таким чином ми можемо створювати потужні ланцюги перетворень. \ No newline at end of file