Топ-11 (і більше!) функцій JavaScript, які потрібно знати

Код розумний! Станьте швидшим, продуктивнішим і щасливішим розробником JavaScript, опанувавши ці найважливіші та повторювані функції мови.

Незалежно від того, чи це бекенд, або інтерфейс (або навіть космічні кораблі), JavaScript є всюди. Це також досить гнучка мова (це означає, що вона має жорсткі шаблони функціонального програмування, а також старі добрі класи), а її схожість з іншими «С-подібними» мовами дозволяє розробникам легко переходити з інших мов.

Якщо хочеш підвищте рівень своєї гри JS, я пропоную вам вивчити, попрактикуватися та, зрештою, оволодіти наступними основними функціями, доступними в мові. Не всі з них суто «потрібні» для вирішення проблем, але в деяких випадках вони можуть зробити для вас багато важкої роботи, тоді як в інших вони можуть зменшити кількість коду, який вам потрібно написати.

map()

Було б єрессю писати статтю про важливі функції JavaScript і не згадувати map()! 😆😆 Разом з filter() і reduce(), map() утворює своєрідну святу трійцю. Ці функції ви будете використовувати знову і знову у своїй кар’єрі, тому вони більш ніж варті уваги. Давайте розберемося з ними по черзі, починаючи з map().

map() належить до тих функцій, які створюють найбільше проблем людям, які вивчають JavaScript. чому Не тому, що в цьому є щось складне, а тому, що спосіб роботи цієї функції є ідеєю, взятою з так званого функціонального програмування. І оскільки ми не знайомі з функціональним програмуванням — наші школи та галузь повні об’єктно-орієнтованих мов — робота здається дивною або навіть неправильною для нашого упередженого мозку.

JavaScript набагато функціональніший, ніж об’єктно-орієнтований, хоча його сучасні версії роблять усе можливе, щоб приховати цей факт. Але це ціла банка хробаків, яку я зможу відкрити, можливо, в інший день. 🤣 Гаразд, map() . . .

map() — дуже проста функція; він приєднується до масиву і допомагає нам перетворювати кожен елемент у щось інше, у результаті чого створюється новий масив. Як саме перетворити елемент, надається як інша функція, яка за домовленістю є анонімною.

Ось і все! До синтаксису може знадобитися трохи звикнути, але по суті це те, що ми робимо у функції map(). Чому ми можемо використовувати map()? Залежить від того, чого ми прагнемо досягти. Наприклад, скажімо, ми записали температуру для кожного дня останнього тижня та зберегли її як простий масив. Однак тепер нам кажуть, що прилади були не дуже точними і показали температуру на 1,5 градуси нижче, ніж повинні були.

Ми можемо зробити це виправлення за допомогою функції map() так:

const weeklyReadings = [20, 22, 20.5, 19, 21, 21.5, 23];

const correctedWeeklyReadings = weeklyReadings.map(reading => reading + 1.5);

console.log(correctedWeeklyReadings); // gives [ 21.5, 23.5, 22, 20.5, 22.5, 23, 24.5 ]

Інший, дуже практичний, приклад походить зі світу React, де створення списків елементів DOM із масивів є звичайним шаблоном; отже, щось на зразок цього є поширеним:

export default ({ products }) => {
    return products.map(product => {
        return (
            <div className="product" key={product.id}>
                <div className="p-name">{product.name}</div>
                <div className="p-desc">{product.description}</div>
            </div>
        );
    });
};

Тут ми маємо функціональний компонент React, який отримує список продуктів як свій проп. З цього списку (масиву) він будує список HTML «div», фактично перетворюючи кожен об’єкт продукту в HTML. Оригінальний предмет продукції залишається недоторканим.

Ви можете стверджувати, що map() — це не що інше, як прославлений цикл for, і ви будете абсолютно праві. Але зауважте, що як тільки ви висловлюєте цей аргумент, говорить ваш об’єктно-орієнтований навчений розум, тоді як ці функції та їх обґрунтування походять із функціонального програмування, де уніфікованість, компактність та елегантність дуже шануються. 🙂

фільтр()

filter() — дуже корисна функція, яку ви застосовуєте знову і знову в багатьох ситуаціях. Як випливає з назви, ця функція фільтрує масив на основі наданих вами правил/логіки та повертає новий масив, що містить елементи, які задовольняють ці правила.

Давайте повторно використаємо наш приклад погоди. Припустимо, що у нас є масив, що містить максимальні температури для кожного дня минулого тижня; тепер ми хочемо дізнатися, скільки з тих днів було холодніше. Так, «холодніше» — це суб’єктивний термін, тому, припустімо, ми шукаємо дні, коли температура була нижче 20. Ми можемо зробити це за допомогою функції filter() так:

const weeklyReadings = [20, 22, 20.5, 19, 21, 21.5, 23];

const colderDays = weeklyReadings.filter(dayTemperature => {
    return dayTemperature < 20;
});

console.log("Total colder days in week were: " + colderDays.length); // 1

Зауважте, що анонімна функція, яку ми передаємо до filter(), має повертати логічне значення: true або false. Ось як filter() дізнається, чи слід включати цей елемент у відфільтрований масив. Ви можете писати будь-яку складну логіку всередині цієї анонімної функції; ви можете здійснювати виклики API та читати введені користувачем дані тощо, доки ви переконаєтеся, що зрештою ви повертаєте логічне значення.

Обережно: це додаткова примітка, яку я відчуваю змушеним надати на основі свого досвіду розробника JavaScript. Незалежно від того, чи це через неохайність, чи через неправильні основи, багато програмістів створюють тонкі помилки у своїх програмах, використовуючи filter(). Давайте перепишемо попередній код, щоб усунути помилку:

const weeklyReadings = [20, 22, 20.5, 19, 21, 21.5, 23];

const colderDays = weeklyReadings.filter(dayTemperature => {
    return dayTemperature < 20;
});

if(colderDays) {
    console.log("Yes, there were colder days last week");
} else {
    console.log("No, there were no colder days");
}

Помітили щось? Чудова робота, якщо ви це зробили! Умова if до кінця перевіряє colderDays, який насправді є масивом! Ви здивуєтеся, скільки разів люди роблять цю помилку, намагаючись дотриматися дедлайнів або кодуючи код у поганому настрої (з будь-якої причини). Проблема з цією умовою полягає в тому, що JavaScript є дивною та непослідовною мовою в багатьох аспектах, і «правдивість» речей є одним із них. Поки [] == true повертає false, змушуючи вас думати, що наведений вище код не зламаний, реальність така, що всередині умови if, [] оцінює як правду! Іншими словами, написаний нами код ніколи не скаже, що минулого тижня не було холодніших днів.

Виправлення дуже просте, як зазначено в коді, що передує коду вище. Ми перевіряємо colderDays.length, який гарантовано дає нам ціле число (нуль або вище) і таким чином працює послідовно в логічних порівняннях. Зауважте, що filter() завжди, завжди, завжди повертатиме масив, порожній чи непорожній, тому ми можемо покладатися на це та впевнено писати наші логічні порівняння.

Це був довший шлях, ніж я планував, але такі помилки, як ця, варті того, щоб висвітлити їх десятьма тисячами слів, за потреби — великими. Сподіваюся, вас це не зачепило, і ви заощадите собі сотні годин налагодження! 🙂

зменшити()

З усіх функцій у цій статті, а також у стандартній бібліотеці JavaScript, reduce() є одним із лідерів на корони «заплутаних і дивних». Хоча ця функція дуже важлива й у багатьох ситуаціях призводить до елегантного коду, більшість розробників JavaScript уникають її й надають перевагу написанню більш докладного коду.

Причина в тому — і я буду чесним! — reduce() важко зрозуміти як у сенсі концепції, так і в сенсі виконання. Коли ви читаєте його опис, ви перечитували його кілька разів і все одно сумніваєтеся, чи не прочитали ви його неправильно; і коли ви бачите це в дії та намагаєтесь уявити, як це працює, ваш мозок закручується на тисячу вузлів! 🤭

Тепер не лякайтеся. Функція reduce() не наближається за складністю та залякуванням до, скажімо, B+ Дерева та їх алгоритми. Просто така логіка рідко зустрічається під час повсякденної роботи середнього програміста.

Тож, налякавши вас до смерті, а потім одразу сказавши не хвилюватися, я нарешті хотів би показати вам, що це за функція та для чого саме вона нам може знадобитися.

Як випливає з назви, reduce() використовується для, ну, зменшення чогось. Те, що він скорочує, є масивом, а те, до чого він зменшує заданий масив, — це одне значення (число, рядок, функція, об’єкт тощо). Ось простіше сказати — reduce() перетворює масив на одне значення. Зауважте, що значення, яке повертається від reduce(), не є масивом, як у випадку з map() і filter(). Зрозуміти це – це вже півсправи. 🙂

Тепер очевидно, що якщо ми збираємося трансформувати (зменшити) масив, нам потрібно забезпечити необхідну логіку; і, виходячи з вашого досвіду розробника JS, ви вже здогадалися, що ми робимо це за допомогою функції. Цю функцію ми називаємо функцією редуктора, яка формує перший аргумент для reduce(). Другим аргументом є початкове значення, наприклад число, рядок тощо (незабаром я поясню, що таке «початкове значення»).

Виходячи з нашого розуміння на даний момент, ми можемо сказати, що виклик reduce() виглядає так: array.reduce(reducerFunction, initialValue). Тепер давайте розберемося з суть усієї справи: функція редуктора. Як уже було встановлено, функція-редусер – це те, що повідомляє reduce(), як перетворити масив в одне значення. Для цього потрібні два аргументи: змінна, яка виконує функцію накопичувача (не хвилюйтеся, я також поясню це), і змінна, яка зберігає поточне значення.

Я знаю, я знаю . . . це було багато термінології для однієї функції, яка навіть не є обов’язковою в JavaScript. 😝😝 І ось чому люди тікають від reduce(). Але якщо ви навчитеся цьому крок за кроком, ви не тільки зрозумієте це, але й оціните це, коли станете кращим розробником.

Гаразд, повернемося до поточної теми. «Початкове значення», яке передається в reduce(), є . . . Ну, початкове значення для обчислення, яке ви хочете використовувати. Наприклад, якщо ви збираєтеся виконувати множення у функції скорочення, початкове значення 1 має сенс; для додавання ви можете почати з 0 і так далі.

Тепер давайте подивимося на сигнатуру функції редуктора. Функція-редусер, яка передається в reduce(), має таку форму: reducerFunction(accumulator, currentValue). «Акумулятор» — це лише химерна назва змінної, яка збирає та зберігає результат обчислення; це точно так само, як використання змінної під назвою total для підсумовування всіх елементів у масиві за допомогою щось на зразок total += arr[i]. Саме так використовується функція редукції в reduce(): спочатку для накопичувача встановлюється початкове значення, яке ви надаєте, а потім один за одним відвідуються елементи в масиві, виконується обчислення, а результат зберігається в акумулятор і так далі. . .

Отже, що це за «поточне значення» у функції редуктора? Це та сама ідея, яку ви могли б уявити собі подумки, якби я попросив вас пройти по масиву: ви візьмете змінну, починаючи з нульового індексу, і перемістіть її вперед на крок за раз. Поки ви це робите, якщо я попрошу вас раптом зупинитися, ви опинитесь на одному з елементів масиву, правда? Ось що ми маємо на увазі під поточним значенням: це значення змінної, яка використовується для представлення елемента масиву, який зараз розглядається (подумайте про цикл над масивом, якщо це допоможе).

З огляду на все сказане, настав час переглянути простий приклад і побачити, як увесь цей жаргон поєднується у справжньому виклику reduce(). Скажімо, у нас є масив, що містить перші n натуральних чисел (1, 2, 3… n), і ми зацікавлені в тому, щоб знайти факторіал n. Ми знаємо, що знайти n! нам просто потрібно все помножити, що приведе нас до цієї реалізації:

const numbers = [1, 2, 3, 4, 5];
const factorial = numbers.reduce((acc, item) => acc * item, 1);
console.log(factorial); // 120

Багато чого відбувається в цих трьох рядках коду, тому давайте розпакуємо це по черзі в контексті (дуже довгої) дискусії, яку ми мали досі. Як очевидно, числа — це масив, який містить усі числа, які ми хочемо помножити. Далі подивіться на виклик numbers.reduce(), який говорить, що початкове значення для acc має бути 1 (оскільки воно не впливає на множення та не руйнує його). Далі перевірте тіло функції скорочення, `(acc, item) => acc * item, яке просто говорить, що значенням, що повертається для кожної ітерації в масиві, має бути цей елемент, помножений на те, що вже є в акумуляторі. Ітерація та фактичне збереження множення в явному вигляді в накопичувачі — це те, що відбувається за лаштунками, і це одна з головних причин, чому reduce() є таким каменем спотикання для розробників JavaScript.

Навіщо використовувати reduce()?

Це справді чудове запитання, і, чесно кажучи, я не маю однозначної відповіді. Усе, що робить reduce(), можна виконати за допомогою циклів, forEach() тощо. Однак ці прийоми призводять до набагато більшого коду, що ускладнює його читання, особливо якщо ви поспішаєте. Крім того, існує проблема незмінності: за допомогою reduce() і подібних функцій ви можете бути впевнені, що ваші вихідні дані не змінені; це саме по собі усуває цілі класи помилок, особливо в розподілених програмах.

Нарешті, reduce() набагато гнучкіший у тому сенсі, що накопичувач може бути об’єктом, масивом або навіть функцією, якщо потрібно; те ж саме стосується початкового значення та інших частин виклику функції — майже будь-що може ввійти, і майже все може вийти, тому існує надзвичайна гнучкість у розробці багаторазового коду.

Якщо ви все ще не переконані, це також цілком нормально; сама спільнота JavaScript різко розділилася щодо «компактності», «елегантності» та «потужності» reduce(), тому нічого страшного, якщо ви ним не користуєтеся. 🙂 Але обов’язково подивіться на деякі гарні приклади перш ніж ви вирішите bin reduce().

деякі()

Припустімо, у вас є масив об’єктів, кожен з яких представляє людину. Ви хочете знати, чи є в масиві люди віком понад 35 років. Зауважте, що немає необхідності рахувати, скільки таких людей, не кажучи вже про те, щоб отримати їх список. Те, що ми тут говоримо, є еквівалентом «одного чи кількох» або «принаймні одного».

Як ви це робите?

Так, ви можете створити змінну прапора та виконати цикл по масиву, щоб вирішити цю проблему так:

const persons = [
    {
        name: 'Person 1',
        age: 32
    },
    
    {
        name: 'Person 2',
        age: 40
    },
];

let foundOver35 = false;

for (let i = 0; i < persons.length; i ++) {
    if(persons[i].age > 35) {
        foundOver35 = true;
        break;
    }
}

if(foundOver35) {
    console.log("Yup, there are a few people here!")
}

Проблема? На мою думку, код занадто схожий на C або Java. «Багатослівний» — ще одне слово, яке спадає на думку. Досвідчений JS може подумати про «потворний», «жахливий» тощо. 😝 Я б стверджував, що це правильно. Один із способів удосконалити цей фрагмент коду — використати щось на кшталт map(), але навіть у цьому випадку рішення буде трохи незграбним.

Виявляється, ми маємо досить гарну функцію під назвою some(), яка вже доступна в базовій мові. Ця функція обробляє масиви та приймає спеціальну функцію «фільтрування», повертаючи логічне значення true або false. По суті, це робить те, що ми намагалися зробити протягом останніх кількох хвилин, тільки дуже лаконічно та елегантно. Ось як ми можемо ним скористатися:

const persons = [
    {
        name: 'Person 1',
        age: 32
    },
    
    {
        name: 'Person 2',
        age: 40
    },
];

if(persons.some(person => {
    return person.age > 35
})) {
    console.log("Found some people!")
}

Те саме введення, той же результат, що й раніше; але зверніть увагу на значне скорочення коду! Зверніть також увагу на те, як різко зменшується когнітивне навантаження, оскільки нам більше не потрібно розбирати код рядок за рядком, ніби ми самі були інтерпретатором! Тепер код читається майже як природна мова.

кожен()

Подібно до some(), ми маємо ще одну корисну функцію під назвою every(). Як ви можете вже здогадатися, це також повертає логічне значення залежно від того, чи всі елементи в масиві пройшли заданий тест. Звичайно, тест, який потрібно пройти, найчастіше надається як анонімна функція. Я позбуду вас болю від того, як може виглядати наївна версія коду, тому ось як використовується every():

const entries = [
    {
        id: 1
    },
    
    {
        id: 2
    },
    
    {
        id: 3  
    },
];

if(entries.every(entry => {
    return Number.isInteger(entry.id) && entry.id > 0;
})) {
    console.log("All the entries have a valid id")
}

Як очевидно, код перевіряє всі об’єкти в масиві на дійсну властивість ідентифікатора. Визначення «дійсного» залежить від контексту проблеми, але, як бачите, для цього коду я розглядав невід’ємні цілі числа. Знову ми бачимо, наскільки простим і елегантним є код для читання, що є єдиною метою цієї (і подібних) функцій.

включає()

Як перевірити наявність підрядків і елементів масиву? Що ж, якщо ви схожі на мене, ви швидко беретеся до indexOf(), а потім шукаєте документи, щоб дізнатися про можливі значення, що повертаються. Це значна незручність, і значення, що повертаються, важко запам’ятати (швидко — що означає процес, який повертає 2 в операційну систему?).

Але є гарна альтернатива, якою ми можемо скористатися: include(). Використання таке ж просте, як і назва, а отриманий код надзвичайно зворушливий. Майте на увазі, що зіставлення здійснюється за допомогою include() чутливого до регістру, але я думаю, що це те, що ми всі інтуїтивно очікуємо в будь-якому випадку. А тепер час для коду!

const numbers = [1, 2, 3, 4, 5];
console.log(numbers.includes(4));
const name = "Ankush";
console.log(name.includes('ank')); // false, because first letter is in small caps
console.log(name.includes('Ank')); // true, as expected

Однак не чекайте занадто багато від цього скромного методу:

const user = {a: 10, b: 20};
console.log(user.includes('a')); // blows up, as objects don't have a "includes" method

Він не може переглядати об’єкти, оскільки це просто не визначено для об’єктів. Але привіт, ми знаємо, що це працює з масивами, тому, можливо, ми можемо вдатися до деяких трюків тут. . . 🤔.

const persons = [{name: 'Phil'}, {name: 'Jane'}];
persons.includes({name: 'Phil'});

Отже, що відбувається, коли ви запускаєте цей код? Він не вибухає, але результат також розчаровує: false. 😫😫 Насправді це пов’язано з об’єктами, покажчиками та тим, як JavaScript бачить і керує пам’яттю, що є окремим світом. Якщо ви хочете зануритися глибше, сміливо зробіть крок (можливо, почніть тут), але я тут зупинюся.

Ми можемо змусити наведений вище код поводитися, якщо ми перепишемо його таким чином, але на цьому етапі, на мій погляд, це більш-менш стає жартом:

const phil = {name: 'Phil'};
const persons = [phil, {name: 'Jane'}];
persons.includes(phil); // true

Тим не менш, це показує, що ми можемо змусити include() працювати над об’єктами, тому я думаю, що це не повна катастрофа. 😄

шматочок()

Припустімо, у нас є рядок, і я прошу вас повернути його частину, яка починається на «r» і закінчується на «z» (справжні символи не важливі). Як би ви до цього підійшли? Можливо, ви створите новий рядок і використаєте його для збереження всіх необхідних символів і повернення їх. Або, якщо ви схожі на більшість програмістів, ви б дали мені два індекси масиву натомість: один вказує на початок підрядка, інший позначає кінець.

Обидва ці підходи чудові, але існує концепція, яка називається нарізкою, яка пропонує гарне рішення в таких ситуаціях. На щастя, немає ніякої незрозумілої теорії, якій слід слідувати; нарізка означає саме те, що це звучить — створення меншого рядка/масиву з заданого, подібно до того, як ми створюємо шматочки фруктів. Давайте подивимося, що я маю на увазі, за допомогою простого прикладу:

const headline = "And in tonight's special, the guest we've all been waiting for!";
const startIndex = headline.indexOf('guest');
const endIndex = headline.indexOf('waiting');
const newHeadline = headline.slice(startIndex, endIndex);
console.log(newHeadline); // guest we've all been

Коли ми використовуємо slice(), ми надаємо два індекси для JavaScript — один, з якого ми хочемо почати нарізку, і інший, де ми хочемо, щоб вона зупинилася. Заковика slice() полягає в тому, що кінцевий індекс не включається в кінцевий результат, тому ми бачимо, що слово «очікування» відсутнє в новому заголовку коду вище.

Такі поняття, як нарізка, є більш помітними в інших мовах, зокрема Python. Якщо ви запитаєте цих розробників, вони скажуть, що не можуть уявити життя без цієї функціональності, і це правильно, оскільки мова забезпечує дуже чіткий синтаксис для нарізки.

Нарізка акуратна і надзвичайно зручна, і немає причин не використовувати її. Це також не синтаксичний цукор, пронизаний погіршенням продуктивності, оскільки він створює поверхневі копії оригінального масиву/рядка. Розробникам JavaScript я настійно рекомендую ознайомитися з slice() і додати його до свого арсеналу!

зрощення ()

Метод splice() звучить як двоюрідний брат slice(), і в деякому сенсі ми можемо стверджувати, що це так. Обидва створюють нові масиви/рядки з оригінальних, з однією невеликою, але важливою відмінністю — splice() видаляє, змінює або додає елементи, але змінює вихідний масив. Це «знищення» оригінального масиву може створити величезні проблеми, якщо ви не будете обережні або не розумієте глибокі копії та посилання. Цікаво, що заважало розробникам використати той самий підхід, що й для slice(), і залишити вихідний масив недоторканим, але я думаю, що ми можемо бути більш поблажливими до мови створені всього за десять днів.

Незважаючи на мої скарги, давайте подивимося, як працює splice(). Я покажу приклад, коли ми видаляємо кілька елементів із масиву, оскільки це найпоширеніше використання цього методу. Я також утримаюся від наведення прикладів додавання та вставлення, тому що їх можна легко знайти, і вони також прості.

const items = ['eggs', 'milk', 'cheese', 'bread', 'butter'];
items.splice(2, 1);
console.log(items); // [ 'eggs', 'milk', 'bread', 'butter' ]

Виклик splice() вище каже: почніть з індексу 2 (тобто третього місця) масиву та видаліть один елемент. У заданому масиві «сир» є третім елементом, тому його буде видалено з масиву, а масив елементів скорочується, як і очікувалося. До речі, видалені елементи повертаються splice() у формі або масиві, тому, якби ми хотіли, ми могли б захопити «сир» у змінній.

З мого досвіду, indexOf() і splice() мають чудову синергію — ми знаходимо індекс елемента, а потім видаляємо його з заданого масиву. Однак зауважте, що це не завжди найефективніший метод, і часто використання ключів об’єкта (еквівалента хеш-карти) набагато швидше.

shift()

shift() — це зручний метод сортування, який використовується для видалення першого елемента масиву. Зауважте, що те ж саме можна зробити за допомогою splice(), але shift() трохи легше запам’ятати та інтуїтивно зрозумілий, коли все, що вам потрібно зробити, це відрізати перший елемент.

const items = ['eggs', 'milk', 'cheese', 'bread', 'butter'];
items.shift()
console.log(items); // [ 'milk', 'cheese', 'bread', 'butter' ]

unshift()

Подібно до того, як shift() видаляє перший елемент із масиву, unshift() додає новий елемент на початку масиву. Його використання настільки ж просте і компактне:

const items = ['eggs', 'milk'];
items.unshift('bread')
console.log(items); // [ 'bread', 'eggs', 'milk' ]

Тим не менш, я не можу допомогти собі і попереджаю новачків: на відміну від популярних методів push() і pop(), shift() і unshift() надзвичайно неефективні (через те, як працюють основні алгоритми). Отже, якщо ви працюєте з великими масивами (скажімо, понад 2000 елементів), занадто багато викликів цих функцій можуть зупинити вашу програму.

fill()

Іноді потрібно змінити кілька елементів на одне значення або навіть «скинути» весь масив, так би мовити. У таких ситуаціях fill() позбавляє вас від зациклювань і одноразових помилок. Його можна використовувати для заміни частини або всього масиву заданим значенням. Давайте розглянемо кілька прикладів:

const heights = [1, 2, 4, 5, 6, 7, 1, 1];
heights.fill(0);
console.log(heights); // [0, 0, 0, 0, 0, 0, 0, 0]

const heights2 = [1, 2, 4, 5, 6, 7, 1, 1];
heights2.fill(0, 4);
console.log(heights2); // [1, 2, 4, 5, 0, 0, 0, 0]

Інші функції, про які варто згадати

Хоча наведений вище список є тим, з чим стикаються більшість розробників JavaScript і використовують їх у своїй кар’єрі, він аж ніяк не повний. У JavaScript є стільки інших незначних, але корисних функцій (методів), що їх неможливо охопити в одній статті. Тим не менш, деякі, які спадають на думку, такі:

• зворотний()
• sort()
• записи ()
• fill()
• знайти()
• квартира()

Я закликаю вас принаймні переглянути їх, щоб мати певне уявлення про існування таких зручностей.

Висновок

JavaScript — це велика мова, незважаючи на невелику кількість основних концепцій, які потрібно вивчити. Багато доступних нам функцій (методів) складають основну частину цього великого розміру. Однак, оскільки JavaScript є другорядною мовою для більшості розробників, ми не занурюємося достатньо глибоко, пропускаючи багато гарних і корисних функцій, які він пропонує. Насправді, те саме стосується концепцій функціонального програмування, але це тема іншого дня! 😅

Щоразу, коли ви можете, приділіть деякий час дослідженню основної мови (і, якщо можливо, відомих бібліотек утиліт, таких як Лодаш). Навіть кілька хвилин, витрачених на ці зусилля, призведуть до значного підвищення продуктивності та набагато чистішого та компактнішого коду.