Какие преимущества есть у Go ?
Спросят с вероятностью 17%

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

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

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

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

Пример:

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")
}

В этом примере функция say запускается как горутина с помощью go say("world"), что позволяет выполнять её конкурентно с основной программой.

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

5️⃣Встроенная поддержка стандартных инструментов
Поставляется с богатым набором встроенных инструментов для разработки, таких как:

✅go fmt для автоматического форматирования кода.
✅go test для запуска тестов.
✅go build и go run для сборки и выполнения программ.
✅go doc для генерации документации.

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

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

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Как инкапсуляция осуществлена в Golang ?
Спросят с вероятностью 17%

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

Экспортируемые и неэкспортируемые элементы

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

Пример инкапсуляции

Определение структуры с экспортируемыми и неэкспортируемыми полями

package main

import (
    "fmt"
)

// Person структура с экспортируемыми и неэкспортируемыми полями
type Person struct {
    Name string  // Экспортируемое поле
    age  int     // Неэкспортируемое поле
}

// Метод для получения возраста (экспортируемый)
func (p *Person) GetAge() int {
    return p.age
}

// Метод для установки возраста (экспортируемый)
func (p *Person) SetAge(age int) {
    if age >= 0 {
        p.age = age
    }
}

func main() {
    // Создание экземпляра структуры
    person := Person{Name: "Alice"}
    
    // Доступ к экспортируемому полю
    fmt.Println("Name:", person.Name)
    
    // Установка и получение значения через методы
    person.SetAge(30)
    fmt.Println("Age:", person.GetAge())
}

В этом примере структура Person имеет экспортируемое поле Name и неэкспортируемое поле age. Методы GetAge и SetAge позволяют управлять доступом к полю age.

Попробуем обратиться к полю age из другого пакета:

Пакет main.go

package main

import (
    "fmt"
    "mypackage"
)

func main() {
    person := mypackage.NewPerson("Bob", 25)
    
    // Доступ к экспортируемому полю
    fmt.Println("Name:", person.Name)
    
    // Попытка доступа к неэкспортируемому полю приведет к ошибке компиляции
    // fmt.Println("Age:", person.age)
    
    // Использование методов для доступа к неэкспортируемому полю
    fmt.Println("Age:", person.GetAge())
}

Пакет mypackage/person.go

package mypackage

// Person структура с экспортируемыми и неэкспортируемыми полями
type Person struct {
    Name string  // Экспортируемое поле
    age  int     // Неэкспортируемое поле
}

// NewPerson конструктор для создания новой структуры Person
func NewPerson(name string, age int) *Person {
    return &Person{Name: name, age: age}
}

// Метод для получения возраста (экспортируемый)
func (p *Person) GetAge() int {
    return p.age
}

// Метод для установки возраста (экспортируемый)
func (p *Person) SetAge(age int) {
    if age >= 0 {
        p.age = age
    }
}

В данном примере пакет mypackage определяет структуру Person и функции для работы с неэкспортируемым полем age. Пакет main использует эти функции для управления доступом к полю age.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Можно ли сделать int(string) и string(int) соответственно ?
Спросят с вероятностью 8%

Существуют встроенные функции для преобразования типов, включая преобразование из строки в целое число и наоборот. Для этих целей используются функции из стандартной библиотеки strconv. Рассмотрим, как это делается.

Преобразование строки в целое число

Для этого используется функция strconv.Atoi. Она возвращает два значения: само число и ошибку, если преобразование не удалось.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    str := "123"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("Error converting string to int:", err)
    } else {
        fmt.Println("Converted number:", num)
    }
}

В этом примере строка "123" успешно преобразуется в целое число 123. Если строка не может быть преобразована (например, содержит нецифровые символы), функция strconv.Atoi вернет ошибку.

Преобразование целого числа в строку

Для этого используется функция strconv.Itoa.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    num := 123
    str := strconv.Itoa(num)
    fmt.Println("Converted string:", str)
}

В этом примере целое число 123 успешно преобразуется в строку "123".

Обработка ошибок при преобразовании

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

package main

import (
    "fmt"
    "strconv"
)

func main() {
    str := "abc"
    num, err := strconv.Atoi(str)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Converted number:", num)
    }
}

В этом примере строка "abc" не может быть преобразована в целое число, поэтому функция strconv.Atoi вернет ошибку, которая будет обработана и выведена на экран.

Для преобразования строки в целое число в Go используется функция strconv.Atoi, а для преобразования целого числа в строку — функция strconv.Itoa. Обработка ошибок при преобразовании строки в целое число необходима для надежности программы.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Какие есть плюсы и минусы у монолита ?
Спросят с вероятностью 8%

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

Плюсы

1️⃣Простота разработки:
✅Легче начать разработку, особенно для небольших проектов. Вся кодовая база находится в одном месте, что упрощает понимание и внесение изменений.

2️⃣Единая кодовая база:
✅Весь код хранится в одном репозитории, что упрощает управление версиями, интеграцию изменений и сотрудничество между разработчиками.

3️⃣Простота развертывания:
✅Разворачивание монолитного приложения проще, так как нужно развернуть только один исполняемый файл или пакет. Нет необходимости в сложной координации развертывания множества микросервисов.

4️⃣Производительность:
✅Вызовы между компонентами происходят внутри одного процесса, что устраняет накладные расходы на межпроцессное взаимодействие и сетевые задержки.

5️⃣Единая система логирования и мониторинга:
✅Проще настраивать логирование и мониторинг, так как все компоненты приложения находятся в одном процессе и используют единые средства для логирования и мониторинга.

Минусы

1️⃣Сложность масштабирования:
✅Трудно масштабировать только определенные части приложения. Если одна часть приложения требует больше ресурсов, приходится масштабировать все приложение целиком, что может быть неэффективно.

2️⃣Сложность поддержки и обновления:
✅Изменение одного компонента может потребовать повторного развертывания всего приложения. Это увеличивает риски и время развертывания.

3️⃣Ограниченная гибкость:
✅Использование одной технологии для всего приложения может быть ограничивающим. Трудно использовать разные языки программирования и технологии для разных компонентов.

4️⃣Долгое время старта:
✅По мере роста приложения время старта может значительно увеличиваться, что влияет на производительность разработки и развертывания.

5️⃣Трудности в разделении команд:
✅Разработчики могут сталкиваться с конфликтами и сложностями в управлении большими кодовыми базами. Трудно разделить работу над разными частями приложения между командами.

Пример преимуществ и недостатков в реальных сценариях

Пример 1: Простота разработки

Сценарий: Стартап, который разрабатывает MVP (минимально жизнеспособный продукт).

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

Пример 2: Сложность масштабирования

Сценарий: Веб-приложение, в котором один из модулей (например, модуль обработки изображений) испытывает высокую нагрузку.

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Сколько в памяти занимают реализации int32 и int64 ?
Спросят с вероятностью 8%

В Go типы int32 и int64 занимают в памяти фиксированное количество байтов:

✅int32 занимает 4 байта (32 бита).
✅int64 занимает 8 байтов (64 бита).

Подробное объяснение

1️⃣int32:
✅Размер: 4 байта (32 бита).
✅Диапазон значений: от -2,147,483,648 до 2,147,483,647.

2️⃣int64:
✅Размер: 8 байтов (64 бита).
✅Диапазон значений: от -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807.

Пример кода для демонстрации размеров

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

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var a int32
    var b int64

    fmt.Printf("Size of int32: %d bytes\n", unsafe.Sizeof(a))
    fmt.Printf("Size of int64: %d bytes\n", unsafe.Sizeof(b))
}

В этом примере переменная a имеет тип int32, а переменная b — int64. Функция unsafe.Sizeof возвращает размер каждой переменной в байтах.

Тип int32 занимает 4 байта (32 бита) в памяти, а тип int64 занимает 8 байтов (64 бита).

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Какие есть плюсы и минусы у микросервисной архитектуры ?
Спросят с вероятностью 8%

Микросервисная архитектура (MSA) предлагает множество преимуществ по сравнению с монолитной архитектурой, но также имеет свои недостатки.

Плюсы

1️⃣Масштабируемость:
✅Каждый микросервис можно масштабировать независимо в зависимости от его нагрузки. Это позволяет более эффективно использовать ресурсы и улучшает производительность.

2️⃣Гибкость в выборе технологий:
✅Команды могут выбирать наиболее подходящие технологии и языки программирования для каждого микросервиса. Это позволяет использовать лучшие инструменты для конкретных задач и облегчает интеграцию новых технологий.

3️⃣Независимое развертывание и обновление:
✅Микросервисы могут разворачиваться и обновляться независимо друг от друга. Это снижает риски при развертывании и позволяет внедрять изменения быстрее.

4️⃣Повышенная отказоустойчивость:
✅Сбой одного микросервиса не приводит к остановке всего приложения. Это улучшает общую надежность системы.

5️⃣Упрощение разработки и обслуживания:
✅Меньшие по размеру и по объему функциональности микросервисы легче разрабатывать, тестировать и поддерживать. Команды могут работать над отдельными микросервисами параллельно, что увеличивает скорость разработки.

6️⃣Упрощение управления командами:
✅Разделение системы на микросервисы позволяет небольшим автономным командам работать независимо друг от друга, что улучшает управляемость и ускоряет разработку.

Минусы

1️⃣Сложность управления и мониторинга:
✅С ростом количества микросервисов увеличивается сложность управления системой. Необходимы продвинутые инструменты для мониторинга, логирования, трассировки и оркестрации микросервисов.

2️⃣Сложность в обеспечении консистентности данных:
✅Разделенные базы данных и распределенные транзакции усложняют обеспечение консистентности данных. Требуются дополнительные механизмы для управления распределенными данными.

3️⃣Повышенные накладные расходы на межсервисное взаимодействие:
✅Межсервисное взаимодействие происходит по сети, что добавляет накладные расходы и может влиять на производительность. Необходимы эффективные механизмы для управления сетевыми задержками и пропускной способностью.

4️⃣Сложность тестирования:
✅Тестирование распределенной системы сложнее, так как необходимо учитывать взаимодействие между микросервисами, сетевые задержки и потенциальные сбои.

5️⃣Требования к навыкам и опыту команды:
✅Команды должны обладать опытом и знаниями в области распределенных систем, управления контейнерами, оркестрации и DevOps.

6️⃣Повышенные затраты на инфраструктуру:
✅Поддержка микросервисной архитектуры требует более сложной инфраструктуры, включая оркестрацию контейнеров (например, Kubernetes), сервисные сетки (Service Mesh) и другие инструменты.

Примеры преимуществ и недостатков в сценариях

Пример 1: Масштабируемость

Сценарий: Веб-приложение с высокой нагрузкой на определенный функционал, например, обработка платежей.

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

Пример 2: Гибкость в выборе технологий

Сценарий: Приложение, состоящее из разных модулей, таких как анализ данных и управление пользователями.

Преимущество: Команда может выбрать Python для микросервиса анализа данных и Go для микросервиса управления пользователями, используя лучшие инструменты для каждой задачи.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Какие предельные значения int32 и int64 ?
Спросят с вероятностью 8%

Предельные значения типов int32 и int64 определяются количеством бит, отведенных для хранения этих значений. Поскольку int32 и int64 — знаковые целые числа, одно из бит используется для знака (положительное или отрицательное число).

Предельные значения для int32

✅Минимальное значение: -2,147,483,648
✅Максимальное значение: 2,147,483,647

Это потому, что:
✅он занимает 32 бита.
✅Из них 1 бит используется для знака, оставляя 31 бит для значения.
✅Диапазон значений определяется формулой: \(-2^{31}\) до \(2^{31} - 1\).

Предельные значения для int64

✅Минимальное значение: -9,223,372,036,854,775,808
✅Максимальное значение: 9,223,372,036,854,775,807

Это потому, что:
✅он занимает 64 бита.
✅Из них 1 бит используется для знака, оставляя 63 бита для значения.
✅Диапазон значений определяется формулой: \(-2^{63}\) до \(2^{63} - 1\).

Пример кода для демонстрации предельных значений

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

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Printf("int32 range: %d to %d\n", math.MinInt32, math.MaxInt32)
    fmt.Printf("int64 range: %d to %d\n", math.MinInt64, math.MaxInt64)
}

В этом примере используются константы math.MinInt32, math.MaxInt32, math.MinInt64 и math.MaxInt64 для вывода предельных значений типов int32 и int64.

✅Для int32 диапазон значений: от -2,147,483,648 до 2,147,483,647.
✅Для int64 диапазон значений: от -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Чем отличается микросервис от монолита ?
Спросят с вероятностью 8%

Монолит и микросервисы представляют два разных подхода к архитектуре ПО. Рассмотрим основные отличия между ними, а также их преимущества и недостатки.

Монолитная архитектура

Характеристики

1️⃣Единое приложение:
✅Вся функциональность приложения собрана в одном исполняемом файле или пакете.
✅Все модули и компоненты тесно связаны и взаимодействуют друг с другом внутри одного процесса.

2️⃣Единая кодовая база:
✅Весь код хранится в одном репозитории, что упрощает управление версиями и интеграцию.

3️⃣Общая база данных:
✅Часто используется одна база данных для всех модулей и компонентов приложения.

Преимущества

1️⃣Простота разработки и тестирования:
✅Легко настроить окружение для разработки.
✅Тестирование может быть проще, так как все компоненты находятся в одном процессе.

2️⃣Простота развертывания:
✅Можно развернуть всё приложение как одно целое.
✅Меньше проблем с интеграцией и совместимостью версий различных компонентов.

3️⃣Производительность:
✅Нет накладных расходов на межпроцессное взаимодействие, все вызовы происходят внутри одного процесса.

Недостатки

1️⃣Сложность масштабирования:
✅Масштабирование всего приложения сразу может быть неэффективным.
✅Трудно масштабировать только те части, которые испытывают наибольшую нагрузку.

2️⃣Сложность поддержки и обновления:
✅Изменение одного модуля может потребовать повторного развертывания всего приложения.
✅Риск появления неожиданных багов при изменении кода в разных модулях.

3️⃣Ограниченная гибкость:
✅Трудно использовать разные технологии и языки программирования для разных частей приложения.

Микросервисная архитектура

Характеристики

1️⃣Декомпозиция на отдельные сервисы:
✅Приложение разбивается на несколько независимых сервисов, каждый из которых отвечает за определенную функциональность.
✅Сервисы общаются друг с другом через определенные интерфейсы, обычно по сети (например, через HTTP/REST или gRPC).

2️⃣Независимая разработка и развертывание:
✅Каждый сервис может разрабатываться и разворачиваться независимо от других.

3️⃣Разные технологии и базы данных:
✅Для каждого сервиса можно использовать разные технологии, языки программирования и базы данных.

Преимущества

1️⃣Гибкость и масштабируемость:
✅Легко масштабировать только те сервисы, которые испытывают наибольшую нагрузку.
✅Возможность использования разных технологий для разных сервисов.

2️⃣Упрощение разработки и развертывания:
✅Маленькие команды могут работать над отдельными сервисами независимо.
✅Обновление одного сервиса не требует повторного развертывания всего приложения.

3️⃣Устойчивость и отказоустойчивость:
✅Сбой одного сервиса не приводит к остановке всего приложения.
✅Легче внедрять политику автоматического восстановления и балансировки нагрузки.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Какой результат получим если разделить int на 0 и float на 0 ?
Спросят с вероятностью 8%

Разделение числа на 0 — это особый случай в программировании, и поведение зависит от типа чисел. Для целочисленных и чисел с плавающей запятой поведение при делении на 0 различается.

Деление целого числа на 0

Если попытаться разделить целое число (int, int32, int64 и т.д.) на 0, то Go вызовет паническое состояние (runtime panic). Это происходит потому, что целочисленное деление на 0 является неопределенной операцией.

package main

func main() {
    var a int = 10
    var b int = 0
    result := a / b
    fmt.Println(result)
}

Этот код приведет к панике с ошибкой вида:

panic: runtime error: integer divide by zero

Деление числа с плавающей запятой на 0

Если разделить число с плавающей запятой (float32, float64) на 0, то Go не вызовет паники. Вместо этого будут использованы специальные значения IEEE 754: положительная бесконечность, отрицательная бесконечность или NaN (Not a Number), в зависимости от знака числителя.

package main

import (
    "fmt"
    "math"
)

func main() {
    var a float64 = 10.0
    var b float64 = 0.0

    // Деление положительного числа на 0
    positiveInf := a / b
    fmt.Println("Positive Infinity:", positiveInf) // Вывод: Positive Infinity: +Inf

    // Деление отрицательного числа на 0
    negativeInf := -a / b
    fmt.Println("Negative Infinity:", negativeInf) // Вывод: Negative Infinity: -Inf

    // Деление нуля на ноль
    zeroDivZero := b / b
    fmt.Println("Zero divided by Zero:", zeroDivZero) // Вывод: Zero divided by Zero: NaN

    // Проверка значений
    fmt.Println("Is Inf:", math.IsInf(positiveInf, 1)) // true
    fmt.Println("Is Inf:", math.IsInf(negativeInf, -1)) // true
    fmt.Println("Is NaN:", math.IsNaN(zeroDivZero)) // true
}

В этом примере:
✅Деление положительного числа на 0 дает положительную бесконечность (+Inf).
✅Деление отрицательного числа на 0 дает отрицательную бесконечность (-Inf).
✅Деление нуля на ноль дает NaN.

✅Деление целого числа на 0 в Go вызывает паническое состояние (runtime panic).
✅Деление числа с плавающей запятой на 0 в Go приводит к бесконечности (+Inf, -Inf) или NaN без вызова паники.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое РПС ?
Спросят с вероятностью 8%

РПС (Remote Procedure Call, удаленный вызов процедуры) — это протокол или технология, позволяющая программе вызвать процедуру или функцию, которая выполняется на удаленном сервере, так, как если бы она выполнялась локально. Абстрагирует детали сетевого взаимодействия, предоставляя разработчикам простой способ взаимодействия с удаленными сервисами и обмена данными между различными системами.

Основные компоненты

1️⃣Клиент:
✅Инициатор вызова удаленной процедуры. Клиент отправляет запрос серверу, который содержит имя процедуры и необходимые параметры.

2️⃣Сервер:
✅Исполнитель удаленной процедуры. Сервер принимает запрос, выполняет указанную процедуру и возвращает результат клиенту.

3️⃣Сетевой транспорт:
✅Среда, через которую передаются запросы и ответы между клиентом и сервером. Обычно это TCP/IP, но могут использоваться и другие протоколы.

Принцип работы

1️⃣Клиент вызывает процедуру:
✅Клиент вызывает локальную процедуру, которая на самом деле является прокси (stub) для удаленной процедуры.

2️⃣Прокси (stub) клиента:
✅Прокси берет параметры вызова, сериализует их (преобразует в формат, подходящий для передачи по сети), и отправляет на сервер.

3️⃣Серверный прокси (stub):
✅Прокси на стороне сервера получает запрос, десериализует параметры, вызывает соответствующую процедуру на сервере и получает результат.

4️⃣Выполнение процедуры на сервере:
✅Сервер выполняет указанную процедуру с переданными параметрами и возвращает результат прокси сервера.

5️⃣Возврат результата клиенту:
✅Серверный прокси сериализует результат и отправляет его обратно клиентскому прокси.

6️⃣Получение результата клиентом:
✅Клиентский прокси получает ответ, десериализует результат и возвращает его исходной процедуре, вызвавшей РПС.

Преимущества

✅Прозрачность: Можно вызывать удаленные процедуры так же, как локальные, не задумываясь о сетевом взаимодействии.
✅Многоязыковая поддержка: РПС можно использовать для взаимодействия между программами, написанными на разных языках программирования.
✅Модульность: Позволяет разделять системы на модули и вызывать функции одного модуля из другого через сеть.

Недостатки

✅Задержки: Вызовы через сеть могут быть медленнее, чем локальные вызовы из-за сетевых задержек.
✅Надежность: Сеть может быть ненадежной, и необходимо учитывать возможность сбоев при передаче данных.
✅Безопасность: Взаимодействие через сеть требует дополнительных мер безопасности для защиты данных.

gRPC (Google Remote Procedure Call)

Современная реализация РПС от Google, которая использует HTTP/2 для транспортного уровня и Protocol Buffers для сериализации данных.

// Пример использования gRPC в Go

// Определение службы в .proto файле
syntax = "proto3";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

// Сгенерированный серверный код
package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/your/protobuf/generated/code"
)

type server struct {
    pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

РПС (Remote Procedure Call) — это технология, позволяющая вызывать процедуры, выполняемые на удаленном сервере, так же, как если бы они выполнялись локально. Это упрощает разработку распределенных систем, обеспечивая прозрачное взаимодействие между различными компонентами через сеть.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых

Что такое хеш-функция ?
Спросят с вероятностью 8%

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

Основные свойства

1️⃣Детерминированность:
✅Для одного и того же входного значения хеш-функция всегда должна возвращать одно и то же хеш-значение.

2️⃣Быстрота вычисления:
✅Хеш-функция должна быть достаточно быстрой для вычисления хеша даже для больших объемов данных.

3️⃣Равномерное распределение:
✅Хорошая хеш-функция равномерно распределяет входные данные по всем возможным хеш-значениям, чтобы минимизировать количество коллизий.

4️⃣Коллизии:
✅Коллизия возникает, когда два разных входных значения дают одинаковое хеш-значение. Хорошая хеш-функция минимизирует вероятность коллизий, но они не могут быть полностью исключены.

Хеш-таблицы

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

package main

import (
    "fmt"
    "hash/fnv"
)

// Пример простой хеш-функции для строки
func hash(s string) uint32 {
    h := fnv.New32a()
    h.Write([]byte(s))
    return h.Sum32()
}

func main() {
    keys := []string{"Alice", "Bob", "Charlie"}
    for _, key := range keys {
        fmt.Printf("Hash for %s: %d\n", key, hash(key))
    }
}

Контроль целостности данных

Используются для проверки целостности данных. Например, алгоритмы контрольных сумм (checksum) или криптографические хеш-функции (SHA-256) позволяют убедиться, что данные не были изменены.

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    data := "Hello, World!"
    hash := sha256.Sum256([]byte(data))
    fmt.Printf("SHA-256 hash: %x\n", hash)
}

Простая функция

package main

import "fmt"

// Простая хеш-функция для строк
func simpleHash(s string) int {
    hash := 0
    for _, char := range s {
        hash += int(char)
    }
    return hash
}

func main() {
    keys := []string{"Alice", "Bob", "Charlie"}
    for _, key := range keys {
        fmt.Printf("Simple hash for %s: %d\n", key, simpleHash(key))
    }
}

Сложные

FNV-1a

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

package main

import (
    "fmt"
    "hash/fnv"
)

// Хеш-функция FNV-1a для строк
func fnvHash(s string) uint32 {
    h := fnv.New32a()
    h.Write([]byte(s))
    return h.Sum32()
}

func main() {
    keys := []string{"Alice", "Bob", "Charlie"}
    for _, key := range keys {
        fmt.Printf("FNV-1a hash for %s: %d\n", key, fnvHash(key))
    }
}

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 349 вопроса на Golang разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых