Метка: JavaScript

  • Vue 3 Slots передача параметров

    Slots (слоты) в Vue 3 предоставляют мощный механизм для создания гибких и переиспользуемых компонентов. В этой статье мы разберём все способы передачи параметров в слоты с примерами из реальной практики.

    Основные типы слотов в Vue 3

    • Слоты по умолчанию — базовый способ передачи контента
    • Именованные слоты — для точного позиционирования контента
    • Scoped slots — с передачей параметров из дочернего компонента

    1. Scoped Slots (Основной способ передачи параметров)

    <!-- Дочерний компонент -->
    <template>
      <div>
        <slot :item="item" :index="index"></slot>
      </div>
    </template>
    
    <!-- Родительский компонент -->
    <ChildComponent>
      <template v-slot:default="slotProps">
        {{ slotProps.item }} - {{ slotProps.index }}
      </template>
    </ChildComponent>

    2. Именованные scoped slots

    <!-- Дочерний компонент -->
    <template>
      <div>
        <slot name="header" :title="title"></slot>
        <slot name="content" :data="contentData"></slot>
      </div>
    </template>
    
    <!-- Родительский компонент -->
    <DataContainer>
      <template #header="{ title }">
        <h2>{{ title }}</h2>
      </template>
      
      <template #content="{ data }">
        <p>{{ data.description }}</p>
      </template>
    </DataContainer>

    3. Динамические параметры слотов

    <!-- Дочерний компонент -->
    <script setup>
    const slotProps = computed(() => ({
      user: currentUser.value,
      timestamp: new Date()
    }))
    </script>
    
    <template>
      <slot v-bind="slotProps"></slot>
    </template>

    4. Деструктуризация параметров

    <template #item="{ id, name }">
      <div>{{ id }}: {{ name }}</div>
    </template>

    Практические примеры

    Пример 1: Гибкий список

    <SmartList :items="users">
      <template #item="{ user }">
        <UserCard :user="user" />
      </template>
    </SmartList>

    Пример 2: Модальное окно с параметрами

    <ModalDialog>
      <template #header="{ close }">
        <button @click="close">×</button>
      </template>
      
      <template #default="{ data }">
        {{ data.message }}
      </template>
    </ModalDialog>

    Лучшие практики

    • Используйте осмысленные имена для параметров слотов
    • Для сложных компонентов документируйте структуру слотов
    • Избегайте глубокой вложенности scoped slots
    • Используйте TypeScript для типизации параметров

    Заключение

    Scoped slots в Vue 3 предоставляют мощный инструмент для создания гибких компонентов. Освоив передачу параметров в слоты, вы сможете создавать по-настоящему переиспользуемые UI-компоненты.

    Для более сложных сценариев рассмотрите использование Composition API вместе со слотами.

    Vue 3 Composition API + Slots: Сложные сценарии использования

    В сочетании с Composition API слоты Vue 3 раскрывают свою настоящую мощь. Рассмотрим продвинутые паттерны для сложных UI-компонентов.

    1. Динамические слоты с реактивными параметрами

    <!-- DynamicTable.vue -->
    <script setup>
    import { ref, computed } from 'vue'
    
    const props = defineProps(['data'])
    const sortDirection = ref('asc')
    
    const sortedData = computed(() => {
      return [...props.data].sort((a, b) => {
        return sortDirection.value === 'asc' 
          ? a.value - b.value 
          : b.value - a.value
      })
    })
    </script>
    
    <template>
      <table>
        <slot name="header" :toggleSort="() => sortDirection = sortDirection === 'asc' ? 'desc' : 'asc'"></slot>
        <tr v-for="(item, index) in sortedData" :key="index">
          <slot :item="item" :index="index"/>
        </tr>
      </table>
    </template>

    Применение: Таблицы с сортировкой, где логика инкапсулирована в компоненте, а рендеринг контролируется через слоты.

    2. Состояние модальных окон

    <!-- useModal.js -->
    import { ref } from 'vue'
    
    export function useModal() {
      const isOpen = ref(false)
      
      const open = () => isOpen.value = true
      const close = () => isOpen.value = false
      
      return { isOpen, open, close }
    }
    
    <!-- ModalComponent.vue -->
    <script setup>
    import { useModal } from './useModal'
    const modal = useModal()
    </script>
    
    <template>
      <slot :open="modal.open" :close="modal.close" :isOpen="modal.isOpen"/>
    </template>

    Использование:

    <ModalComponent v-slot="{ open, close, isOpen }">
      <button @click="open">Открыть</button>
      
      <div v-if="isOpen" class="modal">
        <slot name="content"/>
        <button @click="close">Закрыть</button>
      </div>
    </ModalComponent>

    3. Композиционные слоты для форм

    <!-- useFormField.js -->
    import { ref, computed } from 'vue'
    
    export function useFormField(initialValue) {
      const value = ref(initialValue)
      const isValid = computed(() => value.value.length > 0)
      
      return { value, isValid }
    }
    
    <!-- FormField.vue -->
    <script setup>
    import { useFormField } from './useFormField'
    
    const props = defineProps(['initialValue'])
    const field = useFormField(props.initialValue)
    </script>
    
    <template>
      <div class="form-field" :class="{ invalid: !field.isValid }">
        <slot :value="field.value" :isValid="field.isValid"/>
      </div>
    </template>

    Использование с кастомным input:

    <FormField initialValue="" v-slot="{ value, isValid }">
      <input 
        v-model="value"
        :class="{ error: !isValid }"
        placeholder="Введите текст"
      >
      <span v-if="!isValid">Поле обязательно</span>
    </FormField>

    4. Сложные компоненты данных

    <!-- DataFetcher.vue -->
    <script setup>
    import { ref, onMounted } from 'vue'
    
    const props = defineProps(['url'])
    const data = ref(null)
    const error = ref(null)
    const isLoading = ref(false)
    
    onMounted(async () => {
      isLoading.value = true
      try {
        const response = await fetch(props.url)
        data.value = await response.json()
      } catch (err) {
        error.value = err
      } finally {
        isLoading.value = false
      }
    })
    </script>
    
    <template>
      <slot 
        :data="data" 
        :error="error" 
        :isLoading="isLoading"
        :reload="onMounted"
      />
    </template>

    Использование:

    <DataFetcher url="/api/users" v-slot="{ data, isLoading }">
      <div v-if="isLoading">Загрузка...</div>
      <UserList v-else :users="data" />
    </DataFetcher>

    5. Продвинутый пример: Компонент вкладок

    <!-- TabsContainer.vue -->
    <script setup>
    import { ref } from 'vue'
    
    const activeTab = ref(0)
    const tabs = ref([])
    
    const registerTab = (title) => {
      const id = tabs.value.length
      tabs.value.push({ id, title })
      return id
    }
    
    const setActiveTab = (id) => {
      activeTab.value = id
    }
    </script>
    
    <template>
      <div class="tabs-container">
        <div class="tabs-header">
          <button 
            v-for="tab in tabs" 
            @click="setActiveTab(tab.id)"
            :class="{ active: activeTab === tab.id }"
          >
            {{ tab.title }}
          </button>
        </div>
        
        <div class="tabs-content">
          <slot :activeTab="activeTab"/>
        </div>
      </div>
    </template>

    Использование:

    <TabsContainer v-slot="{ activeTab }">
      <template #default>
        <Tab :register="registerTab" title="Профиль">
          <div v-if="activeTab === 0">...</div>
        </Tab>
        
        <Tab :register="registerTab" title="Настройки">
          <div v-if="activeTab === 1">...</div>
        </Tab>
      </template>
    </TabsContainer>

    Заключение

    Сочетание Composition API и слотов позволяет создавать:

    • Полностью инкапсулированную логику компонентов
    • Максимально гибкие API для переиспользуемых компонентов
    • Сложные stateful-компоненты с простым интерфейсом
    • Легко тестируемые решения (бизнес-логика отделена от рендеринга)

  • Сортировка слиянием (Merge Sort) на PHP и JavaScript

    Сортировка слиянием — это эффективный алгоритм сортировки, работающий по принципу «разделяй и властвуй». Он обладает стабильностью и гарантированной сложностью O(n log n).

    📌 Алгоритм сортировки слиянием

    • Разделение массива на две половины
    • Рекурсивная сортировка каждой половины
    • Слияние отсортированных половин

    💻 Реализация на PHP

    <?php
    function mergeSort(array $arr): array {
        if (count($arr) <= 1) {
            return $arr;
        }
        
        $middle = (int)(count($arr) / 2);
        $left = mergeSort(array_slice($arr, 0, $middle));
        $right = mergeSort(array_slice($arr, $middle));
        
        return merge($left, $right);
    }
    
    function merge(array $left, array $right): array {
        $result = [];
        $i = $j = 0;
        
        while ($i < count($left) && $j < count($right)) {
            if ($left[$i] < $right[$j]) {
                $result[] = $left[$i++];
            } else {
                $result[] = $right[$j++];
            }
        }
        
        return array_merge($result, array_slice($left, $i), array_slice($right, $j));
    }
    
    // Пример использования
    $array = [38, 27, 43, 3, 9, 82, 10];
    $sorted = mergeSort($array);
    print_r($sorted);
    ?>

    🌐 Реализация на JavaScript

    1. Классическая версия

    function mergeSort(arr) {
        if (arr.length <= 1) return arr;
        
        const middle = Math.floor(arr.length / 2);
        const left = mergeSort(arr.slice(0, middle));
        const right = mergeSort(arr.slice(middle));
        
        return merge(left, right);
    }
    
    function merge(left, right) {
        let result = [];
        let i = 0, j = 0;
        
        while (i < left.length && j < right.length) {
            if (left[i] < right[j]) {
                result.push(left[i++]);
            } else {
                result.push(right[j++]);
            }
        }
        
        return result.concat(left.slice(i)).concat(right.slice(j));
    }
    
    // Пример использования
    const array = [38, 27, 43, 3, 9, 82, 10];
    console.log(mergeSort(array));

    2. Версия с визуализацией шагов

    function mergeSortWithSteps(arr, level = 0) {
        console.log(`${'  '.repeat(level)}Сортируем:`, arr);
        
        if (arr.length <= 1) {
            console.log(`${'  '.repeat(level)}Базовый случай:`, arr);
            return arr;
        }
        
        const middle = Math.floor(arr.length / 2);
        const left = mergeSortWithSteps(arr.slice(0, middle), level + 1);
        const right = mergeSortWithSteps(arr.slice(middle), level + 1);
        
        const merged = merge(left, right);
        console.log(`${'  '.repeat(level)}Сливаем ${left} и ${right} →`, merged);
        
        return merged;
    }
    
    const nums = [5, 2, 4, 7, 1];
    console.log("Исходный массив:", nums);
    console.log("Результат:", mergeSortWithSteps(nums));

    ⚡ Сравнение с другими алгоритмами

    ХарактеристикаMerge SortQuick SortBubble Sort
    Сложность (средняя)O(n log n)O(n log n)O(n²)
    Сложность (худшая)O(n log n)O(n²)O(n²)
    ПамятьO(n)O(log n)O(1)
    СтабильностьДаНетДа

    📌 Когда использовать?

    • Плюсы Merge Sort:
      • Гарантированная сложность O(n log n)
      • Стабильность (сохраняет порядок равных элементов)
      • Хорош для связных списков и внешней сортировки
    • Минусы:
      • Требует дополнительной памяти O(n)
      • Медленнее Quick Sort на небольших массивах

    Оптимальное применение: большие массивы (от 10k элементов), где важна стабильность.

    Другие виды сортировок

    • Quick Sort — быстрая сортировка
    • Bubble Sort — сортировка пузырьком
  • Методы массивов в JavaScript для поиска и проверки элементов в массиве: some, every, includes, find, findIndex.

    В JavaScript у массивов есть несколько методов для проверки элементов. В этой статье разберём:

    • some() — проверяет, удовлетворяет ли хотя бы один элемент условию.
    • Похожие методы: every(), includes(), find(), findIndex().
    • Примеры и сравнение с аналогами.

    1. Array.some(): Хотя бы один элемент проходит проверку

    Синтаксис

    arr.some(callback(element, index, array));

    — Возвращает true, если хотя бы один элемент соответствует условию.
    — Иначе — false.

    Пример

    const numbers = [1, 2, 3, 4, 5];
    
    // Есть ли хотя бы одно чётное число?
    const hasEven = numbers.some(num => num % 2 === 0);
    console.log(hasEven); // true (2 и 4 подходят)

    Когда использовать?

    Проверка, что в массиве есть хотя бы один подходящий элемент.


    2. Array.every(): Все элементы проходят проверку

    Синтаксис

    arr.every(callback(element, index, array));

    — Возвращает true, если все элементы удовлетворяют условию.

    Пример

    const ages = [18, 22, 25, 30];
    
    // Все ли совершеннолетние?
    const allAdults = ages.every(age => age >= 18);
    console.log(allAdults); // true

    Сравнение some() и every()

    МетодВозвращает true, если…Аналог в логике
    some()Хотя бы один элемент подходит|| (ИЛИ)
    every()Все элементы подходят&& (И)

    3. Array.includes(): Проверка наличия конкретного значения

    Синтаксис

    arr.includes(value, fromIndex);

    — Проверяет, есть ли конкретное значение в массиве.

    Пример

    const fruits = ['apple', 'banana', 'orange'];
    
    console.log(fruits.includes('banana')); // true
    console.log(fruits.includes('grape'));  // false

    includes() vs some()

    includes() — ищет конкретное значение.
    some() — проверяет условие (например, через функцию).

    // Эквивалентные проверки:
    const numbers = [1, 2, 3];
    
    // Через includes()
    numbers.includes(2); // true
    
    // Через some()
    numbers.some(num => num === 2); // true

    4. Array.find() и findIndex(): Поиск первого подходящего элемента

    find()

    Возвращает первый элемент, удовлетворяющий условию:

    const users = [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' },
    ];
    
    const bob = users.find(user => user.name === 'Bob');
    console.log(bob); // { id: 2, name: 'Bob' }

    findIndex()

    Возвращает индекс первого подходящего элемента (или -1):

    const index = users.findIndex(user => user.name === 'Bob');
    console.log(index); // 1

    Сравнение с some()

    МетодВозвращаетПодходит для…
    some()true/falseПроверка наличия
    find()Элемент или undefinedПолучение объекта
    findIndex()Индекс или -1Удаление/замена элемента

    5. Итог: Какой метод выбрать?

    ЗадачаМетод
    Есть ли хотя бы один подходящий?some()
    Все элементы подходят?every()
    Есть ли конкретное значение?includes()
    Найти первый подходящий элементfind()
    Найти индекс элементаfindIndex()

    Примеры использования

    ❶ Проверка прав доступа

    const permissions = ['read', 'write', 'delete'];
    
    // Есть ли право на запись?
    const canWrite = permissions.some(perm => perm === 'write');

    ❷ Валидация формы

    const inputs = ['', 'test@example.com', '123'];
    
    // Все ли поля заполнены?
    const isValid = inputs.every(input => input.trim() !== '');

    ❸ Поиск в массиве объектов

    const products = [
      { id: 1, name: 'Laptop', inStock: true },
      { id: 2, name: 'Phone', inStock: false },
    ];
    
    // Есть ли хотя бы один товар в наличии?
    const hasStock = products.some(product => product.inStock);

    Вывод

    some() — лучший выбор для проверки хотя бы одного элемента.
    every() — если нужно убедиться, что все элементы подходят.
    includes() — для простой проверки значений.
    find()/findIndex() — если нужен сам элемент или его индекс.

    Используйте эти методы, чтобы писать чистый и эффективный код! 🚀

  • Аналог JavaScript includes() в PHP

    Разбираем, как заменить популярный метод JavaScript includes() в PHP с примерами кода и подводными камнями.

    📌 JavaScript: includes()

    В JavaScript метод проверяет наличие подстроки или элемента в массиве:

    // Строки
    "Hello".includes("ell"); // true
    
    // Массивы
    [1, 2, 3].includes(2); // true

    📌 PHP: аналоги

    1. Для строк

    str_contains() (PHP 8.0+) — самый простой вариант:

    str_contains("Hello", "ell"); // true

    strpos() (для PHP < 8.0) — требует точной проверки:

    if (strpos("Hello", "ell") !== false) { // true
        echo "Найдено!";
    }

    🔹 Подводный камень:
    strpos() возвращает 0, если подстрока в начале строки, поэтому проверка должна быть строго !== false:

    strpos("Hello", "He"); // 0 (но это не false!)
    2. Для массивов

    in_array() — аналог [].includes():

    in_array(2, [1, 2, 3]); // true

    array_key_exists() — проверка ключа:

    array_key_exists("key", ["key" => 42]); // true

    🔹 Подводный камень:
    in_array() по умолчанию использует нестрогую проверку (==). Для строгой (===) укажите третий параметр:

    in_array("2", [1, 2, 3]); // true (без strict)
    in_array("2", [1, 2, 3], true); // false (со strict)
    3. Регистронезависимый поиск

    Для строк используйте stripos():

    stripos("Hello", "hello"); // 0 (проверяйте !== false!)

    Для массивов — преобразуйте элементы в нижний регистр:

    in_array(strtolower("HELLO"), array_map('strtolower', $array));

    📌 Советы по оптимизации

    • Для строк: str_contains() (PHP 8+) быстрее и читабельнее.
    • Для массивов: isset($array[$key]) работает быстрее in_array(), но проверяет только ключи.
    • Большие массивы: Используйте связку array_flip() + isset():
    isset(array_flip($array)[$value]);

    📌 Вопрос читателям

    Какой метод вы используете чаще?

    • str_contains() / strpos()
    • in_array() / isset()
    • Другие варианты? Пишите в комментарии!