Присоединяйтесь к каналу 'Golang | Вопросы собесов', чтобы успешно подготовиться к собеседованиям по языку программирования Golang. Канал @easy_golang предлагает широкий выбор тестов, задач и информацию о вакансиях для тех, кто интересуется работой с Golang.
На канале вы найдете полезные материалы, которые помогут вам улучшить свои навыки программирования на Golang. Используйте предоставленные тесты для проверки своих знаний и подготовки к собеседованиям. Решайте задачи, чтобы оттачивать свое мастерство и становиться более опытным разработчиком. Кроме того, канал предоставляет информацию о вакансиях, позволяя вам искать подходящую работу в сфере Golang.
Не упустите возможность быть в курсе последних трендов и развивать свои профессиональные навыки. Присоединяйтесь к каналу 'Golang | Вопросы собесов' прямо сейчас и станьте экспертом в области программирования на Golang!
12 Feb, 16:10
12 Feb, 09:10
struct. В структуре могут быть поля различных типов.package main
import "fmt"
// Определение структуры Person
type Person struct {
Name string
Age int
}
func main() {
// Создание экземпляра структуры
var p Person
p.Name = "Alice"
p.Age = 30
fmt.Println("Name:", p.Name)
fmt.Println("Age:", p.Age)
}
package main
import "fmt"
// Определение структуры Person
type Person struct {
Name string
Age int
}
func main() {
// Инициализация с использованием литерала структуры
p := Person{Name: "Bob", Age: 25}
fmt.Println("Name:", p.Name)
fmt.Println("Age:", p.Age)
}
package main
import "fmt"
// Определение структуры Person
type Person struct {
Name string
Age int
}
func main() {
// Инициализация по умолчанию (поля будут нулевыми значениями)
var p Person
fmt.Println("Name:", p.Name) // Пустая строка
fmt.Println("Age:", p.Age) // 0
}
package main
import "fmt"
// Определение структур Address и Person
type Address struct {
City string
State string
}
type Person struct {
Name string
Age int
Address Address
}
func main() {
// Инициализация структуры с вложенной структурой
p := Person{
Name: "Charlie",
Age: 40,
Address: Address{
City: "New York",
State: "NY",
},
}
fmt.Println("Name:", p.Name)
fmt.Println("Age:", p.Age)
fmt.Println("City:", p.Address.City)
fmt.Println("State:", p.Address.State)
}
package main
import "fmt"
// Определение структуры Person
type Person struct {
Name string
Age int
}
// Метод для структуры Person
func (p Person) Greet() {
fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}
func main() {
p := Person{Name: "David", Age: 35}
p.Greet()
}
12 Feb, 07:00
11 Feb, 16:10
11 Feb, 09:10
prometheus/client_golangpackage main
import (
"net/http"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
)
var httpRequests = prometheus.NewCounter(
prometheus.CounterOpts{
Name: "http_requests_total",
Help: "Total number of HTTP requests",
},
)
func handler(w http.ResponseWriter, r *http.Request) {
httpRequests.Inc() // Увеличиваем счетчик запросов
w.Write([]byte("Hello, Prometheus!"))
}
func main() {
// Регистрируем метрику
prometheus.MustRegister(httpRequests)
// Эндпоинт для сбора метрик
http.Handle("/metrics", promhttp.Handler())
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
10 Feb, 20:14
10 Feb, 16:10
10 Feb, 09:10
09 Feb, 16:10
09 Feb, 09:10
iota в одной группе констант увеличивает его значение на 1.iota сбрасывается до 0.package main
import "fmt"
const (
A = iota // 0
B // 1
C // 2
)
func main() {
fmt.Println(A) // Вывод: 0
fmt.Println(B) // Вывод: 1
fmt.Println(C) // Вывод: 2
}
package main
import "fmt"
const (
Flag1 = 1 << iota // 1 << 0 = 1
Flag2 // 1 << 1 = 2
Flag3 // 1 << 2 = 4
Flag4 // 1 << 3 = 8
)
func main() {
fmt.Println(Flag1) // Вывод: 1
fmt.Println(Flag2) // Вывод: 2
fmt.Println(Flag3) // Вывод: 4
fmt.Println(Flag4) // Вывод: 8
}
package main
import "fmt"
const (
X = iota // 0
Y // 1
)
const (
Z = iota // 0 (новый блок констант, iota сбрасывается)
W // 1
)
func main() {
fmt.Println(X) // Вывод: 0
fmt.Println(Y) // Вывод: 1
fmt.Println(Z) // Вывод: 0
fmt.Println(W) // Вывод: 1
}
package main
import "fmt"
const (
_ = iota // пропускаем 0
KB = 1 << (10 * iota) // 1 << 10 = 1024
MB // 1 << 20 = 1048576
GB // 1 << 30 = 1073741824
)
func main() {
fmt.Println("KB:", KB) // Вывод: KB: 1024
fmt.Println("MB:", MB) // Вывод: MB: 1048576
fmt.Println("GB:", GB) // Вывод: GB: 1073741824
}
08 Feb, 23:42
08 Feb, 16:10
08 Feb, 09:10
value := myMap[key]
package main
import "fmt"
func main() {
myMap := map[string]int{
"Alice": 25,
"Bob": 30,
}
value := myMap["Alice"]
fmt.Println("Alice:", value) // Alice: 25
}
value, exists := myMap[key]
package main
import "fmt"
func main() {
myMap := map[string]int{
"Alice": 25,
"Bob": 30,
}
value, exists := myMap["Charlie"]
if exists {
fmt.Println("Charlie:", value)
} else {
fmt.Println("Charlie not found")
}
}
myMap[key] = value
package main
import "fmt"
func main() {
myMap := map[string]int{}
// Добавление значений
myMap["Alice"] = 25
myMap["Bob"] = 30
fmt.Println("Map:", myMap) // Map: map[Alice:25 Bob:30]
// Обновление значения
myMap["Alice"] = 26
fmt.Println("Updated Map:", myMap) // Updated Map: map[Alice:26 Bob:30]
}
delete:delete(myMap, key)
package main
import "fmt"
func main() {
myMap := map[string]int{
"Alice": 25,
"Bob": 30,
}
// Удаление значения по ключу
delete(myMap, "Alice")
fmt.Println("Map after deletion:", myMap) // Map after deletion: map[Bob:30]
}
map[string]int это будет 0.package main
import "fmt"
func main() {
myMap := map[string]int{
"Alice": 25,
}
value := myMap["Bob"] // Ключ "Bob" отсутствует
fmt.Println("Value:", value) // Value: 0
}
nil карту. Это приведет к панике времени выполнения.package main
func main() {
var myMap map[string]int // nil карта
myMap["Alice"] = 25 // Вызовет панику: runtime error: assignment to entry in nil map
}
package main
import "fmt"
func main() {
myMap := map[string]int{
"Alice": 25,
"Bob": 30,
"Carol": 35,
}
for key, value := range myMap {
fmt.Printf("%s: %d\n", key, value)
}
}
07 Feb, 16:10
07 Feb, 09:10
06 Feb, 16:10
06 Feb, 09:10
http_requests_total{job="web_service"}05 Feb, 16:10
05 Feb, 09:10
map, после которого указываются типы ключей и значений.var myMap map[string]int
make или литерала карты.// Инициализация с помощью make
myMap = make(map[string]int)
// Инициализация с помощью литерала карты
myMap = map[string]int{
"Alice": 25,
"Bob": 30,
}
myMap["Charlie"] = 35
myMap["Alice"] = 26 // обновление значения по ключу "Alice"
age := myMap["Alice"]
fmt.Println(age) // 26
age, exists := myMap["David"]
if exists {
fmt.Println("Age of David:", age)
} else {
fmt.Println("David not found")
}
delete.delete(myMap, "Bob")
for range.for key, value := range myMap {
fmt.Printf("Key: %s, Value: %d\n", key, value)
}package main
import (
"fmt"
)
func main() {
// Инициализация карты с помощью литерала
myMap := map[string]int{
"Alice": 25,
"Bob": 30,
}
// Добавление нового элемента
myMap["Charlie"] = 35
// Обновление существующего элемента
myMap["Alice"] = 26
// Извлечение значения по ключу
age := myMap["Alice"]
fmt.Println("Age of Alice:", age) // 26
// Проверка существования ключа
age, exists := myMap["David"]
if exists {
fmt.Println("Age of David:", age)
} else {
fmt.Println("David not found")
}
// Удаление элемента
delete(myMap, "Bob")
// Итерация по карте
for key, value := range myMap {
fmt.Printf("Key: %s, Value: %d\n", key, value)
}
}
04 Feb, 16:10
04 Feb, 09:10
go func() {
fmt.Println("Привет из горутины!")
}()pthread в Linux, Windows Thread в Windows). M зависит от GOMAXPROCS, но обычно Go создаёт столько потоков, сколько ядер в системе. runtime.GOMAXPROCS(4) // Использовать 4 ядра процессора
G) между потоками (M). P управляет очередью горутин и раздаёт их потокам (M). P равно количеству GOMAXPROCS. P. [Processor P1] ----> [Machine M1] ----> Выполняет горутины G1, G2
[Processor P2] ----> [Machine M2] ----> Выполняет горутины G3, G4
03 Feb, 16:10
03 Feb, 09:10
WHERE col1 = X AND col2 = Y), составной индекс ускоряет их выполнение.ORDER BY col1, col2, индекс помогает избежать дополнительной сортировки.CREATE INDEX idx_name ON users (last_name, first_name);
SELECT * FROM users WHERE last_name = 'Иванов' AND first_name = 'Петр';
02 Feb, 16:10
02 Feb, 09:10
package main
import "fmt"
func main() {
sum := 0
for i := 1; i <= 5; i++ {
sum += i // Явно изменяем переменную sum
}
fmt.Println("Сумма:", sum)
}
map, filter через срезы и функции высшего порядка. package main
import "fmt"
func mapSlice(slice []int, f func(int) int) []int {
result := make([]int, len(slice))
for i, v := range slice {
result[i] = f(v) // Декларативное применение функции к элементам
}
return result
}
func main() {
nums := []int{1, 2, 3, 4, 5}
squared := mapSlice(nums, func(n int) int { return n * n })
fmt.Println(squared) // [1 4 9 16 25]
}
01 Feb, 16:10
01 Feb, 09:10
interface{} является особым типом, который может содержать значение любого типа. Это связано с тем, что в Go любой тип реализует пустой интерфейс, поскольку в нем нет методов, которые нужно реализовать. type interface{} interface {}nil или происходит паника, если приведение выполнено без проверки.package main
import "fmt"
func main() {
var i interface{}
i = 42
fmt.Println(i) // 42
i = "hello"
fmt.Println(i) // hello
}
package main
import "fmt"
func main() {
var i interface{} = "hello"
// Утверждение типа с проверкой
s, ok := i.(string)
if ok {
fmt.Println("String:", s)
} else {
fmt.Println("Not a string")
}
// Утверждение типа без проверки
// Это вызовет панику, если тип не соответствует
s = i.(string)
fmt.Println("String:", s)
}
package main
import "fmt"
func printType(i interface{}) {
switch v := i.(type) {
case string:
fmt.Println("String:", v)
case int:
fmt.Println("Integer:", v)
case bool:
fmt.Println("Boolean:", v)
default:
fmt.Printf("Unknown type: %T\n", v)
}
}
func main() {
printType("hello")
printType(42)
printType(true)
printType(3.14)
}
31 Jan, 16:10
31 Jan, 09:10
struct).type Person struct {
Name string
Age int
}
func (p *Person) Greet() {
fmt.Printf("Hello, my name is %s\n", p.Name)
}type Employee struct {
Person
Position string
}type Person struct {
name string // неэкспортируемое поле
Age int // экспортируемое поле
}type Greeter interface {
Greet()
}
type Person struct {
Name string
}
func (p *Person) Greet() {
fmt.Printf("Hello, my name is %s\n", p.Name)
}public class Person {
public string Name { get; set; }
public int Age { get; set; }
public void Greet() {
Console.WriteLine($"Hello, my name is {Name}");
}
}public class Employee : Person {
public string Position { get; set; }
}public, private, protected).public class Person {
private string name;
public int Age { get; set; }
}public class Person {
public virtual void Greet() {
Console.WriteLine("Hello!");
}
}
public class Employee : Person {
public override void Greet() {
Console.WriteLine("Hello, I am an employee!");
}
}30 Jan, 16:10
30 Jan, 09:10
29 Jan, 16:10
29 Jan, 09:10
copy или методы, такие как использование append.package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
// Создаем новый слайс той же длины, что и оригинал
copySlice := make([]int, len(original))
// Копируем элементы из оригинального слайса в новый
copy(copySlice, original)
// Изменяем элемент в копии
copySlice[0] = 100
fmt.Println("Оригинал:", original) // Выводит: Оригинал: [1 2 3 4 5]
fmt.Println("Копия:", copySlice) // Выводит: Копия: [100 2 3 4 5]
}
inal)
package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
// Копируем элементы из оригинального слайса в новый слайс
copySlice := append([]int(nil), original...)
// Изменяем элемент в копии
copySlice[0] = 100
fmt.Println("Оригинал:", original) // Выводит: Оригинал: [1 2 3 4 5]
fmt.Println("Копия:", copySlice) // Выводит: Копия: [100 2 3 4 5]
}
28 Jan, 16:10
28 Jan, 09:10
sync.WaitGroup. Вот каждый из этих методов.package main
import (
"fmt"
"sync"
"time"
)
func worker(stopCh <-chan struct{}, wg *sync.WaitGroup, id int) {
defer wg.Done()
for {
select {
case <-stopCh:
fmt.Printf("Worker %d stopping\n", id)
return
default:
// выполнение полезной работы
fmt.Printf("Worker %d working\n", id)
time.Sleep(time.Second)
}
}
}
func main() {
var wg sync.WaitGroup
stopCh := make(chan struct{})
// запуск горутин
for i := 0; i < 3; i++ {
wg.Add(1)
go worker(stopCh, &wg, i)
}
// остановка горутин после 3 секунд
time.Sleep(3 * time.Second)
close(stopCh) // отправка сигнала всем горутинам остановиться
wg.Wait() // ожидание завершения всех горутин
}
package main
import (
"context"
"fmt"
"sync"
"time"
)
func worker(ctx context.Context, wg *sync.WaitGroup, id int) {
defer wg.Done()
for {
select {
case <-ctx.Done():
fmt.Printf("Worker %d stopping\n", id)
return
default:
// выполнение полезной работы
fmt.Printf("Worker %d working\n", id)
time.Sleep(time.Second)
}
}
}
func main() {
var wg sync.WaitGroup
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
// запуск горутин
for i := 0; i < 3; i++ {
wg.Add(1)
go worker(ctx, &wg, i)
}
wg.Wait() // ожидание завершения всех горутин
cancel() // убедиться, что все ресурсы освобождены
}
27 Jan, 16:10
27 Jan, 09:10
package main
import "fmt"
func main() {
str := "Привет"
fmt.Println(str[0]) // 208 (байт, не символ!)
fmt.Printf("%c\n", str[0]) // П (символ, представленный первым байтом UTF-8)
}
package main
import "fmt"
func main() {
arr := [5]int{10, 20, 30, 40, 50}
fmt.Println(arr[2]) // 30
// Изменение значения по индексу
arr[2] = 100
fmt.Println(arr) // [10 20 100 40 50]
}
for.package main
import "fmt"
func main() {
nums := []int{10, 20, 30, 40, 50}
for i, v := range nums {
fmt.Printf("Индекс: %d, Значение: %d\n", i, v)
}
}
package main
import "fmt"
func main() {
str := "Привет, Мир!"
fmt.Println(str[8:12]) // Мир
}
package main
func main() {
nums := []int{1, 2, 3}
fmt.Println(nums[5]) // panic: runtime error: index out of range
}
26 Jan, 16:10
26 Jan, 09:10
25 Jan, 16:10
25 Jan, 09:10
+ или функцию fmt.Sprintf.package main
import "fmt"
func main() {
s1 := "Привет"
s2 := "Мир"
result := s1 + ", " + s2 + "!"
fmt.Println(result) // Привет, Мир!
// Через fmt.Sprintf
formatted := fmt.Sprintf("%s, %s!", s1, s2)
fmt.Println(formatted) // Привет, Мир!
}
len возвращает длину строки в байтах, а не в символах.package main
import "fmt"
func main() {
str := "Привет"
fmt.Println(len(str)) // 12, так как кириллические символы занимают 2 байта
}
package main
import (
"fmt"
"unicode/utf8"
)
func main() {
str := "Привет"
// Итерация по байтам
for i := 0; i < len(str); i++ {
fmt.Printf("Байт: %x\n", str[i])
}
// Итерация по символам (рунам)
for _, runeValue := range str {
fmt.Printf("Символ: %c\n", runeValue)
}
// Количество рун
fmt.Println("Количество символов:", utf8.RuneCountInString(str))
}
slice).package main
import "fmt"
func main() {
str := "Привет, Мир!"
substring := str[8:] // С 8-го байта до конца
fmt.Println(substring) // Мир!
}
strings.Split и strings.Join из пакета strings позволяют разбивать строку на части или объединять части в строку.package main
import (
"fmt"
"strings"
)
func main() {
str := "apple,banana,cherry"
// Разделение строки
parts := strings.Split(str, ",")
fmt.Println(parts) // [apple banana cherry]
// Объединение строк
joined := strings.Join(parts, " | ")
fmt.Println(joined) // apple | banana | cherry
}
strings.Contains, strings.Index или strings.HasPrefix/strings.HasSuffix. Для замены — strings.Replace.package main
import (
"fmt"
"strings"
)
func main() {
str := "Go — это круто!"
// Поиск подстроки
fmt.Println(strings.Contains(str, "круто")) // true
fmt.Println(strings.Index(str, "это")) // 4
// Замена подстроки
newStr := strings.Replace(str, "круто", "отлично", 1)
fmt.Println(newStr) // Go — это отлично!
}
strings.ToLower и strings.ToUpper.package main
import (
"fmt"
"strings"
)
func main() {
str := "Hello, Go!"
fmt.Println(strings.ToUpper(str)) // HELLO, GO!
fmt.Println(strings.ToLower(str)) // hello, go!
}
strings.Trim, strings.TrimSpace и других функций.package main
import (
"fmt"
"strings"
)
func main() {
str := " Hello, Go! "
fmt.Println(strings.TrimSpace(str)) // "Hello, Go!"
}
24 Jan, 16:10
23 Jan, 16:10
23 Jan, 09:10
package main
import (
"fmt"
"net/http"
)
func helloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, World!")
}
func main() {
http.HandleFunc("/", helloHandler)
fmt.Println("Starting server on :8080")
http.ListenAndServe(":8080", nil)
}
go func() {
fmt.Println("Hello from a goroutine!")
}() ch := make(chan int)
go func() {
ch <- 42
}()
value := <-ch
fmt.Println(value)
type Stringer interface {
String() string
} package mypackage
import "fmt"
func MyFunction() {
fmt.Println("Hello from mypackage")
}
22 Jan, 16:10
22 Jan, 11:29
22 Jan, 09:10
package main
import "fmt"
func main() {
m := map[string]int{"a": 1, "b": 2}
// Нельзя делать так:
// p := &m["a"]
// Вместо этого можно работать с копией значения
value := m["a"]
p := &value
fmt.Println("Value:", *p) // 1
// Изменение карты
m["c"] = 3
// Ссылка на значение в карте могла бы стать недействительной
// fmt.Println("Value after map change:", *p)
}
value := m["a"]
value := m["a"]
value = value + 10
m["a"] = value
package main
import "fmt"
func main() {
m := map[string]*int{"a": new(int), "b": new(int)}
*m["a"] = 1
*m["b"] = 2
// Теперь можно брать указатели на значения
p := m["a"]
fmt.Println("Value:", *p) // 1
// Изменение значения через указатель
*p = 42
fmt.Println("Updated Value:", *m["a"]) // 42
}
21 Jan, 16:10
21 Jan, 09:10
var arr [5]int
arr := [5]int{1, 2, 3, 4, 5}arr := [5]int{1, 2}fmt.Println(arr[0]) // 1
arr[1] = 10
fmt.Println(arr[1]) // 10
lenfmt.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]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
}
20 Jan, 16:10
20 Jan, 09:10
[]) при применении к строке используется для доступа к отдельным байтам в этой строке. Строки представлены как последовательности байтов, и оператор [] позволяет получить байт по указанному индексу. package main
import (
"fmt"
)
func main() {
str := "hello"
// Получаем байт по индексу
firstByte := str[0]
// Выводим байт и его символ
fmt.Printf("Первый байт: %d\n", firstByte) // Выводит: 104
fmt.Printf("Первый символ: %c\n", firstByte) // Выводит: h
}
0 в строке str. В данном случае это байт, соответствующий символу 'h'.firstByte := str[0]
104.fmt.Printf("Первый байт: %d\n", firstByte) %c. Это отобразит символ 'h'.fmt.Printf("Первый символ: %c\n", firstByte) [] дает байт, а не руну (rune). Если строка содержит многобайтовые символы (например, символы Unicode), то доступ по индексу может вернуть только один из байтов, составляющих символ.package main
import (
"fmt"
)
func main() {
str := "Привет"
// Получаем байт по индексу
firstByte := str[0]
// Выводим байт и его символ
fmt.Printf("Первый байт: %d\n", firstByte) // Выводит: 208
fmt.Printf("Первый символ: %c\n", firstByte) // Выводит: � (неполный символ)
}
package main
import (
"fmt"
)
func main() {
str := "Привет"
// Преобразуем строку в срез рун
runes := []rune(str)
// Получаем руну по индексу
firstRune := runes[0]
// Выводим руну и её символ
fmt.Printf("Первая руна: %d\n", firstRune) // Выводит: 1055 (код Unicode для 'П')
fmt.Printf("Первый символ: %c\n", firstRune) // Выводит: П
}
19 Jan, 16:10
19 Jan, 09:10
true) в канал, чтобы уведомить о своем завершении.func worker(done chan bool) {
fmt.Println("Работа началась...")
time.Sleep(2 * time.Second) // Имитация работы
fmt.Println("Работа завершена!")
done <- true // Отправляем сигнал в канал
}
func main() {
done := make(chan bool)
go worker(done) // Запускаем горутину
// Ожидаем сигнал завершения
<-done
fmt.Println("Основной поток: горутина завершена")
}func worker(progress chan int) {
for i := 1; i <= 5; i++ {
fmt.Printf("Шаг %d выполнен\n", i)
progress <- i // Отправляем номер шага в канал
time.Sleep(500 * time.Millisecond) // Имитация работы
}
close(progress) // Закрываем канал после завершения работы
}
func main() {
progress := make(chan int)
go worker(progress) // Запускаем горутину
// Считываем данные из канала
for step := range progress {
fmt.Printf("Получен сигнал: шаг %d завершен\n", step)
}
fmt.Println("Все шаги выполнены!")
}select с тайм-аутом.func worker(status chan string) {
time.Sleep(2 * time.Second) // Имитация работы
status <- "Горутина завершена"
}
func main() {
status := make(chan string)
go worker(status)
select {
case msg := <-status:
fmt.Println(msg)
case <-time.After(1 * time.Second): // Тайм-аут 1 секунда
fmt.Println("Горутина работает слишком долго")
}
}func worker(done chan struct{}) {
fmt.Println("Горутина работает...")
time.Sleep(2 * time.Second)
fmt.Println("Горутина завершена!")
close(done) // Закрываем канал
}
func main() {
done := make(chan struct{})
go worker(done)
// Проверяем, когда канал закроется
<-done
fmt.Println("Основной поток: горутина завершила работу")
}18 Jan, 16:10
18 Jan, 09:10
package main
import "fmt"
func main() {
// Создание карты
myMap := make(map[string]int)
// Вставка значений
myMap["Alice"] = 25
myMap["Bob"] = 30
// Поиск значений
value, exists := myMap["Alice"]
if exists {
fmt.Println("Alice:", value) // Alice: 25
} else {
fmt.Println("Alice not found")
}
// Удаление значений
delete(myMap, "Alice")
_, exists = myMap["Alice"]
if !exists {
fmt.Println("Alice has been deleted") // Alice has been deleted
}
}
17 Jan, 16:10
17 Jan, 09:10
+) приводит к созданию новой строки, которая является конкатенацией двух или более исходных строк. s1 := "Hello"
s2 := "World"
result := s1 + " " + s2
fmt.Println(result) // Output: Hello World
+ может быть неэффективным при множественных операциях, так как каждый раз создается новая строка, а старые промежуточные результаты удаляются сборщиком мусора.result := ""
for i := 0; i < 5; i++ {
result += "Go"
}
fmt.Println(result) // Output: GoGoGoGoGo
strings.Builder. Это более эффективный способ, так как Builder работает с буфером и избегает лишних аллокаций.import "strings"
func main() {
var builder strings.Builder
for i := 0; i < 5; i++ {
builder.WriteString("Go")
}
fmt.Println(builder.String()) // Output: GoGoGoGoGo
}
s1 := "Привет"
s2 := "Мир"
result := s1 + " " + s2
fmt.Println(result) // Output: Привет Мир
16 Jan, 16:10
16 Jan, 09:10
{} в функции используется для ограничения области видимости переменных и улучшения читаемости кода. Это позволяет временно вводить переменные или выполнять локальные операции без влияния на остальную часть функции.{}, видимы только в пределах этого блока. Это полезно для временных переменных, которые не должны "загрязнять" основную область видимости функции.func processData() {
{
value := 42
fmt.Println("Внутренний блок, value =", value) // value доступна только здесь
}
// fmt.Println(value) // Ошибка: value не определена за пределами блока
}func readFile() {
{
file, err := os.Open("example.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close() // Закроется при выходе из блока
// Работа с файлом
fmt.Println("Чтение файла")
}
// Здесь файл уже закрыт
}func main() {
{
// Работа с настройками
config := loadConfig()
fmt.Println("Конфигурация загружена:", config)
}
{
// Работа с данными
data := fetchData()
fmt.Println("Данные получены:", data)
}
}func calculate() int {
result := 0
{
a := 10
b := 20
result = a + b
}
return result
}15 Jan, 16:10
15 Jan, 09:10
==. Это необходимо для проверки равенства ключей при выполнении операций вставки, поиска и удаления в карте. m := map[bool]string{
true: "Yes",
false: "No",
} m := map[int]string{
1: "One",
2: "Two",
} m := map[float64]string{
1.1: "One point one",
2.2: "Two point two",
} m := map[string]int{
"Alice": 25,
"Bob": 30,
} type Key struct {
FirstName string
LastName string
}
m := map[Key]int{
{"Alice", "Smith"}: 1,
{"Bob", "Johnson"}: 2,
}
slice)== (только сравнение с nil).map)func)package main
import "fmt"
type Person struct {
FirstName string
LastName string
}
func main() {
// Создаем карту с ключами типа Person
m := make(map[Person]int)
// Вставляем значения в карту
m[Person{"Alice", "Smith"}] = 25
m[Person{"Bob", "Johnson"}] = 30
// Выводим значения из карты
fmt.Println(m[Person{"Alice", "Smith"}]) // Выводит: 25
fmt.Println(m[Person{"Bob", "Johnson"}]) // Выводит: 30
}
14 Jan, 16:10
14 Jan, 09:10
func main() {
var mu1, mu2 sync.Mutex
go func() {
mu1.Lock()
defer mu1.Unlock()
mu2.Lock()
defer mu2.Unlock()
}()
go func() {
mu2.Lock()
defer mu2.Unlock()
mu1.Lock()
defer mu1.Unlock()
}()
}func main() {
ch := make(chan int)
ch <- 42 // Deadlock, так как никто не читает из канала
}ch := make(chan int)
close(ch) // Закрыт слишком рано
ch <- 42 // Паника
func main() {
ch := make(chan int)
ch <- 1
fmt.Println(<-ch) // Никогда не выполнится
}select. Если операция занимает слишком много времени, можно выполнить альтернативное действие.func main() {
ch := make(chan int)
select {
case data := <-ch:
fmt.Println("Получены данные:", data)
case <-time.After(1 * time.Second):
fmt.Println("Тайм-аут, завершение")
}
}go run -race, которая помогает выявлять гонки данных и другие проблемы, связанные с синхронизацией.go run -race main.go
13 Jan, 16:10
10 Jan, 16:10
10 Jan, 09:10
arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4] // слайс содержит элементы {2, 3, 4}
slice := make([]int, 5) // создаёт слайс длиной и ёмкостью 5, заполненный нулями
slice := []int{1, 2, 3, 4, 5} fmt.Println(slice[0]) // выводит первый элемент слайса
slice[1] = 10 // изменяет второй элемент слайса
slice = append(slice, 6, 7) // добавляет элементы 6 и 7 к слайсу
newSlice := slice[1:3] // создаёт новый слайс с элементами с 1-го по 3-й
package main
import "fmt"
func main() {
nums := []int{1, 2, 3}
nums = append(nums, 4) // добавление элемента
fmt.Println(nums) // выводит [1, 2, 3, 4]
}
10 Jan, 07:14
09 Jan, 16:10
09 Jan, 12:55
09 Jan, 09:10
var arr [5]int
arr := [5]int{1, 2, 3, 4, 5}arr := [5]int{1, 2}fmt.Println(arr[0]) // 1
arr[1] = 10
fmt.Println(arr[1]) // 10
lenfmt.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]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
}
08 Jan, 16:10
08 Jan, 09:10
append просто добавляет элементы к существующему массиву.append выделяет новый массив, копирует в него существующие элементы и добавляет новые элементы. Новый массив будет иметь увеличенную емкость (как правило, в два раза больше, чем предыдущая).slice = append(slice, elem1, elem2, ...)
package main
import "fmt"
func main() {
// Создаем слайс из 3 целых чисел
slice := []int{1, 2, 3}
// Добавляем один элемент
slice = append(slice, 4)
// Добавляем несколько элементов
slice = append(slice, 5, 6, 7)
// Выводим слайс
fmt.Println(slice) // Выводит: [1 2 3 4 5 6 7]
}
[1, 2, 3].slice := []int{1, 2, 3} 4 к слайсу. Теперь слайс содержит [1, 2, 3, 4].slice = append(slice, 4)
5, 6, и 7. Теперь слайс содержит [1, 2, 3, 4, 5, 6, 7].slice = append(slice, 5, 6, 7)
[1, 2, 3, 4, 5, 6, 7].fmt.Println(slice)
package main
import "fmt"
func main() {
slice := []int{1, 2, 3}
fmt.Printf("Before append: len=%d cap=%d %v\n", len(slice), cap(slice), slice)
slice = append(slice, 4)
fmt.Printf("After append: len=%d cap=%d %v\n", len(slice), cap(slice), slice)
slice = append(slice, 5, 6, 7)
fmt.Printf("After multiple appends: len=%d cap=%d %v\n", len(slice), cap(slice), slice)
}
07 Jan, 16:10
07 Jan, 09:10
type slice struct {
ptr *ElementType // Указатель на базовый массив
len int // Длина
cap int // Емкость
}package main
import "fmt"
func main() {
arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4] // Слайс содержит элементы с индексами 1, 2, 3
fmt.Println(slice) // [2 3 4]
}
package main
import "fmt"
func main() {
slice := make([]int, 3, 5) // Слайс длиной 3 и емкостью 5
fmt.Println(slice) // [0 0 0]
}
package main
import "fmt"
func main() {
slice := []int{1, 2, 3, 4, 5}
fmt.Println(slice[0]) // 1
slice[1] = 10
fmt.Println(slice) // [1 10 3 4 5]
}
appendpackage main
import "fmt"
func main() {
slice := []int{1, 2, 3}
slice = append(slice, 4, 5) // Добавляем элементы 4 и 5 в конец слайса
fmt.Println(slice) // [1 2 3 4 5]
}
package main
import "fmt"
func main() {
slice := []int{1, 2, 3, 4, 5}
subSlice := slice[1:4] // Слайс содержит элементы с индексами 1, 2, 3
fmt.Println(subSlice) // [2 3 4]
}
copypackage main
import "fmt"
func main() {
src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src)
fmt.Println(dst) // [1 2 3]
}
append. Когда емкость текущего массива недостаточна для добавления новых элементов, создается новый массив с большей емкостью, в который копируются существующие элементы.package main
import "fmt"
func main() {
slice := make([]int, 3, 5)
fmt.Println("Before append:", slice, "Len:", len(slice), "Cap:", cap(slice))
slice = append(slice, 1, 2, 3)
fmt.Println("After append:", slice, "Len:", len(slice), "Cap:", cap(slice))
slice = append(slice, 4)
fmt.Println("After another append:", slice, "Len:", len(slice), "Cap:", cap(slice))
}
06 Jan, 16:10
06 Jan, 09:10
nilnil. Это означает, что слайс, объявленный, но не инициализированный явно, указывает на nil и имеет длину и емкость равные нулю.package main
import "fmt"
func main() {
var slice []int // Объявление слайса без инициализации
fmt.Println(slice) // []
fmt.Println(len(slice)) // 0
fmt.Println(cap(slice)) // 0
fmt.Println(slice == nil) // true
}
append, и это будет работать корректно.append с nil-слайсомpackage main
import "fmt"
func main() {
var slice []int // nil-слайс
// Добавление элемента в nil-слайс
slice = append(slice, 1)
fmt.Println(slice) // [1]
fmt.Println(len(slice)) // 1
fmt.Println(cap(slice)) // 1
fmt.Println(slice == nil) // false (теперь слайс больше не nil)
}
05 Jan, 16:10
05 Jan, 09:10
package main
import "fmt"
func main() {
// Создаем массив из 5 целых чисел
var arr [5]int
// Создаем переменную и присваиваем ей значение
x := 10
// Подставляем переменную в массив
arr[0] = x
// Выводим массив
fmt.Println(arr) // Выводит: [10 0 0 0 0]
}
arr из 5 целых чисел, все элементы которого инициализируются значением 0.var arr [5]int
x и присваиваем ей значение 10.x := 10
x первому элементу массива arr.arr[0] = x
10, а остальные элементы остаются нулями.fmt.Println(arr)
package main
import "fmt"
func main() {
// Создаем слайс из 3 целых чисел
slice := make([]int, 3)
// Создаем переменную и присваиваем ей значение
x := 20
// Подставляем переменную в слайс
slice[1] = x
// Выводим слайс
fmt.Println(slice) // Выводит: [0 20 0]
}
slice из 3 целых чисел, все элементы которого инициализируются значением 0.slice := make([]int, 3)
x и присваиваем ей значение 20.x := 20
x второму элементу слайса slice.slice[1] = x
20, а остальные элементы остаются нулями.fmt.Println(slice)
04 Jan, 16:10
04 Jan, 09:10
package main
import "fmt"
func main() {
slice := []int{1, 2, 3, 4, 5}
fmt.Println(slice) // [1 2 3 4 5]
}
package main
import "fmt"
func main() {
slice := make([]int, 3) // Создаем слайс длиной 3 и емкостью 3
fmt.Println(slice) // [0 0 0]
sliceWithCapacity := make([]int, 3, 5) // Создаем слайс длиной 3 и емкостью 5
fmt.Println(sliceWithCapacity) // [0 0 0]
}
package main
import "fmt"
func main() {
arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4] // Слайс содержит элементы с индексами 1, 2 и 3
fmt.Println(slice) // [2 3 4]
}
package main
import "fmt"
func main() {
slice := []int{1, 2, 3, 4, 5}
subSlice := slice[1:4] // Новый слайс содержит элементы с индексами 1, 2 и 3
fmt.Println(subSlice) // [2 3 4]
}
package main
import "fmt"
func main() {
var emptySlice []int // Пустой слайс
fmt.Println(emptySlice, len(emptySlice), cap(emptySlice)) // [] 0 0
emptySlice = append(emptySlice, 1) // Добавление элемента
fmt.Println(emptySlice) // [1]
}
package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
newSlice := original[:3] // Слайс содержит элементы с индексами 0, 1, 2
fmt.Println(newSlice) // [1 2 3]
anotherSlice := original[2:] // Слайс содержит элементы с индекса 2 до конца
fmt.Println(anotherSlice) // [3 4 5]
}
package main
import "fmt"
func main() {
// Создание слайса с использованием литерала
sliceLiteral := []int{1, 2, 3, 4, 5}
fmt.Println("Slice literal:", sliceLiteral)
// Создание слайса с использованием make
sliceMake := make([]int, 3) // Длина 3, емкость 3
fmt.Println("Slice make:", sliceMake)
sliceMakeWithCapacity := make([]int, 3, 5) // Длина 3, емкость 5
fmt.Println("Slice make with capacity:", sliceMakeWithCapacity)
// Создание слайса на основе массива
arr := [5]int{1, 2, 3, 4, 5}
sliceFromArray := arr[1:4] // Элементы с индексами 1, 2, 3
fmt.Println("Slice from array:", sliceFromArray)
// Создание слайса на основе другого слайса
sliceFromSlice := sliceLiteral[2:5] // Элементы с индексами 2, 3, 4
fmt.Println("Slice from slice:", sliceFromSlice)
// Создание пустого слайса
var emptySlice []int
fmt.Println("Empty slice:", emptySlice, len(emptySlice), cap(emptySlice))
// Добавление элемента в пустой слайс
emptySlice = append(emptySlice, 10)
fmt.Println("After append:", emptySlice)
}
03 Jan, 16:10
03 Jan, 09:10
copy или методы, такие как использование append.package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
// Создаем новый слайс той же длины, что и оригинал
copySlice := make([]int, len(original))
// Копируем элементы из оригинального слайса в новый
copy(copySlice, original)
// Изменяем элемент в копии
copySlice[0] = 100
fmt.Println("Оригинал:", original) // Выводит: Оригинал: [1 2 3 4 5]
fmt.Println("Копия:", copySlice) // Выводит: Копия: [100 2 3 4 5]
}
inal)
package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
// Копируем элементы из оригинального слайса в новый слайс
copySlice := append([]int(nil), original...)
// Изменяем элемент в копии
copySlice[0] = 100
fmt.Println("Оригинал:", original) // Выводит: Оригинал: [1 2 3 4 5]
fmt.Println("Копия:", copySlice) // Выводит: Копия: [100 2 3 4 5]
}
02 Jan, 16:10
02 Jan, 09:10
[]) при применении к строке используется для доступа к отдельным байтам в этой строке. Строки представлены как последовательности байтов, и оператор [] позволяет получить байт по указанному индексу. package main
import (
"fmt"
)
func main() {
str := "hello"
// Получаем байт по индексу
firstByte := str[0]
// Выводим байт и его символ
fmt.Printf("Первый байт: %d\n", firstByte) // Выводит: 104
fmt.Printf("Первый символ: %c\n", firstByte) // Выводит: h
}
0 в строке str. В данном случае это байт, соответствующий символу 'h'.firstByte := str[0]
104.fmt.Printf("Первый байт: %d\n", firstByte) %c. Это отобразит символ 'h'.fmt.Printf("Первый символ: %c\n", firstByte) [] дает байт, а не руну (rune). Если строка содержит многобайтовые символы (например, символы Unicode), то доступ по индексу может вернуть только один из байтов, составляющих символ.package main
import (
"fmt"
)
func main() {
str := "Привет"
// Получаем байт по индексу
firstByte := str[0]
// Выводим байт и его символ
fmt.Printf("Первый байт: %d\n", firstByte) // Выводит: 208
fmt.Printf("Первый символ: %c\n", firstByte) // Выводит: � (неполный символ)
}
package main
import (
"fmt"
)
func main() {
str := "Привет"
// Преобразуем строку в срез рун
runes := []rune(str)
// Получаем руну по индексу
firstRune := runes[0]
// Выводим руну и её символ
fmt.Printf("Первая руна: %d\n", firstRune) // Выводит: 1055 (код Unicode для 'П')
fmt.Printf("Первый символ: %c\n", firstRune) // Выводит: П
}
01 Jan, 16:10
01 Jan, 09:10
==. Это необходимо для проверки равенства ключей при выполнении операций вставки, поиска и удаления в карте. m := map[bool]string{
true: "Yes",
false: "No",
} m := map[int]string{
1: "One",
2: "Two",
} m := map[float64]string{
1.1: "One point one",
2.2: "Two point two",
} m := map[string]int{
"Alice": 25,
"Bob": 30,
} type Key struct {
FirstName string
LastName string
}
m := map[Key]int{
{"Alice", "Smith"}: 1,
{"Bob", "Johnson"}: 2,
}
slice)== (только сравнение с nil).map)func)package main
import "fmt"
type Person struct {
FirstName string
LastName string
}
func main() {
// Создаем карту с ключами типа Person
m := make(map[Person]int)
// Вставляем значения в карту
m[Person{"Alice", "Smith"}] = 25
m[Person{"Bob", "Johnson"}] = 30
// Выводим значения из карты
fmt.Println(m[Person{"Alice", "Smith"}]) // Выводит: 25
fmt.Println(m[Person{"Bob", "Johnson"}]) // Выводит: 30
}
31 Dec, 16:10
31 Dec, 09:10
golintgo install golang.org/x/lint/golint@latest
example.gopackage main
import "fmt"
func main() {
fmt.Println("Hello, world!")
}
golintgolint example.go
ESLintnpm install eslint --save-dev
ESLintnpx eslint --init
example.jsfunction hello() {
console.log("Hello, world!");
}
hello();ESLintnpx eslint example.js
30 Dec, 16:10
30 Dec, 09:10
golint: Проверяет стиль кода на соответствие рекомендациям Go.gofmt: Автоматически форматирует код в соответствии со стандартами Go.staticcheck: Более мощный инструмент, который находит ошибки, неэффективные конструкции и другие проблемы.ESLint: Очень мощный и настраиваемый линтер для JavaScript и TypeScriptJSHint: Инструмент для выявления ошибок и потенциальных проблем в JavaScript-коде.Pylint: Линтер для Python, который проверяет стиль кода, ищет ошибки и предлагает улучшения.flake8: Комбинированный инструмент, который включает в себя проверки на стиль, ошибки и другие проблемы.Checkstyle: Инструмент для проверки стиля кода Java.PMD: Находит потенциальные ошибки, неиспользуемый код и другие проблемы в коде Java.golintgo install golang.org/x/lint/golint@latest
example.gopackage main
import "fmt"
func main() {
fmt.Println("Hello, world!")
}
golintgolint example.go
ESLintnpm install eslint --save-dev
ESLintnpx eslint --init
example.jsfunction hello() {
console.log("Hello, world!");
}
hello();ESLint:npx eslint example.js
29 Dec, 16:10
29 Dec, 09:10
Jenkinsfile, который описывает этапы вашего CI/CD процесса.pipeline {
agent any
stages {
stage('Build') {
steps {
sh 'go build -v'
}
}
stage('Test') {
steps {
sh 'go test -v ./...'
}
}
stage('Deploy') {
steps {
sh 'echo "Deploying to production"'
// Ваши команды для развертывания
}
}
}
}28 Dec, 16:10
28 Dec, 09:10
myproject/
main.go
mypackage/
mypackage.go
mypackage.go определите пакет с именем mypackage и добавьте функции, которые вы хотите экспортировать.mypackage/mypackage.gopackage mypackage
import "fmt"
// Экспортируемая функция (имя начинается с заглавной буквы)
func PrintHello() {
fmt.Println("Hello from mypackage")
}
// Неэкспортируемая функция (имя начинается с маленькой буквы)
func privateFunction() {
fmt.Println("This is a private function")
}
mypackage в файле main.go, нужно импортировать этот пакет.main.gopackage main
import (
"mypackage" // Импортируем наш пакет
)
func main() {
mypackage.PrintHello() // Вызов экспортируемой функции из пакета mypackage
// mypackage.privateFunction() // Это вызовет ошибку, так как функция не экспортируется
}
myproject) и выполните командуgo run main.go
Hello from mypackage
main.go:package main
import (
"fmt"
mp "mypackage" // Импортируем mypackage под именем mp
)
func main() {
mp.PrintHello() // Используем алиас для вызова функции из пакета
}
import (
_ "some/package" // Импортируем пакет только для его инициализации
)
go mod init myproject
go.mod.myproject/
go.mod
main.go
mypackage/
mypackage.go
mypackage/mypackage.gopackage mypackage
import "fmt"
func PrintHello() {
fmt.Println("Hello from mypackage")
}
main.gopackage main
import (
"mypackage"
)
func main() {
mypackage.PrintHello()
}
cd myproject
go mod init myproject
go run main.go
Hello from mypackage
27 Dec, 16:10
27 Dec, 09:10
package main или package fmt.import.main является входной точкой программы. Он должен содержать функцию main, которая будет выполняться при запуске программы.mypackage/mypackage.gopackage mypackage
import "fmt"
// Экспортируемая функция
func PrintHello() {
fmt.Println("Hello from mypackage")
}
// Неэкспортируемая функция
func privateFunction() {
fmt.Println("This is a private function")
}
main.gopackage main
import (
"mypackage"
)
func main() {
mypackage.PrintHello() // Output: Hello from mypackage
// mypackage.privateFunction() // Ошибка: неэкспортируемая функция
}
package main
import (
"fmt"
"mypackage"
)
func main() {
fmt.Println("Using multiple packages")
mypackage.PrintHello()
}
package main
import (
"fmt"
mp "mypackage"
)
func main() {
fmt.Println("Using aliased package")
mp.PrintHello()
}
import (
_ "some/package"
)
myproject/
main.go
mypackage/
mypackage.go
anotherpackage/
anotherpackage.go
main.gopackage main
import (
"mypackage"
"anotherpackage"
)
func main() {
mypackage.PrintHello()
anotherpackage.DoSomething()
}
anotherpackage/anotherpackage.gopackage anotherpackage
import "fmt"
func DoSomething() {
fmt.Println("Doing something in anotherpackage")
}
26 Dec, 16:10
26 Dec, 09:10
25 Dec, 09:10
package main
import (
"fmt"
"net/http"
)
func helloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, World!")
}
func main() {
http.HandleFunc("/", helloHandler)
fmt.Println("Starting server on :8080")
http.ListenAndServe(":8080", nil)
}
go func() {
fmt.Println("Hello from a goroutine!")
}() ch := make(chan int)
go func() {
ch <- 42
}()
value := <-ch
fmt.Println(value)
type Stringer interface {
String() string
} package mypackage
import "fmt"
func MyFunction() {
fmt.Println("Hello from mypackage")
}
24 Dec, 16:10
24 Dec, 09:10
implements в Java или implements/inherits в C#).package main
import "fmt"
// Определение интерфейса
type Stringer interface {
String() string
}
// Определение структуры
type Person struct {
Name string
Age int
}
// Реализация метода String для структуры Person
func (p Person) String() string {
return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}
func main() {
// Присваивание переменной интерфейса значения типа Person
var s Stringer = Person{Name: "Alice", Age: 30}
fmt.Println(s.String()) // Output: Alice (30 years old)
}
package main
// Определение интерфейса
type Stringer interface {
String() string
}
// Определение структуры
type Person struct {
Name string
Age int
}
// Реализация метода String для структуры Person
func (p Person) String() string {
return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}
// Пустое присваивание для проверки соответствия интерфейсу
var _ Stringer = Person{}
func main() {
// Ваш основной код здесь
}
package main
import "fmt"
// Определение интерфейса
type Stringer interface {
String() string
}
// Определение структуры
type Person struct {
Name string
Age int
}
// Реализация метода String для структуры Person
func (p Person) String() string {
return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}
// Функция, принимающая интерфейс
func printString(s Stringer) {
fmt.Println(s.String())
}
func main() {
p := Person{Name: "Alice", Age: 30}
printString(p) // Output: Alice (30 years old)
}
23 Dec, 16:10
23 Dec, 09:10
package mypackage
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)
}
package io
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
package interfaces
type Stringer interface {
String() string
}
main.gopackage main
import (
"fmt"
"myproject/interfaces"
)
type Person struct {
Name string
Age int
}
func (p Person) String() string {
return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}
func printString(s interfaces.Stringer) {
fmt.Println(s.String())
}
func main() {
p := Person{Name: "Alice", Age: 30}
printString(p)
}
22 Dec, 16:10
22 Dec, 09:10
value, ok := interfaceValue.(ConcreteType)
interfaceValue — переменная интерфейсного типа. ConcreteType — тип, к которому вы хотите привести значение. value — переменная, которая будет содержать значение типа ConcreteType, если приведение успешно. ok — булевое значение, указывающее, было ли приведение успешным.package main
import "fmt"
func main() {
var i interface{} = "hello"
// Утверждение типа с проверкой
s, ok := i.(string)
if ok {
fmt.Println("String:", s)
} else {
fmt.Println("Not a string")
}
// Утверждение типа с проверкой
n, ok := i.(int)
if ok {
fmt.Println("Integer:", n)
} else {
fmt.Println("Not an integer")
}
}
package main
import "fmt"
func main() {
var i interface{} = "hello"
// Утверждение типа без проверки
s := i.(string)
fmt.Println("String:", s)
// Утверждение типа без проверки, которое вызовет панику
// n := i.(int) // Это вызовет панику, если раскомментировать
// fmt.Println("Integer:", n)
}
switch с утверждением типа.package main
import "fmt"
func printType(i interface{}) {
switch v := i.(type) {
case string:
fmt.Println("String:", v)
case int:
fmt.Println("Integer:", v)
case bool:
fmt.Println("Boolean:", v)
default:
fmt.Printf("Unknown type: %T\n", v)
}
}
func main() {
printType("hello") // Output: String: hello
printType(42) // Output: Integer: 42
printType(true) // Output: Boolean: true
printType(3.14) // Output: Unknown type: float64
}
fmt.Stringer и утверждение типа для приведения значения к конкретному типу.package main
import "fmt"
type Person struct {
Name string
Age int
}
// Реализация интерфейса fmt.Stringer
func (p Person) String() string {
return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}
func printValue(i interface{}) {
if str, ok := i.(fmt.Stringer); ok {
fmt.Println("Stringer:", str.String())
} else {
fmt.Println("Not a Stringer")
}
}
func main() {
p := Person{Name: "Alice", Age: 30}
printValue(p) // Output: Alice (30 years old)
printValue("Hello, world!") // Output: Not a Stringer
}
