Это интерфейс, содержащий метод Close() error, который сигнализирует об освобождении ресурсов, например, файлов или соединений. Если объект реализует Closer, его можно безопасно завершить, вызвав Close, что предотвращает утечки ресурсов.
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
🔥2👍1
HAVING
— это оператор в SQL, который фильтрует группированные (GROUP BY
) данные по агрегатным функциям (SUM
, COUNT
, AVG
, MAX
, MIN
). WHERE
фильтрует отдельные строки до группировки. HAVING
фильтрует группы строк после GROUP BY
. Теперь посчитаем сумму продаж по категориям и оставим только те, где сумма > 250
SELECT category, SUM(amount) AS total_sales
FROM sales
GROUP BY category
HAVING SUM(amount) > 250;
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍4
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3💊1
Интерфейсы имеют ряд уникальных особенностей и отличий от интерфейсов в других языках программирования, таких как Java, C# или C++.
В Go типы реализуют интерфейсы неявно. Это означает, что если тип имеет методы, определенные в интерфейсе, он автоматически считается реализацией этого интерфейса без явного указания.
package main
import "fmt"
type Stringer interface {
String() string
}
type Person struct {
Name string
Age int
}
func (p Person) String() string {
return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}
func main() {
var s Stringer = Person{Name: "Alice", Age: 30}
fmt.Println(s.String())
}
В Go нет явного наследования интерфейсов или типов. Интерфейсы могут быть составлены из других интерфейсов с помощью композиции, но это не считается наследованием в традиционном смысле.
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
type ReadWriter interface {
Reader
Writer
}
В Go нет методов доступа (getter и setter), как в некоторых других языках. Методы интерфейсов определяются исключительно для реализации логики.
В Go часто используются маленькие и простые интерфейсы с одним или двумя методами. Это позволяет создавать более гибкие и переиспользуемые компоненты.
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
Интерфейсы в Go могут быть составлены из других интерфейсов, что позволяет строить сложные интерфейсы из простых.
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
type ReadWriter interface {
Reader
Writer
}
В Go есть специальный пустой интерфейс
interface{}
, который может содержать значение любого типа. Это делает его мощным инструментом для работы с обобщенным кодом.func printValue(v interface{}) {
fmt.Println(v)
}
func main() {
printValue(42)
printValue("hello")
printValue(true)
}
Интерфейсы в Java и C# требуют явного указания, какие классы реализуют интерфейсы с использованием ключевого слова
implements
. Явное наследование интерфейсов. Методы доступа часто используются. Интерфейсы могут содержать свойства (в C#), которые требуют реализации.Интерфейсы часто реализуются с использованием чисто виртуальных функций. Классы должны явно указывать наследование от интерфейсов. Наследование интерфейсов и классов явно указывается.
Используется динамическая типизация и протоколы, похожие на интерфейсы. Протоколы не требуют явного указания реализации. Python использует утиную типизацию, похожую на неявную реализацию интерфейсов в Go.
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2
Дополнительно есть:
- Глобальная очередь, из которой P может забирать задачи, если его собственная очередь пуста.
- Stealing-механизм — если P простаивает, он может "украсть" goroutine из другой очереди.
Итого:
- У каждого логического процессора (P) — своя очередь.
- Плюс одна глобальная очередь.
- Всего: N локальных + 1 глобальная очередь.
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3
Оптимизация кода в Go может быть выполнена на нескольких уровнях:
Использование более эффективных алгоритмов (например,
O(log n)
вместо O(n^2)
). Выбор подходящих структур данных (например, map
вместо срезов для поиска по ключу). Снижение количества аллокаций (использование
sync.Pool
, предварительное выделение памяти). Использование []byte
вместо string
, если требуется частое изменение строки. Минимизация копирования данных, например, передача []byte
по ссылке вместо копирования. Использование
worker pool
, чтобы избежать избыточного создания горутин. Ограничение количества параллельных задач (runtime.GOMAXPROCS
). Использование каналов правильной ёмкости для минимизации блокировок. Буферизация (
bufio.Reader
, bufio.Writer
). Использование асинхронных операций при работе с файлами или сетью. Использование io.Pipe()
для потоковой обработки данных. pprof
для анализа CPU, памяти и блокировок. race detector
(-race
флаг) для выявления проблем с конкурентным доступом. Инструменты трассировки (trace
). Пример неэффективного кода
func inefficient() []string {
var result []string
for i := 0; i < 1000; i++ {
result = append(result, fmt.Sprintf("Item %d", i)) // Частые аллокации
}
return result
}
Оптимизированный вариант
func efficient() []string {
result := make([]string, 0, 1000) // Выделяем память заранее
for i := 0; i < 1000; i++ {
result = append(result, fmt.Sprintf("Item %d", i))
}
return result
}
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍1
Это оператор SQL, который применяется после GROUP BY и используется для фильтрации агрегированных данных (SUM, COUNT, AVG).
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2
Существует один основной цикл — это цикл for. н может использоваться в различных формах, выполняя функции традиционных циклов
while
, do-while
и классического for
.С тремя выражениями
package main
import "fmt"
func main() {
for i := 0; i < 5; i++ {
fmt.Println(i)
}
}
Как
while
package main
import "fmt"
func main() {
i := 0
for i < 5 {
fmt.Println(i)
i++
}
}
Бесконечный
package main
import "fmt"
func main() {
i := 0
for {
if i >= 5 {
break
}
fmt.Println(i)
i++
}
}
С использованием range
package main
import "fmt"
func main() {
arr := []int{1, 2, 3, 4, 5}
for index, value := range arr {
fmt.Printf("Index: %d, Value: %d\n", index, value)
}
}
Итерация по массиву
arr := [5]int{10, 20, 30, 40, 50}
for i := 0; i < len(arr); i++ {
fmt.Println(arr[i])
}
Итерация по карте
m := map[string]int{"a": 1, "b": 2, "c": 3}
for key, value := range m {
fmt.Printf("Key: %s, Value: %d\n", key, value)
}
Итерация по строке
s := "hello"
for index, char := range s {
fmt.Printf("Index: %d, Char: %c\n", index, char)
}
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2
Горутины и потоки (треды) в традиционном понимании операционных систем — это две различные концепции параллельного выполнения кода, каждая из которых имеет свои особенности и преимущества. Вот ключевые различия между ними.
Горутины — это легковесные "зеленые" потоки, управляемые Go runtime. Они не являются потоками операционной системы, и Go runtime отвечает за их планирование и выполнение на доступных физических потоках. Это позволяет создавать тысячи и даже миллионы горутин в рамках одного приложения с относительно небольшими затратами памяти и CPU.
Треды — это потоки выполнения, управляемые непосредственно операционной системой. Каждый тред занимает значительно больше ресурсов, чем горутина, особенно в плане памяти и времени на создание и управление. Треды более подходят для задач, требующих высокой вычислительной мощности и прямого взаимодействия с операционной системой.
Горутины потребляют гораздо меньше памяти по сравнению с тредами. Например, стек горутины начинается с нескольких килобайт, что значительно уменьшает затраты при масштабировании.
Треды требуют большего количества памяти для каждого стека, обычно начиная от нескольких сотен килобайт до мегабайтов. Это ограничивает количество потоков, которые могут быть активными одновременно без значительного увеличения затрат на ресурсы.
Горутины могут масштабироваться до большого количества параллельных задач благодаря меньшим требованиям к ресурсам и управлению со стороны runtime Go.
Треды ограничены в масштабируемости физическими ресурсами системы и более высокими затратами на управление.
Горутины имеют намного более эффективный контекст переключения, так как Go runtime оптимизирован для работы с большим количеством горутин и их переключением.
Треды терпят большие затраты времени на переключение контекста, так как операционной системе требуется больше времени для управления потоками.
package main
import (
"fmt"
"time"
)
func say(text string) {
for i := 0; i < 5; i++ {
fmt.Println(text)
time.Sleep(time.Millisecond * 500)
}
}
func main() {
go say("Hello")
say("World")
}
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3💊1
default выполняется, если ни один из каналов в select не готов. Это предотвращает блокировку горутины, позволяя ей продолжить выполнение программы.
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍4
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
💊7👍2
Когда сервер тормозит, важно быстро найти причину. Разберём основные направления диагностики.
Сначала проверяем логи!
Системные логи (
journalctl -u myservice
, /var/log/syslog
, /var/log/messages
) Логи приложения (например,
logs/app.log
) Nginx / Apache (
/var/log/nginx/error.log
, /var/log/httpd/error.log
) Пример просмотра последних 100 строк лога:
tail -n 100 /var/log/syslog
Если используете
docker
: docker logs my_container --tail 100 -f
Проверяем, не перегружен ли сервер:
top
htop # Более удобный интерфейс
Или просто:
ps aux --sort=-%cpu | head -10 # Топ-10 процессов по CPU
ps aux --sort=-%mem | head -10 # Топ-10 процессов по памяти
Если процесс
"myapp"
жрет CPU, смотрим его нагрузку: pidstat -p $(pgrep myapp)
Проверяем сетевую активность:
netstat -tulnp # Слушающие порты
ss -tulnp # Альтернатива netstat
Пингуем сервер:
ping google.com
Проверяем скорость соединения:
wget --output-document=/dev/null http://speedtest.tele2.net/10MB.zip
Проверяем, не забит ли диск:
df -h # Свободное место
du -sh /* | sort -h # Топ занимаемых мест
Мониторинг активности диска:
iotop # Если доступен
Если сервер использует PostgreSQL / MySQL, смотрим запросы:
SHOW PROCESSLIST; # MySQL: текущие запросы
SELECT * FROM pg_stat_activity; # PostgreSQL: активные запросы
Проверяем медленные запросы (если включен
slow_query_log
): tail -n 100 /var/log/mysql/slow.log
---
Включаем pprof и анализируем:
import _ "net/http/pprof"
go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()
Запускаем профайлер:
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍6
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍5🔥3
Тип rune представляет собой alias для типа
int32
, предназначенного для хранения Unicode кодовых точек.Строки (
string
) являются последовательностями байтов, а не символов. Это означает, что один символ может занимать больше одного байта, особенно если это символ из расширенного набора Unicode.Тип используется для работы с символами, представляемыми одной кодовой точкой Unicode. Это упрощает манипуляции с символами, так как каждая
rune
— это отдельный символ, независимо от его длины в байтах.Использование типа
rune
делает код более понятным и само-документируемым. Когда в коде виден тип rune
, это сразу указывает на то, что переменная предназначена для хранения одного символа, а не целого числа.Создание и инициализация
var r rune = '世'
fmt.Println(r) // Output: 19990
Итерация по строке
s := "Привет, 世界"
for _, r := range s {
fmt.Printf("%c ", r)
}
// Output: П р и в е т , 世 界
Преобразование между
string
ито такоеs := "Go"
runes := []rune(s)
fmt.Println(runes) // Output: [71 111]
s2 := string(runes)
fmt.Println(s2) // Output: Go
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍4
Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
🤔21💊15👍1
Нарезка (slicing) — это создание нового слайса, который указывает на подмножество элементов исходного слайса. Этот процесс включает указание начального и конечного индексов для создания нового слайса. Несмотря на свою простоту, slicing имеет несколько нюансов и потенциальных подводных камней, которые важно учитывать.
Синтаксис
newSlice := originalSlice[start:end]
start
: начальный индекс (включительно).end
: конечный индекс (исключительно).Пример
package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
newSlice := original[1:4] // Элементы с индексами 1, 2 и 3
fmt.Println(newSlice) // [2 3 4]
}
При нарезке слайса важно, чтобы индексы
start
и end
были в пределах длины исходного слайса. Нарушение этого правила приведет к панике (runtime panic).package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
// Это вызовет панику: runtime error: slice bounds out of range
// newSlice := original[1:6]
// Правильное использование
newSlice := original[1:5]
fmt.Println(newSlice) // [2 3 4 5]
}
Слайсы в Go работают как ссылки на массивы. Это означает, что если вы модифицируете элементы нового слайса, то изменения отразятся и в исходном слайсе.
package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
newSlice := original[1:4]
newSlice[0] = 20
fmt.Println("Original:", original) // [1 20 3 4 5]
fmt.Println("New Slice:", newSlice) // [20 3 4]
}
Длина нового слайса определяется как
end - start
. Емкость нового слайса определяется как cap(original) - start
.package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
newSlice := original[1:4]
fmt.Println("New Slice Length:", len(newSlice)) // 3
fmt.Println("New Slice Capacity:", cap(newSlice)) // 4
}
Если нужно создать независимую копию слайса, следует использовать функцию
copy
, чтобы изменения в новом слайсе не влияли на исходный.package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
newSlice := make([]int, 3)
copy(newSlice, original[1:4])
newSlice[0] = 20
fmt.Println("Original:", original) // [1 2 3 4 5]
fmt.Println("New Slice:", newSlice) // [20 3 4]
}
Полная форма нарезки позволяет явно указать емкость нового слайса:
newSlice := original[start:end:max
Это полезно, когда вы хотите контролировать емкость нового слайса.
package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
newSlice := original[1:3:4]
fmt.Println("New Slice:", newSlice) // [2 3]
fmt.Println("New Slice Capacity:", cap(newSlice)) // 3
}
Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍4
map
? Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3🔥1