🤔 Что делать, если канал интовый и был получен ноль?

Проверить второй параметр при чтении:
- Если ok == false – канал закрыт, а 0 не является значением.
- Если ok == true – это действительное значение 0, переданное в канал.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие преимущества есть у Go?

Go (или Golang) обладает рядом преимуществ, которые делают его популярным.

🟠Простота и лаконичность
Был разработан с упором на простоту синтаксиса и лаконичность. Это делает язык легким для изучения и чтения кода. Минимализм языка позволяет разработчикам сосредоточиться на решении задач, а не на сложностях синтаксиса.

🟠Высокая производительность
Компилируется в машинный код, что обеспечивает высокую производительность выполнения программ. Производительность Go сопоставима с производительностью программ, написанных на C или C++, благодаря низкоуровневой оптимизации компилятора.

🟠Параллелизм и конкурентность
Одним из ключевых преимуществ является встроенная поддержка параллелизма и конкурентности. С помощью горутин и каналов разработчики могут легко создавать многопоточные приложения.

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

🟠Сильная система типов и безопасность памяти
Имеет строгую систему типов, которая помогает предотвращать ошибки на этапе компиляции. В языке отсутствуют неявные преобразования типов, что снижает вероятность ошибок. Также Go управляет памятью с помощью встроенного сборщика мусора (garbage collector), что предотвращает утечки памяти.

🟠Встроенная поддержка
Стандартных инструментов
Поставляется с богатым набором встроенных инструментов для разработки, таких как:
go fmt для автоматического форматирования кода.
go test для запуска тестов.
go build и go run для сборки и выполнения программ.
go doc для генерации документации.

🟠Кроссплатформенность
Поддерживает компиляцию кода для различных платформ и операционных систем. Это делает его удобным для разработки кроссплатформенных приложений.

🟠Стандартная библиотека
Обширна и покрывает многие аспекты разработки, такие как работа с сетью, работа с файлами, веб-разработка и многое другое. Это позволяет разработчикам быстро начинать работу, не тратя время на поиск и интеграцию сторонних библиотек.

🟠Сообщество и поддержка
Имеет большое и активное сообщество, а также поддерживается компанией Google. Это гарантирует наличие множества ресурсов для обучения и решения возникающих вопросов, а также активное развитие и улучшение языка.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Через какой канал возможна проверка работы горутины?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Чем stream отличается от unary?

В контексте gRPC (Google Remote Procedure Call) unary и stream — это два разных типа взаимодействия между клиентом и сервером.

🚩Unary RPC (Обычный вызов)

🟠Unary (унарный) вызов
это стандартный запрос-ответ:
Клиент отправляет одно сообщение → сервер отвечает одним сообщением.

service UserService {
    rpc GetUserInfo(UserRequest) returns (UserResponse);
}

Go-реализация Unary RPC

func (s *server) GetUserInfo(ctx context.Context, req *pb.UserRequest) (*pb.UserResponse, error) {
    user := &pb.UserResponse{
        Id:    req.Id,
        Name:  "John Doe",
        Email: "john@example.com",
    }
    return user, nil // Обычный ответ
}

🚩Streaming RPC (Потоковый вызов)

В streaming RPC передача данных идёт потоком. gRPC поддерживает три вида стримов:

🟠Server Streaming (Поток от сервера)
Клиент отправляет один запрос → сервер возвращает поток ответов.

service UserService {
    rpc GetUserActivity(UserRequest) returns (stream ActivityResponse);
}

Go-реализация Server Streaming

func (s *server) GetUserActivity(req *pb.UserRequest, stream pb.UserService_GetUserActivityServer) error {
    activities := []string{"Login", "Upload File", "Logout"}
    for _, activity := range activities {
        err := stream.Send(&pb.ActivityResponse{Message: activity})
        if err != nil {
            return err
        }
        time.Sleep(time.Second) // Имитация задержки
    }
    return nil
}

🟠Client Streaming (Поток от клиента)
Клиент отправляет поток данных → сервер отвечает одним ответом.

service UploadService {
    rpc UploadFile(stream FileChunk) returns (UploadResponse);
}

Go-реализация Client Streaming

func (s *server) UploadFile(stream pb.UploadService_UploadFileServer) error {
    var totalSize int64
    for {
        chunk, err := stream.Recv()
        if err == io.EOF {
            return stream.SendAndClose(&pb.UploadResponse{Size: totalSize})
        }
        if err != nil {
            return err
        }
        totalSize += chunk.Size
    }
}

🟠Bidirectional Streaming (Двунаправленный поток)
Клиент и сервер обмениваются данными в потоке одновременно.

service ChatService {
    rpc Chat(stream ChatMessage) returns (stream ChatMessage);
}

Go-реализация Bi-directional Streaming

func (s *server) Chat(stream pb.ChatService_ChatServer) error {
    for {
        msg, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
        response := &pb.ChatMessage{Text: "Echo: " + msg.Text}
        if err := stream.Send(response); err != nil {
            return err
        }
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как закрыть канал?

Использовать close(channel). После этого:
- Новые записи приведут к panic.
- Чтение продолжится, пока не будет пустым.
- Чтение из пустого закрытого канала даст zero-value.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое интеграционные тесты?

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

🚩Зачем они нужны?

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

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

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

🚩Как их писать?

Интеграционные тесты могут требовать наличия нескольких зависимостей, таких как база данных, внешние API или другие сервисы. Настройте тестовую среду, которая будет эмулировать реальную среду.

      // main.go
   package main

   import (
       "database/sql"
       _ "github.com/mattn/go-sqlite3"
       "log"
   )

   type User struct {
       ID   int
       Name string
   }

   func CreateUser(db *sql.DB, name string) (int, error) {
       res, err := db.Exec("INSERT INTO users(name) VALUES(?)", name)
       if err != nil {
           return 0, err
       }
       id, err := res.LastInsertId()
       if err != nil {
           return 0, err
       }
       return int(id), nil
   }

   func GetUser(db *sql.DB, id int) (User, error) {
       var user User
       err := db.QueryRow("SELECT id, name FROM users WHERE id = ?", id).Scan(&user.ID, &user.Name)
       if err != nil {
           return user, err
       }
       return user, nil
   }

   func main() {
       db, err := sql.Open("sqlite3", ":memory:")
       if err != nil {
           log.Fatal(err)
       }
       defer db.Close()

       _, err = db.Exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
       if err != nil {
           log.Fatal(err)
       }
   }
        // main_test.go
   package main

   import (
       "database/sql"
       "testing"
       _ "github.com/mattn/go-sqlite3"
   )

   func setupTestDB(t *testing.T) *sql.DB {
       db, err := sql.Open("sqlite3", ":memory:")
       if err != nil {
           t.Fatal(err)
       }
       _, err = db.Exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
       if err != nil {
           t.Fatal(err)
       }
       return db
   }

   func TestCreateAndGetUser(t *testing.T) {
       db := setupTestDB(t)
       defer db.Close()

       // Создание пользователя
       userID, err := CreateUser(db, "John Doe")
       if err != nil {
           t.Fatalf("Failed to create user: %v", err)
       }

       // Получение пользователя
       user, err := GetUser(db, userID)
       if err != nil {
           t.Fatalf("Failed to get user: %v", err)
       }

       // Проверка результатов
       if user.Name != "John Doe" {
           t.Errorf("Expected name to be 'John Doe', got %s", user.Name)
       }
   }

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие действия можно производить с каналами?

1. Отправлять данные (chan <- value).
2. Читать данные (value := <-chan).
3. Закрывать (close(chan)).
4. Использовать в select для обработки множественных каналов.
5. Создавать буферизированные и небуферизированные каналы.
6. Использовать range для чтения оставшихся данных из закрытого канала.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

На easyoffer 2.0 появится:
🎯 Тренажер "Проработка вопросов"

✅ Метод интервальных повторений и флеш-карточки
✅ Персональный подход изучения на основе ваших ответов
✅ Упор на самые частые вопросы

📌 Интервальные повторения по карточкам это научно доказанный метод эффективного обучения. Каждая карточка – это вопрос, который задают на собеседовании, вы можете выбрать "Не знаю", "Знаю", "Не спрашивать". После ответа вам показывается правильный ответ и возможность изучить вопрос подробнее (примеры ответов других людей). От ваших ответов зависит то, как часто карточки будут показываться на следующей тренировке. Трудные вопросы показываются чаще, простые – реже. Это позволяет бить в слабые места. Кроме того, изначальный порядок карточек зависит от частотности (вероятности встретить вопрос).

🚀 Благодаря этому тренажеру вы сможете очень быстро подготовиться к собеседованию, т.к. фокусируетесь отвечать на самые частые вопросы. Именно так готовился я сам, когда искал первую работу программистом.

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

‼️ Очень важно, чтобы как можно больше людей поддержали проект в первые дни, по-этому те кто окажет поддержку первыми получат еще более выгодную стоимость на годовую подписку и существенный 💎 бонус о котором я позже расскажу в этом телеграм канале. Подписывайтесь, чтобы узнать о старте проекта раньше других и воспользоваться лимитированными вознаграждениями.

🤔 Что такое массив (array)?

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

🚩Основные характеристики

🟠Фиксированный размер
Размер массива задается при его объявлении и не может изменяться во время выполнения программы.
🟠Тип элементов
Все элементы массива имеют один и тот же тип.
🟠Непрерывное размещение в памяти
Элементы массива хранятся последовательно в памяти, что обеспечивает быстрый доступ к любому элементу по индексу.

🚩Объявление и инициализация массивов

Массивы объявляются с указанием типа элементов и фиксированного размера:

var arr [5]int

🟠Инициализация массива
Могут быть инициализированы при объявлении:

arr := [5]int{1, 2, 3, 4, 5}

Можно также инициализировать массив частично, оставив остальные элементы равными нулям:

arr := [5]int{1, 2}

🟠Доступ к элементам массива
Осуществляется с использованием индексов, начиная с 0:

fmt.Println(arr[0]) // 1
arr[1] = 10
fmt.Println(arr[1]) // 10

🟠Длина массива
Фиксирована и задается при его объявлении. Ее можно получить с помощью функции len:

fmt.Println(len(arr)) // 5

🟠Копирование массива
При присваивании одного массива другому копируются все элементы:

arr1 := [5]int{1, 2, 3, 4, 5}
arr2 := arr1
arr2[0] = 10
fmt.Println(arr1) // [1 2 3 4 5]
fmt.Println(arr2) // [10 2 3 4 5]

🟠Передача массива в функции
Копируется весь массив:

func modifyArray(a [5]int) {
    a[0] = 10
}

arr := [5]int{1, 2, 3, 4, 5}
modifyArray(arr)
fmt.Println(arr) // [1 2 3 4 5]

🟠Сравнение массивов
С помощью оператора ==, если они имеют одинаковую длину и тип элементов:

arr1 := [3]int{1, 2, 3}
arr2 := [3]int{1, 2, 3}
arr3 := [3]int{4, 5, 6}

fmt.Println(arr1 == arr2) // true
fmt.Println(arr1 == arr3) // false

Пример

package main

import (
    "fmt"
)

func main() {
    // Объявление и инициализация массива
    arr := [5]int{1, 2, 3, 4, 5}

    // Доступ к элементам
    fmt.Println("First element:", arr[0]) // First element: 1

    // Изменение элементов
    arr[1] = 10
    fmt.Println("Modified array:", arr) // Modified array: [1 10 3 4 5]

    // Длина массива
    fmt.Println("Length of array:", len(arr)) // Length of array: 5

    // Копирование массива
    arr2 := arr
    arr2[0] = 20
    fmt.Println("Original array:", arr) // Original array: [1 10 3 4 5]
    fmt.Println("Copied array:", arr2)  // Copied array: [20 10 3 4 5]

    // Передача массива в функцию
    modifyArray(arr)
    fmt.Println("Array after modifyArray call:", arr) // Array after modifyArray call: [1 10 3 4 5]
}

func modifyArray(a [5]int) {
    a[0] = 10
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как использовать индексы в JOIN запросах MySQL?

Индексы в JOIN помогают ускорить соединение таблиц, уменьшая количество сравниваемых строк. Для эффективного JOIN следует:
- Использовать индексы на полях соединения (ON table1.id = table2.foreign_key).
- Убедиться, что индексы покрывают условия фильтрации (WHERE).
- Проверить использование индексов с EXPLAIN.
- Предпочитать INNER JOIN, так как он быстрее LEFT JOIN при одинаковых условиях.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Почему в TDD тесты пишутся прежде кода?

Этот подход обеспечивает ряд преимуществ, которые способствуют улучшению качества кода, его поддерживаемости и соответствию требованиям.

🚩Причины

🟠Определение требований
Написание тестов перед кодом помогает разработчикам четко определить требования к функции или модулю. Тесты выступают в роли спецификации, описывающей, как должен работать код. Это помогает избежать недоразумений и гарантирует, что все требования учтены с самого начала.

🟠Сосредоточение на функциональности
TDD заставляет разработчиков сосредоточиться на минимальной функциональности, необходимой для прохождения тестов. Это предотвращает избыточное проектирование и разработку ненужных функций. Каждый тест фокусируется на одном аспекте функциональности, что помогает создавать чистый и целенаправленный код.

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

🟠Обратная связь и уверенность
Тесты, написанные перед кодом, обеспечивают немедленную обратную связь. Если код не проходит тест, это означает, что он не соответствует требованиям. Это позволяет разработчикам быстро обнаруживать и исправлять ошибки, повышая уверенность в корректности кода.

🟠Поддержка и документация
Тесты служат живой документацией кода. Они показывают, как должен работать код и какие случаи использования поддерживаются. Это облегчает понимание кода другим разработчикам и упрощает его поддержку в будущем.

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

🚩Пример процесса TDD

1⃣Написание теста

package main

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, but got %d", result)
    }
}

2⃣Запуск теста
На этом этапе тест не пройдет, так как функция Add еще не реализована.

3⃣Реализация кода

package main

func Add(a, b int) int {
    return a + b
}

4⃣Запуск теста снова
Теперь тест пройдет, так как функция Add реализована корректно.

5⃣Рефакторинг
При необходимости выполняется рефакторинг кода для улучшения его структуры, при этом тесты продолжают проходить, что гарантирует сохранение функциональности.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое частичные индексы?

Это индекс, который создается только на подмножестве строк или столбцов таблицы, а не на всей таблице.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Можно ли использовать один и тот же буфер []byte в нескольких горутинах?

Может быть как безопасным, так и небезопасным, в зависимости от контекста и конкретного использования.

🚩Когда использование небезопасно

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := make([]byte, 10)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            buffer[i] = byte(i) // Несколько горутин одновременно модифицируют буфер
        }(i)
    }

    wg.Wait()
    fmt.Println("Buffer:", buffer)
}

🚩Безопасное использование одного буфера

🟠Только чтение
Если несколько горутин только читают из буфера, это безопасно. Пример безопасного использования:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := []byte("Hello, World!")

    for i := 0; i < len(buffer); i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Printf("buffer[%d]: %c\n", i, buffer[i])
        }(i)
    }

    wg.Wait()
}

🟠Использование мьютексов
Для синхронизации доступа к буферу используйте мьютексы (sync.Mutex). Это гарантирует, что только одна горутина в данный момент модифицирует буфер.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    buffer := make([]byte, 10)

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            mu.Lock()
            buffer[i] = byte(i)
            mu.Unlock()
        }(i)
    }

    wg.Wait()
    fmt.Println("Buffer:", buffer)
}

🟠Копирование буфера
Если каждая горутина должна работать с независимой копией буфера, создавайте копии для каждой горутины.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    buffer := []byte("Hello, World!")

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            localBuffer := make([]byte, len(buffer))
            copy(localBuffer, buffer)
            localBuffer[i] = byte(i)
            fmt.Printf("Goroutine %d: %s\n", i, localBuffer)
        }(i)
    }

    wg.Wait()
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Для чего используется частичный индекс?

Частичные индексы позволяют:
- Экономить место – индекс создается только для нужных значений.
- Ускорять запросы – за счет меньшего размера индекс быстрее сканируется.
- Фильтровать данные – индекс применяется только к записям, которые соответствуют определенному условию.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

На easyoffer 2.0 появится новый раздел:
Задачи с собеседований

🟠Задачи на Алгоритмические, Live-coding и System Design из реальных собеседований
🟠Вероятность встретить ту или иную задачу
🟠Возможность подготовиться к задачам конкретной компании

Есть много сайтов, на которых можно тренироваться решать задачи, но у них у всех одна проблема – сами задачи люди просто выдумывают. На easyoffer 2.0 вы сможете готовиться к live-coding и system design секциям на основе задач из реальных собеседований. Вы можете найдете самые частые задачи и сделаете упор на их решение.

Считаные дни остались до старта краудфандинговой кампании, чтобы ускорить разработку easyoffer 2.0. Все кто, поддержал проект на этом этапе смогу получить 1 год доступа к сайту по цене месячной подписки, а те кто поддержат проект раньше других ито дешевле + получат существенный бонус. Следите за стартом 👉 в этом телеграм канале.

🤔 Сколько весит число в байтах?

Размер числа в байтах зависит от его типа данных. В Go есть несколько числовых типов, и каждый занимает определённое количество байтов в памяти.

🚩Проверка размера в Go (`unsafe.Sizeof`)

Можно проверить размер типа с помощью unsafe.Sizeof()

package main

import (
  "fmt"
  "unsafe"
)

func main() {
  var a int64
  var b float64
  var c byte // то же самое, что uint8
  fmt.Println("int64:", unsafe.Sizeof(a))   // 8
  fmt.Println("float64:", unsafe.Sizeof(b)) // 8
  fmt.Println("byte:", unsafe.Sizeof(c))    // 1
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как создать частичный индекс?

В MySQL нет прямой поддержки частичных индексов, но их можно имитировать:
- Индексация только первых N символов (PREFIX index) – работает с VARCHAR и TEXT.
- Использование WHERE в INDEX (в MySQL 8.0) – позволяет индексировать только определенные строки (CREATE INDEX ... WHERE condition).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Можно ли изменить определенный символ в строке?

Нет, строки (string) в Go неизменяемы (immutable). Это значит, что нельзя просто изменить один символ в строке.

🚩Почему нельзя изменить символ?

Строка в Go — это байтовый срез ([]byte), но неизменяемый. Когда вы создаёте строку

s := "hello"

Ошибка при попытке изменения символа напрямую

s := "hello"
s[0] = 'H' // Ошибка: cannot assign to s[0]

🚩Как изменить символ в строке?

Поскольку строка неизменяема, вам нужно создать новую строку с заменённым символом.
Способ 1: Преобразовать в []byte (для ASCII-строк)
Если строка содержит только английские буквы и символы ASCII, её можно преобразовать в []byte, заменить символ и создать новую строку.

package main

import "fmt"

func main() {
    s := "hello"
    b := []byte(s) // Преобразуем в изменяемый []byte
    b[0] = 'H'     // Меняем первый символ
    s = string(b)  // Преобразуем обратно в строку

    fmt.Println(s) // "Hello"
}

Способ 2: Преобразовать в []rune (для Unicode)
Если строка содержит русские буквы, эмодзи или другие многобайтовые символы, используйте []rune.

package main

import "fmt"

func main() {
    s := "привет"
    r := []rune(s) // Преобразуем в []rune (массив символов)
    r[0] = 'П'     // Меняем первый символ
    s = string(r)  // Преобразуем обратно в строку

    fmt.Println(s) // "Привет"
}

Ставь 👍 и забирай 📚 Базу знаний

На easyoffer 2.0 появится:
Тренажер "Реальное собеседование"

🟠 Сценарии вопросов из реального собеседования
🟠Возможность подготовиться к собеседованию в конкретную компанию
🟠Итоговая статистика (прошёл/не прошёл)

Сценарий вопросов взят из реального собеседования. То есть вы тренируетесь на тех вопросах, которые действительно задавались в компании X.

Уже в начале следующей недели стартует краудфандинг кампания, чтобы ускорить разработку easyoffer 2.0. Все кто, поддержал проект на этом этапе смогу получить 1 год доступа к сайту по цене месячной подписки. Первые 150 донатеров получать особо-выгодную цену и бонус. Следите за стартом 👉 в этом телеграм канале, в нем информация о старте будет опубликована за 6 часов до официального начала.

🤔 В чем отличия InnoDB и MyISAM?

- InnoDB – поддерживает транзакции, внешние ключи, обеспечивает целостность данных, использует кластерные индексы. Подходит для сложных нагрузок.
- MyISAM – быстрее для чтения, но не поддерживает транзакции и блокирует всю таблицу при изменениях. Используется для простых, редко изменяемых данных.
InnoDB предпочтителен для большинства современных приложений, так как надежнее и устойчивее к сбоям.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний