Ответ
Императивный подход описывает как выполнить задачу, явно указывая последовательность шагов (например, циклы, условия). Декларативный — что нужно получить, скрывая детали реализации.
Пример на Go:
// Императивный стиль: суммируем четные числа
sum := 0
nums := []int{1, 2, 3, 4}
for _, num := range nums {
if num%2 == 0 {
sum += num
}
}
// sum = 6
// Декларативный стиль (используя функции из пакета slices, Go 1.21+)
// Сначала фильтруем, затем редуцируем (суммируем)
// (Для slices.Reduce и slices.Filter требуется импорт "golang.org/x/exp/slices" или Go 1.21+)
// import "slices" // для Go 1.21+
// import "golang.org/x/exp/slices" // для более старых версий Go
// Пример использования slices.Filter и slices.Reduce (требует Go 1.21+)
// filtered := slices.Filter(nums, func(n int) bool { return n%2 == 0 })
// evenSum := slices.Reduce(filtered, func(a, b int) int { return a + b }, 0)
// evenSum = 6
// Более простой декларативный пример в Go (без сторонних пакетов, через композицию функций)
// Хотя Go не является чисто декларативным языком, можно писать в более декларативном стиле.
// Например, используя функции высшего порядка или функциональные опции.
// func SumEven(numbers []int) int {
// return Sum(Filter(numbers, IsEven))
// }
// func IsEven(n int) bool { return n%2 == 0 }
// func Filter(numbers []int, predicate func(int) bool) []int { ... }
// func Sum(numbers []int) int { ... }Ключевое отличие: в императивном коде управление потоком явное, а в декларативном логика выражается через композицию функций, DSL (Domain Specific Language) или абстракции, скрывающие детали выполнения.
Ответ 18+ 🔞
Да ты посмотри, какой прикол! Вот сидишь ты, пишешь код, а тут, блядь, целая философия подъезжает — императивный и декларативный подходы. Сука, как будто выбор между "иди туда, не знаю куда" и "принеси то, не знаю что".
Императивный — это как ты своему корешу, который нихуя не шарит, объясняешь, как чай заварить: "Берёшь чайник, сука, наливаешь воду, включаешь, ждёшь, пока закипит, ёпта, потом в кружку засыпаешь заварку, блядь, льешь кипяток, ждёшь три минуты, ну ты понял". Каждый шаг, каждый чих — всё расписано. В коде это вот эти вот циклы, условия, переменные, которые ты, как обезьяна, перекладываешь.
sum := 0
nums := []int{1, 2, 3, 4}
for _, num := range nums {
if num%2 == 0 {
sum += num
}
}Видишь? "Берём sum, обнуляем. Берём массив nums. Бежим по нему, блядь, циклом. Если число чётное — добавляем к sum". Прямо как инструкция для мартышлюшки.
А теперь, внимание, ёпта, декларативный подход! Это как прийти в бар и сказать: "Мне пива, холодного". И всё. Ты не объясняешь бармену, как открыть холодильник, как наклонить бутылку, как открутить крышку. Ты сказал, ЧТО ты хочешь, а КАК это сделать — его, блядь, собачье дело.
В Го, конечно, не самый нативный пример, но суть та же. Вместо того чтобы расписывать цикл, ты как бы говоришь: "Эй, функция, дай мне отфильтрованные чётные числа и просуммируй их". Детали — где-то там, внутри, тебя не ебёт.
// (Представь, что у нас есть эти функции, как в примере выше)
// evenSum := Sum(Filter(nums, IsEven))Вот в чём, сука, парадокс! Императивный — ты царь и бог, контролируешь каждый чих. Декларативный — ты начальник, который ставит задачу: "Мне нужен результат, а как вы его получите — ваши проблемы, я спать пошёл".
И знаешь что самое охуенное? Когда проект растёт, этот декларативный стиль, если его грамотно применить, может сделать код читаемее, блядь. Потому что ты видишь не кучу циклов, а названия операций: Filter, Sum, Transform. Сразу понятно, что происходит, а не "чё это за хуйня в 15 строк, где переменную i на j меняют".
Но Го, он, конечно, больше императивный парень по натуре. Хотя с дженериками и пакетом slices в новых версиях уже можно такие декларативные штуки вытворять, что мама не горюй. Главное — не переборщить, а то получится не код, а заумная пиздопроебибна, которую потом ни ты, ни кто другой не разберёт.
Короче, выбор за тобой: либо ты микроменеджер в коде, либо делегируешь задачи абстракциям. А хуй его знает, что лучше. Иногда проще написать простой цикл и не ебать себе мозг.