Пример кода

package main

import "fmt"

// Обобщённая функция Swap меняет местами два значения любого типа.
// T — параметр типа, а ограничение any означает, что функция принимает аргументы любого типа.
func Swap[T any](a, b T) (T, T) {
	return b, a
}

// Обобщённый тип Box хранит значение произвольного типа T.
type Box[T any] struct {
	value T
}

// Метод Get возвращает значение, хранящееся в Box.
func (b Box[T]) Get() T {
	return b.value
}

// Метод Set присваивает новое значение полю value.
func (b *Box[T]) Set(value T) {
	b.value = value
}

func main() {
	// Пример использования функции Swap с числами
	a, b := 10, 20
	a, b = Swap(a, b)
	fmt.Println("После обмена:", a, b)

	// Пример использования типа Box для хранения значения int
	intBox := Box[int]{value: 100}
	fmt.Println("Значение в intBox:", intBox.Get())

	// Пример использования типа Box для хранения значения string
	strBox := Box[string]{value: "hello"}
	fmt.Println("Значение в strBox:", strBox.Get())
}

Как это работает

1. Параметры типа и ограничения
   В объявлении функции Swap[T any] параметр типа T записывается в квадратных скобках сразу после имени функции. Ограничение any (это синоним для interface{}) указывает, что тип T может быть любым. Таким образом, функция Swap способна принимать на вход значения любых типов, например, int, string и другие.

2. Обобщённый тип
   Тип Box[T any] представляет контейнер, способный хранить значение любого типа. Методы Get и Set работают с этим значением, не теряя информации о типе. При создании экземпляра типа Box компилятор подставляет конкретный тип, например, Box[int] или Box[string].

3. Компиляция и безопасность типов
   При вызове обобщённой функции или создании обобщённого типа компилятор Go подставляет конкретный тип вместо параметра T. Это позволяет избежать дублирования кода и одновременно гарантирует, что типизация будет проверяться на этапе компиляции.

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

Компилятор Go создаёт отдельную, специализированную версию функции (или типа) для каждого уникального набора типовых параметров, используемых в коде. Такой подход называется монопорфизацией.

Разъяснения

• Монопорфизация:
  При компиляции для каждой инстанциации обобщённого кода создаётся конкретный вариант с подставленным типом. Например, если функция Swap[T any] вызывается для int и для string, то компилятор сгенерирует две версии — одну для int, другую для string.

• Преимущества:
  Такой механизм позволяет:

  • Оптимизировать код под конкретные типы, что может улучшать производительность.

  • Сохранять строгую типизацию и выявлять ошибки на этапе компиляции.

  • Избегать накладных расходов, связанных с преобразованиями типов во время выполнения.

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

Таким образом, реализация дженериков в Go через монопорфизацию делает возможным написание обобщённого кода без потери производительности и безопасности типов.

Name: func() string {
   if line.Nomenclature != nil {
      return line.Nomenclature.Name
   }
   return ""
}(),

package main

import (
    "fmt"
)

func main() {
    maxInt := int(^uint(0) >> 1)
    fmt.Println("Максимальное значение int:", maxInt)
}

package main

import (
 "fmt"
 "net/http"
 "time"
)

func main() {
 http.HandleFunc("/events", eventsHandler)
 http.ListenAndServe(":8080", nil)
}

func eventsHandler(w http.ResponseWriter, r *http.Request) {
 // Set CORS headers to allow all origins. You may want to restrict this to specific origins in a production environment.
 w.Header().Set("Access-Control-Allow-Origin", "*")
 w.Header().Set("Access-Control-Expose-Headers", "Content-Type")

 w.Header().Set("Content-Type", "text/event-stream")
 w.Header().Set("Cache-Control", "no-cache")
 w.Header().Set("Connection", "keep-alive")

 // Simulate sending events (you can replace this with real data)
 for i := 0; i < 10; i++ {
 fmt.Fprintf(w, "data: %s\n\n", fmt.Sprintf("Event %d", i))
 time.Sleep(2 * time.Second)
 w.(http.Flusher).Flush()
 }

 // Simulate closing the connection
 closeNotify := w.(http.CloseNotifier).CloseNotify()
 <-closeNotify
}

 

<!DOCTYPE html>
<html>
<head>
 <title>SSE Example</title>
</head>
<body>
 <div id="sse-data"></div>

 <script>
 const eventSource = new EventSource('http://localhost:8080/events');
 eventSource.onmessage = function(event) {
 const dataElement = document.getElementById('sse-data');
 dataElement.innerHTML += event.data + '<br>';
 };
 </script>
</body>
</html>

Она предоставляет удобный способ создания и воспроизведения HTTP запросов, и значительно упрощает создание надежных тестов для ваших клиентов API.

▪Запись и воспроизведение тестов

▪Автоматическое удаления конфиденциальной информации

▪Проверка запросов для обеспечения их целостности

▪Полная интеграция с GO протоколом http.Client

▪Легко расширяемые и настраиваемые опции

go get github.com/areknoster/hypert

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

Более разумным способом решения этой проблемы является такое создание filtered := numbers[:0]

Так мы создадим слайс с ёмкостью numbers и избегаем дополнительных выделений памяти в дальнейшем

В выражении numbers[:0], 0 указывает на индекс, до которого (не включая его) будут скопированы элементы из среза numbers. По сути, это создает новый срез, который имеет ту же емкость, что и исходный срез numbers, но не содержит никаких элементов.

Вот как это работает:

• numbers[:] создает копию среза numbers, включая все его элементы.
• numbers[:n], где n — это неотрицательное целое число, создает новый срез, который содержит первые n элементов numbers.
• numbers[:0] создает новый срез, который не содержит элементов, но имеет ту же емкость, что и numbers. Это означает, что при добавлении элементов в срез filtered с помощью функции append память будет выделена из исходного массива, который лежит в основе среза numbers, до тех пор, пока не будет превышена его емкость.

Теперь range по int

for i := range 10 {
 println(i)
}

https://github.com/evgensr/anti-spam