Архив Тега для: JavaScript

JavaScript мемоизация: Секрет оптимизации производительности и эффективности кода - theVolkov

В мире веб-разработки оптимизация производительности является ключевым аспектом, который позволяет сделать веб-приложения более быстрыми и отзывчивыми. Одной из эффективных техник оптимизации является мемоизация. В данной статье мы рассмотрим, что такое мемоизация, как она работает и как можно использовать эту технику в JavaScript.

Оглавление

  1. Что такое мемоизация?
  2. Преимущества мемоизации для производительности
  3. Примеры мемоизации в JavaScript
  4. Заключение

Мемоизация в JavaScript — ключ к быстрому решению задач, когда каждая миллисекунда имеет значение 💾

Что такое мемоизация?

Мемоизация — это техника оптимизации, которая заключается в сохранении результатов выполнения функций для определенных входных данных, чтобы избежать повторных вычислений при последующих вызовах функции с теми же аргументами.

Примеры мемоизации в JavaScript

Пример 1: Простая мемоизация с использованием объекта:

const memoizedFunction = (function () {
  const cache = {};

  return (n) => {
    if (cache[n]) {
      console.log('Fetching from cache');
      return cache[n];
    } else {
      console.log('Calculating result');
      cache[n] = n * 2;
      return cache[n];
    }
  };
})();

console.log(memoizedFunction(5)); // Вычисление и кэширование
console.log(memoizedFunction(5)); // Загрузка из кэша

Пример 2: Мемоизация с помощью рекурсии и кэша:

function fibonacci(n, cache = {}) {
  if (cache[n]) {
    return cache[n];
  }

  if (n <= 1) {
    return n;
  }

  cache[n] = fibonacci(n - 1, cache) + fibonacci(n - 2, cache);
  return cache[n];
}

console.log(fibonacci(10)); // Вычисление и кэширование
console.log(fibonacci(10)); // Загрузка из кэша

Мемоизация с использованием библиотеки lodash.memoize:

const memoizedExpensiveFunction = _.memoize((x) => {
  console.log('Calculating result');
  return x * x;
});

console.log(memoizedExpensiveFunction(5)); // Вычисление и кэширование
console.log(memoizedExpensiveFunction(5)); // Загрузка из кэша

Заключение

Мемоизация — мощная техника оптимизации, которая позволяет сократить время выполнения функций и снизить нагрузку на процессор. Путем кэширования результатов для определенных входных данных мемоизация способствует улучшению отзывчивости веб-приложений. Попробуйте использовать мемоизацию в ваших проектах, чтобы добиться оптимальной производительности!

Типы данных в JavaScript: Полное Руководство для Разработчиков - theVolkov

JavaScript — это один из самых популярных языков программирования, который используется для создания интерактивных веб-страниц. Понимание типов данных в JavaScript — это ключевой аспект для любого разработчика. Эта статья представляет полное руководство по типам данных в JavaScript, чтобы помочь вам стать более уверенным программистом.

Примитивные типы данных

Примитивные типы данных в JavaScript являются неизменными и включают в себя:

Число (Number)

JavaScript использует один тип данных для всех чисел, независимо от того, являются ли они целыми или десятичными.

let x = 34; // Целое число
let y = 34.00; // Десятичное число

Строка (String)

Строки используются для хранения текста и заключаются в кавычки.

let name = "Иван";

Логический тип (Boolean)

Этот тип данных принимает только два значения: true и false.

let isActive = true;

Null и Undefined

Null используется для обозначения отсутствующего значения, а undefined указывает, что переменная была объявлена, но не определена.

let empty = null;
let notDefined; // undefined

BigInt и Symbol

BigInt используется для работы с большими целыми числами. Symbol — это уникальный и неизменяемый тип данных.

let largeNumber = 1234567890123456789012345678901234567890n;
const uniqueSymbol = Symbol("description");

Объекты

В отличие от примитивных типов, объекты являются изменяемыми и могут хранить различные типы данных.

let person = {
  name: "Иван",
  age: 30
};

Специальные значения

JavaScript также имеет несколько специальных значений, таких как NaN (Not a Number) и Infinity.

console.log(0/0); // NaN
console.log(1/0); // Infinity

Заключение

Понимание типов данных в JavaScript является ключевым элементом для эффективного программирования. От примитивных типов, таких как числа и строки, до более сложных, таких как объекты и специальные значения — знание этих основ поможет вам стать более умелым разработчиком.

Дополнительные ресурсы:

Методы перебора массивов в JavaScript: Руководство с примерами - theVolkov

При работе с массивами в JavaScript чрезвычайно важно уметь эффективно перебирать и обрабатывать элементы. В данной статье мы рассмотрим разнообразные методы перебора массивов с подробными примерами и комментариями, а также объясним, какие методы возвращают новый массив, а какие — модифицируют исходный.

Навигация

  1. Метод forEach
  2. Метод map
  3. Метод filter
  4. Метод find
  5. Метод every
  6. Метод some
  7. Метод reduce

Метод .forEach()

Метод forEach позволяет выполнять указанную функцию для каждого элемента массива. Он не возвращает новый массив, а просто применяет функцию к каждому элементу.

const emojis = ["🌞", "🌈", "🌼", "🍀"];
emojis.forEach((emoji, index) => {
  console.log(`Эмодзи ${emoji} на позиции ${index + 1}`);
});
// Результат:
// Эмодзи 🌞 на позиции 1
// Эмодзи 🌈 на позиции 2
// Эмодзи 🌼 на позиции 3
// Эмодзи 🍀 на позиции 4

Метод .map()

Метод map создает новый массив, содержащий результаты вызова указанной функции для каждого элемента исходного массива.

const weatherEmojis = ["☀️", "🌦️", "🌧️", "❄️"];
const modifiedWeather = weatherEmojis.map(emoji => emoji + "🌍");
// modifiedWeather содержит ["☀️🌍", "🌦️🌍", "🌧️🌍", "❄️🌍"]

Метод .filter()

Метод filter создает новый массив, содержащий все элементы, для которых функция возвращает true.

const flowerEmojis = ["🌸", "🌺", "🌼", "🌻"];
const smallFlowers = flowerEmojis.filter(emoji => emoji !== "🌼");
// smallFlowers содержит ["🌸", "🌺", "🌻"]

Метод .find()

Метод find возвращает первый элемент массива, для которого функция вернула true. Если такой элемент не найден, возвращается undefined.

const fruitEmojis = ["🍎", "🍊", "🍇", "🍌"];
const orangeEmoji = fruitEmojis.find(emoji => emoji === "🍊");
const ballEmoji = fruitEmojis.find(emoji => emoji === "🥎");
// orangeEmoji содержит "🍊"

Метод .every()

Метод every проверяет, удовлетворяют ли все элементы массива условию, заданному функцией. Возвращает true, если все элементы соответствуют условию, иначе — false.

const happyEmojis = ["😄", "😃", "😁", "😆"];
const allHappy = happyEmojis.every(emoji => emoji === "😄");
// allHappy содержит true

Метод .some()

Метод some проверяет, удовлетворяет ли хотя бы один элемент массива условию, заданному функцией. Возвращает true, если хотя бы один элемент соответствует условию.

const animalEmojis = ["🐶", "🐱", "🐰", "🐻"];
const hasCat = animalEmojis.some(emoji => emoji === "🐱");
// hasCat содержит true

Метод .reduce()

Метод reduce выполняет функцию для каждого элемента массива, накапливая результаты в одно значение. Возвращает аккумулированное значение.

const foodEmojis = ["🍔", "🍕", "🍟", "🌮"];
const combinedFood = foodEmojis.reduce((acc, emoji) => acc + emoji, "🍽️");
// combinedFood содержит "🍽️🍔🍕🍟🌮"

Заключение

В данной статье мы рассмотрели основные методы перебора массивов в JavaScrip с примерами. Каждый метод имеет свои особенности и применение, позволяя эффективно обрабатывать и анализировать данные. Ознакомившись с этими методами, вы сможете с легкостью манипулировать массивами в своих проектах.

Дополнительные ресурсы 📚

  1. MDN Web Docs: Подробное описание всех методов массивов с примерами на официальном сайте MDN.
  2. JavaScript.info: Учебник по JavaScript с глубоким разбором методов массивов.
Рекурсия в JavaScript: Искусство Повторения - theVolkov

В JavaScript, как и в других языках программирования, рекурсия играет важную роль в решении сложных задач. В этой статье мы рассмотрим основные концепции рекурсии в JavaScript и представим несколько примеров использования.

Что такое рекурсия?

Рекурсия — это процесс, при котором функция вызывает саму себя внутри своего тела. Этот процесс продолжается до тех пор, пока не будет достигнуто условие завершения. Важно правильно настроить условие завершения, чтобы избежать бесконечной рекурсии и переполнения стека вызовов.

Рекурсия — это процесс, который начинается, когда он заканчивается 🔁

Автор неизвестен

Пример 1: Факториал числа с использованием рекурсии

Факториал числа — это произведение всех целых чисел от 1 до данного числа. Давайте реализуем функцию для вычисления факториала с использованием рекурсии:

function factorial(n) {
  if (n === 0) {
    return 1; // Условие завершения рекурсии
  } else {
    return n * factorial(n - 1); // Рекурсивный вызов
  }
}

const result = factorial(5);
console.log(result); // Вывод: 120 (5 * 4 * 3 * 2 * 1)

В этом примере функция factorial вызывает саму себя с аргументом n - 1, пока не достигнется условие завершения (n === 0).

Пример 2: Вычисление числа Фибоначчи с использованием рекурсии

Числа Фибоначчи — это последовательность чисел, в которой каждое следующее число равно сумме двух предыдущих. Реализуем функцию для вычисления числа Фибоначчи с использованием рекурсии:

function fibonacci(n) {
  if (n <= 1) {
    return n; // Условие завершения рекурсии
  } else {
    return fibonacci(n - 1) + fibonacci(n - 2); // Рекурсивный вызов
  }
}

const result = fibonacci(6);
console.log(result); // Вывод: 8 (0, 1, 1, 2, 3, 5, 8)

В этом примере функция fibonacci вызывает саму себя дважды для двух предыдущих чисел в последовательности.

Пример 3: Рекурсивный обход дерева

Рекурсия также может быть полезной при работе с древовидными структурами данных. Давайте рассмотрим пример обхода дерева с использованием рекурсии:

const tree = {
  value: 1,
  children: [
    {
      value: 2,
      children: [
        {
          value: 5,
          children: []
        },
        {
          value: 6,
          children: []
        }
      ]
    },
    {
      value: 3,
      children: [
        {
          value: 7,
          children: []
        }
      ]
    },
    {
      value: 4,
      children: []
    }
  ]
};

function traverseTree(node) {
  if (!node) return; // Проверка наличия узла
  console.log(node.value); // 1,2,5,6,3,7,4
  node.children.forEach(child => {
    traverseTree(child); // Рекурсивный вызов для каждого потомка
  });
}

traverseTree(tree);

Этот код рекурсивно обходит древовидную структуру и выводит значения узлов.

Заключение

Рекурсия — мощный инструмент программирования в JavaScript, который может быть использован для решения разнообразных задач. Однако необходимо быть осторожными при использовании рекурсии, чтобы избежать переполнения стека вызовов и бесконечных циклов. Надеюсь, что эта статья помогла вам лучше понять основные концепции рекурсии и ее практическое применение в JavaScript.

Глубокое копирование объектов в JavaScript

📋 В JavaScript объекты представляют собой одну из основных концепций, и они могут быть очень сложными и вложенными. В некоторых случаях вам может потребоваться создать копию объекта для работы с ней, не затрагивая исходный объект. Этот процесс называется глубоким копированием объекта. В данной статье мы рассмотрим, как выполнить глубокое копирование объектов в JavaScript на примере несложной функции, а также объясним, почему это важно и почему другие методы копирования могут быть менее эффективными.

Зачем нужно глубокое копирование (клонирование)?

Глубокое копирование объекта играет ключевую роль во многих сценариях разработки, особенно при работе с сложными вложенными структурами данных.

Вот несколько причин, по которым глубокое копирование может быть полезным:

  1. Изоляция данных: Глубокое копирование позволяет создать полностью независимую копию объекта. Это означает, что изменения в одной копии не затрагивают другую. Это особенно важно, когда вы храните состояние или данные, которые могут изменяться в разных частях вашего приложения.
  2. Предотвращение побочных эффектов: Если вы передаете объекты между функциями или модулями, глубокое копирование может предотвратить неожиданные побочные эффекты, вызванные изменением объектов внутри функций.
  3. Cтруктура данных: Глубокое копирование сохраняет структуру данных объекта.

Копирование объектов в JavaScript является важной операцией во многих сценариях разработки 🗂️

Рекурсия для глубокого копирования

Для обработки объектов с различными типами данных и бесконечной вложенностью, функция глубокого клонирования может выглядеть следующим образом:

function deepClone(obj) {
  if (obj === null || typeof obj !== 'object' || typeof obj === 'function') {
    // Если obj - это примитив, функция или null, вернуть его как есть
    return obj;
  }

  if (Array.isArray(obj)) {
    // Если obj - это массив, создать новый массив и клонировать его элементы с помощью рекурсии
    return obj.map((item) => deepClone(item));
  }

  // Если obj - это объект, создать новый объект и клонировать его свойства с помощью рекурсии и reduce
  return Object.keys(obj).reduce((cloneObj, key) => {
    if (obj.hasOwnProperty(key)) {
      cloneObj[key] = deepClone(obj[key]);
    }
    return cloneObj;
  }, {});
}

Эта функция учитывает различные типы данных, включая объекты, массивы, строки, числа, булевые значения, функции и null.

Теперь просто передайте объект, который вы хотите скопировать, в качестве аргумента:

// Пример объекта с глубокой вложенностью:
const originalObject = {
  a: 1,
  b: {
    c: "string",
    d: [3, 4],
    e: true,
    f: null,
    g: function() {
      console.log("Hello, world!");
    },
    h: {
      i: "nested string",
      j: [5, 6],
      k: false,
      l: {
        m: "deeply nested string",
        n: [7, 8],
        o: true,
        p: {
          q: "very deeply nested string",
          r: [9, 10],
          s: false,
          t: {
            u: "incredibly deeply nested string",
          },
        },
      },
    },
  },
};

// Вызов функции клонирования объекта:
const clonedObject = deepClone(originalObject);

В результате, clonedObject — это независимая копия объекта, которую вы можете изменять, не затрагивая originalObject.

Какие еще есть методы клонирования объектов и почему они не так эффективны?

Существуют и другие способы копирования объектов в JavaScript, такие как Object.assign, оператор расширения (spread / ...), и JSON.parse(JSON.stringify(obj)).

Однако эти методы имеют ограничения:

  1. Object.assign и spread оператор {...}: Эти методы выполняют поверхностное копирование, то есть они копируют только верхний уровень свойств объекта. Если объект содержит вложенные объекты или массивы, они будут скопированы по ссылке, а не созданы как независимые копии.
  2. JSON.parse(JSON.stringify(obj)): Этот метод сериализует* объект в строку JSON и затем разбирает ее обратно в объект. Он отлично работает для глубокого копирования простых объектов, но не подходит для объектов, содержащих функции или циклические ссылки, так как они не могут быть сериализованы* в JSON.

Функция deepClone, представленная выше, решает эти проблемы, обеспечивая надежное и глубокое копирование объектов, включая все их вложенные структуры и типы данных.

Подведем итоги

В этой статье мы изучили важность клонирования объектов в JavaScript и представили свою функцию deepClone, которая подойдет для выполнения этой задачи.

Важно помнить, что не все методы копирования объектов обеспечивают глубокое копирование. Многие из них копируют только поверхностные свойства объекта или могут быть неприменимы к объектам с функциями или циклическими ссылками.

В зависимости от вашей задачи и контекста, выбор метода копирования может играть значительную роль.


*Cериализация — это процесс преобразования объекта JavaScript в строку JSON с помощью метода JSON.stringify().

Метод reduce() в JavaScript - theVolkov

🔗 Метод reduce() представляет собой универсальное средство для работы с массивами в JavaScript. С его помощью можно эффективно свести массив к одному значению, последовательно применяя функцию к элементам.

Аргументы:

callback (обязательный): Функция, которая будет применяться к элементам массива. Принимает четыре аргумента:

  • Аккумулятор (accumulator): Значение, которое накапливает результат после каждой итерации. Изначально равно начальному значению или первому элементу массива, если начальное значение не указано.
  • Текущий элемент (currentValue): Текущий обрабатываемый элемент массива.
  • Индекс элемента (index) — Необязательный аргумент: Индекс текущего элемента в массиве.
  • Исходный массив (array) — Необязательный аргумент: Ссылка на исходный массив.

initialValue (необязательный): Начальное значение аккумулятора. Если этот аргумент не указан, первый элемент массива будет использован в качестве начального значения аккумулятора.

Примеры использования метода reduce() в JavaScript:

// Пример 1: Суммирование чисел в массиве
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
// Результат: sum = 15

// Пример 2: Конкатенация строк из массива
const strings = ["Hello", " ", "world", "!"];
const concatenatedString = strings.reduce((accumulator, currentValue) => {
  return accumulator + currentValue;
});
// Результат: concatenatedString = "Hello world!"

// Пример 3: Преобразование в объект с использованием аргумента array
const emojis = ["😀", "🍉", "🌼"];
const emojiInfo = emojis.reduce((accumulator, emoji, index, array) => {
  accumulator[`emoji${index}`] = { emoji, position: index, totalEmojis: array.length };
  return accumulator;
}, {});
// Результат: emojiInfo = { emoji0: { emoji: "😀", position: 0, totalEmojis: 3 }, ... }

// Пример 4: Создание нового массива на основе исходного массива
const numbers = [1, 2, 3, 4, 5];
const doubledAndSquared = numbers.reduce((accumulator, currentValue) => {
  const doubled = currentValue * 2;
  const squared = doubled * doubled;
  accumulator.push(squared);
  return accumulator;
}, []);
// Результат: doubledAndSquared = [4, 16, 36, 64, 100]

Использование метода reduce() в React.js

React.js

В этом примере мы рассмотрим, как с использованием метода reduce() можно удобно подсчитать общую стоимость товаров в корзине и вывести эту информацию на экран.

Допустим, у нас есть массив объектов, представляющих товары в корзине покупателя. Каждый объект содержит информацию о товаре, такую как название и цена. Наша задача — подсчитать общую сумму всех покупок в корзине и отобразить ее на экране.

Применение метода reduce() позволяет нам эффективно агрегировать данные и предоставлять пользователям информацию о стоимости их покупок в интернет-магазинах 🛒

import React from 'react';

const ShoppingCart = () => {
  // Массив объектов с товарами в корзине
  const cartItems = [
    { id: 1, name: 'Smartphone', price: 499.99 },
    { id: 2, name: 'Headphones', price: 99.99 },
    { id: 3, name: 'Charging Cable', price: 9.99 }
  ];

  // Используем метод reduce() для подсчета общей суммы
  const totalAmount = cartItems.reduce((total, item) => total + item.price, 0);

  return (
    <div>
      <h1>Your Shopping Cart</h1>
      <ul>
        {cartItems.map(item => (
          <li key={item.id}>
            {item.name} - ${item.price}
          </li>
        ))}
      </ul>
      <h2>Total: ${totalAmount.toFixed(2)}</h2>
    </div>
  );
};

export default ShoppingCart;

Что у нас в итоге получилось:

В этом простом примере мы используем метод reduce() для подсчета общей суммы всех товаров в корзине. Мы также используем метод map() для отображения списка товаров и их цен. Общая сумма выводится внизу списка с округлением до двух знаков после запятой.

🗺️ Метод map() используется для создания нового массива путем применения заданной функции к каждому элементу исходного массива. Этот метод не изменяет исходный массив, а возвращает новый, содержащий результаты выполнения функции для каждого элемента.

Применение метода map() удобно, когда необходимо трансформировать каждый элемент массива и получить новый массив с результатами 🌀

Аргументы:

callback (обязательный): Функция, которая будет применена к каждому элементу массива. Эта функция может принимать три аргумента:

  • Текущий элемент — item (обязательный): Элемент массива, который обрабатывается на текущей итерации цикла.
  • Индекс элемента — index (необязательный): Индекс текущего элемента в массиве.
  • Исходный массив — array (необязательный): Ссылка на исходный массив, для которого выполняется итерация. Можно использовать этот аргумент, если вам потребуется доступ к другим элементам массива или его свойствам в процессе выполнения.

Как использовать метод map() в JavaScript:

// Пример 1: Обычное использование
const numbers = [1, 2, 3];
const doubledNumbers = numbers.map(num => num * 2);
// Результат: doubledNumbers = [2, 4, 6]

// Пример 2: Использование с дополнительным аргументом index
const strings = ["apple", "banana", "cherry"];
const arrayWithIndex = strings.map((str, index) => `${index}: ${str}`);
// Результат: arrayWithIndex = ["0: apple", "1: banana", "2: cherry"]

// Пример 3: Использование аргумента array
const emojis = ["😀", "🍉", "🌼"];
const emojiInfo = emojis.map((emoji, index, array) => {
  return {
    emoji: emoji,
    position: index,
    totalEmojis: array.length
  };
});
// Результат: emojiInfo = [{ emoji: "😀", position: 0, totalEmojis: 3 }, ...]

Использование массивов в React для отображения списков

В React массивы широко используются для отображения списков данных, элементов пользовательского интерфейса и другой информации. Один из распространенных способов работы с массивами в React — это использование метода map().

React.js

Метод map() позволяет преобразовать каждый элемент массива в JSX-компонент, что упрощает создание динамических списков и повторяющихся элементов интерфейса ⚛️

Пример использования метода map() для отображения списка элементов в компоненте React.js:

import React from 'react';

const UserList = () => {
  const users = [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' },
    { id: 3, name: 'Charlie' }
  ];

  // Используем метод map() для преобразования каждого объекта пользователя в JSX-компонент
  const userList = users.map(user => (
    // Компонент для отображения информации о пользователе
    <div key={user.id}>
      <span>{user.name}</span>
    </div>
  ));
  // Вставляем список (userList) JSX-компонентов пользователей
  return (
    <div>
      <h1>User List</h1>
      {userList}
    </div>
  );
};

export default UserList;

В этом примере мы создаем компонент UserList, который использует метод map() для преобразования каждого объекта пользователя в JSX-компонент. Обратите внимание на использование атрибута key при создании компонента, что позволяет React эффективно управлять изменениями и обновлениями.

В результате, массив пользователей отображается в виде списка с их именами, где каждое имя находится в отдельной div.

Когда дело доходит до обработки данных в JavaScript, массивы становятся настоящей сокровищницей инструментов. Массивы представляют собой упорядоченные коллекции элементов, которые могут хранить разнообразные типы данных (числа, строки, объекты и т.д.). Однако истинная магия проявляется, когда на сцену выходят методы массивов.

Методы массивов в JavaScript предоставляют мощные инструменты для манипуляции данными 🚀

В этой статье мы рассмотрим разнообразные методы массивов, предоставив подробные объяснения и интересные примеры использования каждого метода.

🗺️ map()

Метод map() создает новый массив, путем применения переданной функции ко всем элементам исходного массива. Возвращаемое значение каждого вызова функции становится соответствующим элементом нового массива.

const emojis = ["😃", "🚀", "🌟"];
const excitedEmojis = emojis.map(emoji => emoji + "🎉");

// Результат: ["😃🎉", "🚀🎉", "🌟🎉"]

🎣 filter()

Метод filter() создает новый массив, содержащий только те элементы исходного массива, которые удовлетворяют заданному условию в переданной функции.

const emojis = ["😃", "🚀", "🌟", "😢"];
const happyEmojis = emojis.filter(emoji => emoji === "😃" || emoji === "🌟");

// Результат: ["😃", "🌟"]

reduce()

Метод reduce() применяет функцию аккумулятора к элементам массива, последовательно сводя их к одному значению.

const numbers = [2, 4, 6];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);

// Результат: 12

🔄 forEach()

Метод forEach() выполняет переданную функцию для каждого элемента массива, но не создает новый массив.

const emojis = ["😃", "🚀", "🌟"];
emojis.forEach(emoji => console.log(emoji));

// Результат: В консоле поочередно отобразится три console.log() "😃" => "🚀" => "🌟"

🔤 sort()

Метод sort() сортирует элементы массива и изменяет его порядок.

const emojis = [43, 12, 33, 1];
emojis.sort();

// Результат: [1, 12, 33, 43]

🔍 find()

Метод find() возвращает первый элемент, который удовлетворяет условию, заданному в переданной функции.

const emojis = ["😃", "🚀", "🌟", "😢"];
const foundEmoji = emojis.find(emoji => emoji === "😃");

// Результат: "😃"

🤔 some()

Метод some() проверяет, удовлетворяет ли хотя бы один элемент условию, заданному в переданной функции.

const emojis = ["😃", "🚀", "🌟", "😢"];
const hasHappyEmoji = emojis.some(emoji => emoji === "😃"); 

// Результат: true