{"draftJsState":{"blocks":[{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Паттерны проектирования — это проверенные временем решения распространенных проблем в разработке программного обеспечения. Они помогают создавать гибкий, поддерживаемый и масштабируемый код. GoLang, несмотря на свою простоту и минималистичный синтаксис, отлично подходит для реализации многих паттернов проектирования. В этой статье мы рассмотрим основные паттерны и их реализацию на Go.","type":"unstyled","key":"eld9p"},{"data":{"image":{"id":"67c1e07ef8898a0f1056d92c"}},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"atomic:image","key":"e1834"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"1. Синглтон (Singleton)","type":"header-two","key":"3oaj3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Определение и цель","type":"header-three","key":"4mfmp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":8,"offset":0,"style":"BOLD"}],"text":"Синглтон —порождающий паттерн, который гарантирует, что у класса есть только один экземпляр, и предоставляет глобальную точку доступа к этому экземпляру.","type":"unstyled","key":"4a16k"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Проблема","type":"header-three","key":"9ovgh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В приложении может потребоваться объект, который должен существовать в \nединственном числе: например, менеджер конфигурации, пул соединений с \nбазой данных, кеш, логгер. Если позволить создавать несколько \nэкземпляров такого объекта, это приведёт к несогласованности состояния, \nизбыточному потреблению ресурсов или ошибкам. Традиционный подход — \nсделать конструктор приватным и управлять созданием внутри класса.","type":"unstyled","key":"embs9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализация в Go","type":"header-three","key":"7j74o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В Go нет классов и приватных конструкторов в классическом смысле. Однако \nмы можем достичь того же эффекта, используя пакетный уровень видимости \nи sync.Once для потокобезопасной ленивой инициализации. Рассмотрим пример:","type":"unstyled","key":"c5kru"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"package main\n\nimport (\n \"fmt\"\n \"sync\"\n)\n\n// Singleton — структура, экземпляр которой должен быть единственным.\ntype Singleton struct {\n data string\n}\n\nvar (\n instance *Singleton\n once sync.Once\n)\n\n// GetInstance возвращает единственный экземпляр Singleton.\n// Гарантируется, что инициализация произойдёт только один раз, даже при конкурентных вызовах.\nfunc GetInstance() *Singleton {\n once.Do(func() {\n instance = &Singleton{data: \"Это единственный экземпляр\"}\n fmt.Println(\"Синглтон создан\")\n })\n return instance\n}\n\nfunc main() {\n s1 := GetInstance()\n s2 := GetInstance()\n\n fmt.Println(s1 == s2) // true — ссылки на один и тот же объект\n fmt.Println(s1.data) // Это единственный экземпляр\n}","type":"blockquote","key":"81n6s"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Объяснение","type":"header-three","key":"49rq2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Переменная instance объявлена на уровне пакета, но не экспортируется (с маленькой буквы), поэтому доступ к ней извне возможен только через функцию GetInstance.","type":"unordered-list-item","key":"ac6a4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"sync.Once гарантирует, что переданная функция Do выполнится ровно один раз, даже при параллельных вызовах GetInstance. Это потокобезопасная реализация ленивой инициализации.","type":"unordered-list-item","key":"ahmvt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Функция GetInstance — глобальная точка доступа. Любой код, вызывающий её, получит указатель на тот же объект.","type":"unordered-list-item","key":"7p9np"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда использовать","type":"header-three","key":"2ek8q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда необходим ровно один экземпляр некоторого типа.","type":"unordered-list-item","key":"e3c2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда инициализация объекта ресурсоёмка и должна выполняться только при первом обращении (ленивая загрузка).","type":"unordered-list-item","key":"2f7r5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В системах с конкурентным доступом, где важно избежать гонок данных.","type":"unordered-list-item","key":"62rtn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Альтернативы и критика","type":"header-three","key":"au7um"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В некоторых кругах синглтон считается антипаттерном, так как он вносит \nглобальное состояние, усложняет тестирование и нарушает принцип \nединственной ответственности. В Go часто вместо синглтона используют \nобычные переменные пакетного уровня и функции-конструкторы, которые \nвызываются в init() или явно в main(). Например:","type":"unstyled","key":"egubm"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"var Config = loadConfig()\n\nfunc loadConfig() *Config { ... }","type":"blockquote","key":"910da"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это проще, но инициализация происходит сразу при загрузке пакета, а не по требованию. Выбор зависит от контекста.","type":"unstyled","key":"b194j"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Плюсы и минусы","type":"header-three","key":"36rk0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":0,"style":"BOLD"}],"text":"Плюсы:","type":"unstyled","key":"56hs8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Контролируемый доступ к единственному экземпляру.","type":"unordered-list-item","key":"4v4tc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Ленивая инициализация.","type":"unordered-list-item","key":"1v8ts"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Простота реализации.","type":"unordered-list-item","key":"2bbki"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"Минусы:","type":"unstyled","key":"9ir2q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Нарушение принципа открытости/закрытости (класс отвечает и за свою логику, и за управление экземпляром).","type":"unordered-list-item","key":"un3r"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Глобальное состояние усложняет модульное тестирование (замена экземпляра на заглушку требует дополнительных ухищрений).","type":"unordered-list-item","key":"6qd49"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В многопоточных средах требуется осторожность, хотя sync.Once решает эту проблему.","type":"unordered-list-item","key":"ctedj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"2. Фабрика (Factory)","type":"header-two","key":"fl1ks"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Определение и цель","type":"header-three","key":"9faq0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"Фабрика —порождающий паттерн, который предоставляет интерфейс для создания объектов, но позволяет подклассам (или конкретным реализациям) изменять тип создаваемых объектов. В более широком смысле фабрика инкапсулирует логику создания объектов, скрывая от клиента детали конструирования.","type":"unstyled","key":"flp3t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Проблема","type":"header-three","key":"23stv"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Клиентскому коду часто необходимо создавать объекты, но конкретный тип может \nзависеть от входных данных, конфигурации или других условий. Если \nразместить логику создания непосредственно в клиенте, код станет жёстко \nсвязанным с конкретными классами, что затруднит его расширение и \nтестирование. Паттерн Фабрика предлагает выделить создание объектов в \nотдельный компонент.","type":"unstyled","key":"775hb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Разновидности","type":"header-three","key":"eig2h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Существует несколько вариаций: простой фабричный метод, абстрактная фабрика. В Go часто используют простую фабрику — функцию, которая возвращает объект определённого интерфейса, выбирая конкретную реализацию на основе переданного параметра.","type":"unstyled","key":"7i551"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализация в Go","type":"header-three","key":"1160u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"package main\n\nimport \"fmt\"\n\n// Product — интерфейс, который должны реализовывать все создаваемые объекты.\ntype Product interface {\n Use() string\n}\n\n// ConcreteProductA — конкретная реализация Product.\ntype ConcreteProductA struct{}\n\nfunc (p *ConcreteProductA) Use() string {\n return \"Используется продукт A\"\n}\n\n// ConcreteProductB — ещё одна реализация.\ntype ConcreteProductB struct{}\n\nfunc (p *ConcreteProductB) Use() string {\n return \"Используется продукт B\"\n}\n\n// Factory — структура, содержащая фабричный метод.\ntype Factory struct{}\n\n// CreateProduct — фабричный метод, возвращающий Product в зависимости от типа.\n// Обратите внимание: он не привязан к состоянию Factory, поэтому мог бы быть и обычной функцией.\nfunc (f *Factory) CreateProduct(productType string) Product {\n switch productType {\n case \"A\":\n return &ConcreteProductA{}\n case \"B\":\n return &ConcreteProductB{}\n default:\n return nil\n }\n}\n\nfunc main() {\n factory := &Factory{}\n\n productA := factory.CreateProduct(\"A\")\n fmt.Println(productA.Use()) // Используется продукт A\n\n productB := factory.CreateProduct(\"B\")\n fmt.Println(productB.Use()) // Используется продукт B\n}","type":"blockquote","key":"h6a6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Объяснение","type":"header-three","key":"umnf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Мы определяем интерфейс Product,\n который будут реализовывать все продукты. Это позволяет клиенту \nработать с продуктами через интерфейс, не привязываясь к конкретным \nтипам.","type":"unordered-list-item","key":"5947q"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Структура Factory содержит метод CreateProduct, который принимает строковый параметр и возвращает нужную реализацию Product. Это классический пример простой фабрики.","type":"unordered-list-item","key":"5v13f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Клиент (функция main) создаёт экземпляр фабрики и запрашивает продукты по типу. Он не знает, как именно создаются продукты — это деталь фабрики.","type":"unordered-list-item","key":"9lo5h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Расширенный пример: фабричный метод с паттерном \"Строитель\"","type":"header-three","key":"cafi4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В реальных проектах создание объекта может быть сложным. Например, \nпродукт может требовать дополнительной настройки. Тогда фабрика может \nвызывать конструкторы или даже использовать паттерн Строитель.","type":"unstyled","key":"bfimf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда использовать","type":"header-three","key":"2oopc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда заранее неизвестны типы объектов, которые нужно создавать.","type":"unordered-list-item","key":"996ba"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда логика создания должна быть отделена от клиентского кода.","type":"unordered-list-item","key":"3fpgh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда необходимо централизовать управление созданием объектов (например, пулинг, кеширование).","type":"unordered-list-item","key":"eiba"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Преимущества и недостатки","type":"header-three","key":"3iioc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":0,"style":"BOLD"}],"text":"Плюсы:","type":"unstyled","key":"45goo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Уменьшает связанность между клиентом и конкретными классами.","type":"unordered-list-item","key":"ahjjn"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Упрощает добавление новых типов продуктов — достаточно реализовать интерфейс и дополнить фабрику.","type":"unordered-list-item","key":"dujac"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Способствует соблюдению принципа единственной ответственности.","type":"unordered-list-item","key":"4626f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"Минусы:","type":"unstyled","key":"16rmu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Может привести к созданию большого количества мелких классов (если для каждого продукта своя фабрика).","type":"unordered-list-item","key":"2ngab"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"При изменении интерфейса продукта придётся менять все реализации.","type":"unordered-list-item","key":"d3gim"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Особенности Go","type":"header-three","key":"4gpl6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Благодаря\n интерфейсам и неявной реализации, фабрики в Go получаются очень \nгибкими. Часто фабрикой служит обычная функция, возвращающая интерфейс. \nНапример:","type":"unstyled","key":"cljdq"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"func NewProduct(kind string) Product { ... }","type":"blockquote","key":"94cip"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это проще, чем создавать отдельную структуру Factory. Выбор зависит от того, нужна ли фабрике собственная конфигурация или состояние.","type":"unstyled","key":"d382i"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"3. Стратегия (Strategy)","type":"header-two","key":"q1u2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Определение и цель","type":"header-three","key":"bb360"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":0,"style":"BOLD"}],"text":"Стратегия — поведенческий паттерн, который определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми. Паттерн позволяет выбирать алгоритм во время выполнения программы независимо от клиентов, которые его используют.","type":"unstyled","key":"1ng9p"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Проблема","type":"header-three","key":"8jvc0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Представьте, что у вас есть класс, выполняющий некоторую операцию, но алгоритм операции может меняться в зависимости от контекста. Если закодировать все возможные варианты внутри класса с помощью условных операторов, класс станет громоздким и сложным для поддержки. Каждое добавление нового алгоритма потребует изменения класса. Паттерн Стратегия \nпредлагает вынести алгоритмы в отдельные классы (структуры), реализующие\n общий интерфейс.","type":"unstyled","key":"e5a4g"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализация в Go","type":"header-three","key":"60hf8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"package main\n\nimport \"fmt\"\n\n// Strategy — интерфейс, общий для всех алгоритмов.\ntype Strategy interface {\n Execute(a, b int) int\n}\n\n// AddStrategy — конкретная стратегия сложения.\ntype AddStrategy struct{}\n\nfunc (s *AddStrategy) Execute(a, b int) int {\n return a + b\n}\n\n// SubtractStrategy — конкретная стратегия вычитания.\ntype SubtractStrategy struct{}\n\nfunc (s *SubtractStrategy) Execute(a, b int) int {\n return a - b\n}\n\n// Context — структура, которая использует стратегию.\ntype Context struct {\n strategy Strategy\n}\n\n// SetStrategy позволяет динамически менять стратегию.\nfunc (c *Context) SetStrategy(strategy Strategy) {\n c.strategy = strategy\n}\n\n// ExecuteStrategy выполняет текущую стратегию.\nfunc (c *Context) ExecuteStrategy(a, b int) int {\n return c.strategy.Execute(a, b)\n}\n\nfunc main() {\n context := &Context{}\n\n // Используем стратегию сложения\n context.SetStrategy(&AddStrategy{})\n fmt.Println(context.ExecuteStrategy(5, 3)) // 8\n\n // Меняем стратегию на вычитание\n context.SetStrategy(&SubtractStrategy{})\n fmt.Println(context.ExecuteStrategy(5, 3)) // 2\n}","type":"blockquote","key":"15ha"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Объяснение","type":"header-three","key":"303rr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Интерфейс Strategy объявляет метод Execute, который принимает два целых числа и возвращает результат. Все конкретные стратегии реализуют этот интерфейс.","type":"unordered-list-item","key":"dcq2f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Структура Context хранит ссылку на текущую стратегию и делегирует ей выполнение операции.","type":"unordered-list-item","key":"8kdr6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Клиент (main) создаёт контекст, выбирает нужную стратегию и вызывает метод контекста. Стратегию можно сменить в любой момент.","type":"unordered-list-item","key":"bfr3b"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда использовать","type":"header-three","key":"895tg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда есть несколько родственных классов, отличающихся только поведением.","type":"unordered-list-item","key":"cv867"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда нужно иметь несколько версий алгоритма.","type":"unordered-list-item","key":"61ps3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда алгоритмы используют данные, которые клиент не должен знать.","type":"unordered-list-item","key":"2e8ir"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда необходимо избежать множества условных конструкций для выбора поведения.","type":"unordered-list-item","key":"150lo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реальные примеры","type":"header-three","key":"649ja"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Системы скидок в интернет-магазине: разные стратегии расчёта скидки (процентная, фиксированная, накопительная).","type":"unordered-list-item","key":"a6bk8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Способы оплаты: выбор платёжной системы.","type":"unordered-list-item","key":"4b0mt"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Сжатие данных: выбор алгоритма сжатия (ZIP, GZIP, и т.д.).","type":"unordered-list-item","key":"vvpu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Преимущества и недостатки","type":"header-three","key":"bku4u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":0,"style":"BOLD"}],"text":"Плюсы:","type":"unstyled","key":"3rln9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Замена алгоритмов происходит динамически.","type":"unordered-list-item","key":"d2nji"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Изолирует код алгоритмов от остальной логики, упрощая тестирование и поддержку.","type":"unordered-list-item","key":"897f0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализует принцип открытости/закрытости: новые стратегии добавляются без изменения существующего кода.","type":"unordered-list-item","key":"5v45o"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"Минусы:","type":"unstyled","key":"21jv6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Клиент должен знать о существовании различных стратегий и уметь выбирать подходящую.","type":"unordered-list-item","key":"db6nf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Увеличивает количество объектов (каждая стратегия — отдельная структура).","type":"unordered-list-item","key":"ec2h9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Особенности Go","type":"header-three","key":"emlll"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В Go стратегии часто реализуются как функции, а не как структуры с \nметодами. Можно объявить тип функции, реализующий интерфейс, если \nинтерфейс содержит один метод. Например:","type":"unstyled","key":"d88so"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"type Strategy func(int, int) int\n\ntype Context struct {\n strategy Strategy\n}\n\nfunc (c *Context) ExecuteStrategy(a, b int) int {\n return c.strategy(a, b)\n}","type":"blockquote","key":"cbhvb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Тогда стратегиями становятся обычные функции: AddStrategy := func(a, b int) int { return a+b }. Это более лаконично и соответствует идиоматическому Go, где предпочитают использовать функции первого класса.","type":"unstyled","key":"4s9u6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"4. Наблюдатель (Observer)","type":"header-two","key":"17ni1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Определение и цель","type":"header-three","key":"3tvpb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":11,"offset":0,"style":"BOLD"}],"text":"Наблюдатель — поведенческий паттерн, который создаёт механизм подписки, позволяющий одним объектам следить и реагировать на события, происходящие в других объектах. Его также называют \"издатель-подписчик\" \n(Publisher-Subscriber).","type":"unstyled","key":"9u3nj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Проблема","type":"header-three","key":"2l96v"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В системе часто требуется, чтобы изменение состояния одного объекта \nавтоматически оповещало другие объекты, чтобы те могли обновить своё \nсостояние или выполнить действия. Например, при обновлении данных в \nмодели пользовательского интерфейса, все связанные представления должны \nперерисоваться. Если жёстко зашить зависимости, система станет трудно \nрасширяемой.","type":"unstyled","key":"3dqa7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализация в Go","type":"header-three","key":"9scv5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"package main\n\nimport \"fmt\"\n\n// Observer — интерфейс для подписчиков.\ntype Observer interface {\n Update(message string)\n}\n\n// Subject — структура, за которой наблюдают.\ntype Subject struct {\n observers []Observer\n}\n\n// Attach добавляет нового наблюдателя.\nfunc (s *Subject) Attach(observer Observer) {\n s.observers = append(s.observers, observer)\n}\n\n// Detach удаляет наблюдателя (для полноты примера).\nfunc (s *Subject) Detach(observer Observer) {\n for i, o := range s.observers {\n if o == observer {\n s.observers = append(s.observers[:i], s.observers[i+1:]...)\n break\n }\n }\n}\n\n// Notify уведомляет всех наблюдателей о событии.\nfunc (s *Subject) Notify(message string) {\n for _, observer := range s.observers {\n observer.Update(message)\n }\n}\n\n// ConcreteObserver — конкретный наблюдатель.\ntype ConcreteObserver struct {\n name string\n}\n\nfunc (o *ConcreteObserver) Update(message string) {\n fmt.Printf(\"%s получил сообщение: %s\\n\", o.name, message)\n}\n\nfunc main() {\n subject := &Subject{}\n\n observer1 := &ConcreteObserver{name: \"Наблюдатель 1\"}\n observer2 := &ConcreteObserver{name: \"Наблюдатель 2\"}\n\n subject.Attach(observer1)\n subject.Attach(observer2)\n\n subject.Notify(\"Привет, мир!\")\n // Вывод:\n // Наблюдатель 1 получил сообщение: Привет, мир!\n // Наблюдатель 2 получил сообщение: Привет, мир!\n\n subject.Detach(observer1)\n subject.Notify(\"Второе сообщение\")\n // Вывод:\n // Наблюдатель 2 получил сообщение: Второе сообщение\n}","type":"blockquote","key":"3b9mf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Объяснение","type":"header-three","key":"fog0l"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Интерфейс Observer объявляет метод Update, который вызывается субъектом при изменении состояния.","type":"unordered-list-item","key":"23po7"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Структура Subject хранит список наблюдателей и предоставляет методы для управления подпиской.","type":"unordered-list-item","key":"238d"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"При вызове Notify субъект проходит по всем наблюдателям и вызывает их Update.","type":"unordered-list-item","key":"37doc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Конкретные наблюдатели реализуют Update и выполняют нужные действия.","type":"unordered-list-item","key":"8jmkp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Варианты реализации","type":"header-three","key":"7vc7r"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В реальных системах сообщение может содержать больше информации: ссылку \nна субъект, детали изменения. Часто используется канал событий или \nспециальный объект Event. В Go можно использовать каналы для \nасинхронного уведомления, но это усложняет управление подпиской.","type":"unstyled","key":"1l6ld"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда использовать","type":"header-three","key":"bl2sg"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда изменение состояния одного объекта требует изменения других, и вы не хотите жёстко связывать объекты.","type":"unordered-list-item","key":"8vh5c"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда одни объекты должны наблюдать за другими, но только в определённые моменты.","type":"unordered-list-item","key":"cl4k6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В системах событийно-ориентированной архитектуры.","type":"unordered-list-item","key":"40reu"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Преимущества и недостатки","type":"header-three","key":"e6ufm"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":0,"style":"BOLD"}],"text":"Плюсы:","type":"unstyled","key":"2ou49"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Слабая связанность между субъектом и наблюдателями.","type":"unordered-list-item","key":"62mtm"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Поддержка широковещательной рассылки.","type":"unordered-list-item","key":"1bfb0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Возможность динамически добавлять и удалять наблюдателей.","type":"unordered-list-item","key":"8u1p5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"Минусы:","type":"unstyled","key":"3mpl4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Наблюдатели могут получать уведомления в произвольном порядке (если порядок важен, нужны дополнительные меры).","type":"unordered-list-item","key":"2a7du"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Если неаккуратно реализовать отписку, возможны утечки памяти.","type":"unordered-list-item","key":"5t0no"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Слишком много уведомлений может снизить производительность.","type":"unordered-list-item","key":"3jcg5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Особенности Go","type":"header-three","key":"biqp9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В Go часто используют каналы для реализации асинхронного уведомления, но \nтогда субъект должен управлять каналами наблюдателей. Однако базовая \nреализация с синхронным вызовом методов проще и подходит для большинства\n случаев.","type":"unstyled","key":"6vkvb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"5. Декоратор (Decorator)","type":"header-two","key":"hek9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Определение и цель","type":"header-three","key":"af2h5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":9,"offset":0,"style":"BOLD"}],"text":"Декоратор — структурный паттерн, который позволяет динамически добавлять объектам новую функциональность, оборачивая их в полезные \"обёртки\" (декораторы).\n Он предоставляет гибкую альтернативу наследованию для расширения \nповедения.","type":"unstyled","key":"7ncjo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Проблема","type":"header-three","key":"ec5mf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Иногда\n нужно расширить функциональность объекта, но не изменять его класс, и \nпри этом хочется иметь возможность комбинировать различные расширения. \nНаследование приводит к взрывному росту числа классов (например, классы Звук, Цвет, Громкость и\n их комбинации). Декоратор решает эту проблему, позволяя оборачивать \nобъект в декораторы, каждый из которых добавляет свою часть поведения.","type":"unstyled","key":"87vd1"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализация в Go","type":"header-three","key":"b6tk8"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"package main\n\nimport \"fmt\"\n\n// Component — интерфейс для объектов, которые можно декорировать.\ntype Component interface {\n Operation() string\n}\n\n// ConcreteComponent — конкретный компонент, реализующий базовую функциональность.\ntype ConcreteComponent struct{}\n\nfunc (c *ConcreteComponent) Operation() string {\n return \"Базовая операция\"\n}\n\n// Decorator — базовая структура декоратора, содержащая ссылку на компонент.\n// В Go нет наследования, поэтому мы используем композицию.\ntype Decorator struct {\n component Component\n}\n\n// Operation декоратора добавляет своё поведение к поведению компонента.\nfunc (d *Decorator) Operation() string {\n return \"Декорированная \" + d.component.Operation()\n}\n\n// Можно создать несколько конкретных декораторов.\ntype BoldDecorator struct {\n Decorator\n}\n\nfunc (b *BoldDecorator) Operation() string {\n return \"\" + b.component.Operation() + \"\"\n}\n\ntype ItalicDecorator struct {\n Decorator\n}\n\nfunc (i *ItalicDecorator) Operation() string {\n return \"\" + i.component.Operation() + \"\"\n}\n\nfunc main() {\n component := &ConcreteComponent{}\n fmt.Println(component.Operation()) // Базовая операция\n\n // Декорируем базовый компонент декоратором (простой вариант)\n decoratedComponent := &Decorator{component: component}\n fmt.Println(decoratedComponent.Operation()) // Декорированная Базовая операция\n\n // Используем конкретные декораторы\n boldComponent := &BoldDecorator{Decorator{component: component}}\n fmt.Println(boldComponent.Operation()) // Базовая операция\n\n // Комбинируем декораторы: сначала жирный, потом курсив\n italicBoldComponent := &ItalicDecorator{Decorator{component: boldComponent}}\n fmt.Println(italicBoldComponent.Operation()) // Базовая операция\n}","type":"blockquote","key":"cb843"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Объяснение","type":"header-three","key":"5uerh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Интерфейс Component определяет общий метод Operation.","type":"unordered-list-item","key":"9ah1u"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"ConcreteComponent предоставляет базовую реализацию.","type":"unordered-list-item","key":"4o629"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Структура Decorator содержит поле component типа Component. Она сама реализует интерфейс Component, делегируя вызов вложенному компоненту и добавляя своё поведение.","type":"unordered-list-item","key":"68i22"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Конкретные декораторы (BoldDecorator, ItalicDecorator) встраивают Decorator и переопределяют Operation, добавляя обрамление.","type":"unordered-list-item","key":"11m0f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Благодаря\n тому, что декоратор реализует тот же интерфейс, что и компонент, мы \nможем оборачивать компонент в декораторы многократно.","type":"unordered-list-item","key":"7mphi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда использовать","type":"header-three","key":"bc55c"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда нужно добавить обязанности объектам динамически и прозрачно.","type":"unordered-list-item","key":"28thd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда расширение с помощью наследования невозможно или приводит к большому числу классов.","type":"unordered-list-item","key":"a2acd"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда необходимо комбинировать функциональность.","type":"unordered-list-item","key":"9srj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реальные примеры","type":"header-three","key":"7lunj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Потоки ввода-вывода: BufferedReader, GZIPInputStream в Java.","type":"unordered-list-item","key":"76fdq"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Графические редакторы: добавление рамок, теней, эффектов к графическим примитивам.","type":"unordered-list-item","key":"3654m"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Веб-разработка: middleware в веб-фреймворках (логирование, аутентификация, сжатие).","type":"unordered-list-item","key":"35pbb"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Преимущества и недостатки","type":"header-three","key":"4esmp"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":0,"style":"BOLD"}],"text":"Плюсы:","type":"unstyled","key":"da4lf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Гибкая комбинация поведения.","type":"unordered-list-item","key":"853n9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Соблюдение принципа единственной ответственности: каждый декоратор отвечает только за свою дополнительную функциональность.","type":"unordered-list-item","key":"1c9os"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Можно добавлять новые декораторы без изменения существующих классов.","type":"unordered-list-item","key":"95jgl"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"Минусы:","type":"unstyled","key":"att0s"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Трудно удалить конкретный декоратор из цепочки (приходится пересоздавать объект).","type":"unordered-list-item","key":"dd1p2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Может появиться много мелких объектов, что усложняет отладку.","type":"unordered-list-item","key":"5ii81"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Порядок декораторов может иметь значение (например, шифрование после сжатия даёт другой результат, чем сжатие после шифрования).","type":"unordered-list-item","key":"ca1jo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Особенности Go","type":"header-three","key":"709gc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В Go часто используют функциональные обёртки вместо структур. Например, для middleware в HTTP:","type":"unstyled","key":"cgmoa"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"type Middleware func(http.HandlerFunc) http.HandlerFunc","type":"blockquote","key":"an10j"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это тоже форма декоратора. Однако структурный подход более нагляден для сложных случаев.","type":"unstyled","key":"5i4fh"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"6. Адаптер (Adapter)","type":"header-two","key":"ck7ml"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Определение и цель","type":"header-three","key":"9u4o2"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"Адаптер —\n структурный паттерн, который позволяет объектам с несовместимыми \nинтерфейсами работать вместе. Он действует как прослойка между двумя \nинтерфейсами, преобразуя вызовы одного в формат, понятный другому.","type":"unstyled","key":"5iuuo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Проблема","type":"header-three","key":"bi3go"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Часто\n приходится интегрировать готовые компоненты, библиотеки или старый код,\n интерфейс которых не соответствует тому, что ожидает клиент. \nПереписывать их невозможно или нецелесообразно. Адаптер оборачивает \nнесовместимый объект и предоставляет нужный интерфейс.","type":"unstyled","key":"eukjo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Реализация в Go","type":"header-three","key":"a2lgi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"package main\n\nimport \"fmt\"\n\n// OldSystem — старая система с устаревшим интерфейсом.\ntype OldSystem struct{}\n\nfunc (o *OldSystem) LegacyOperation() string {\n return \"Старая система\"\n}\n\n// NewSystem — интерфейс, который ожидает клиент.\ntype NewSystem interface {\n NewOperation() string\n}\n\n// Adapter адаптирует OldSystem к интерфейсу NewSystem.\ntype Adapter struct {\n oldSystem *OldSystem\n}\n\n// NewOperation реализует требуемый интерфейс, вызывая LegacyOperation.\nfunc (a *Adapter) NewOperation() string {\n return \"Адаптированная \" + a.oldSystem.LegacyOperation()\n}\n\nfunc main() {\n oldSystem := &OldSystem{}\n adapter := &Adapter{oldSystem: oldSystem}\n\n // Клиент работает с адаптером через интерфейс NewSystem\n var newSys NewSystem = adapter\n fmt.Println(newSys.NewOperation()) // Адаптированная Старая система\n}","type":"blockquote","key":"3ksg3"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Объяснение","type":"header-three","key":"boc3e"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Есть старая структура OldSystem с методом LegacyOperation.","type":"unordered-list-item","key":"3d531"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Клиент работает с интерфейсом NewSystem, который требует метод NewOperation.","type":"unordered-list-item","key":"co72f"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Adapter содержит ссылку на OldSystem и реализует NewSystem, преобразуя вызов NewOperation в вызов LegacyOperation.","type":"unordered-list-item","key":"46iij"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В результате клиент может использовать адаптер, не зная о существовании старой системы.","type":"unordered-list-item","key":"3jp4i"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Разновидности адаптера","type":"header-three","key":"ac473"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":15,"offset":0,"style":"BOLD"}],"text":"Адаптер объекта (как в примере) — использует композицию, хранит ссылку на адаптируемый объект.","type":"unordered-list-item","key":"bl7of"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":14,"offset":0,"style":"BOLD"}],"text":"Адаптер класса — использует множественное наследование (в Go неприменимо, поэтому только объектный).","type":"unordered-list-item","key":"b2bt4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда использовать","type":"header-three","key":"58bja"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда нужно использовать существующий класс, но его интерфейс не соответствует потребностям.","type":"unordered-list-item","key":"bp0eo"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Когда нужно создать повторно используемый класс, который взаимодействует с классами, интерфейсы которых заранее неизвестны.","type":"unordered-list-item","key":"eb5tk"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"В системах, где происходит интеграция со сторонними библиотеками.","type":"unordered-list-item","key":"96t85"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Преимущества и недостатки","type":"header-three","key":"2i4hi"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":6,"offset":0,"style":"BOLD"}],"text":"Плюсы:","type":"unstyled","key":"664f5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Позволяет работать с несовместимыми интерфейсами без изменения их кода.","type":"unordered-list-item","key":"fnaag"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Способствует повторному использованию существующих компонентов.","type":"unordered-list-item","key":"f2uao"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Отделяет клиента от адаптируемого класса.","type":"unordered-list-item","key":"ac94s"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[{"length":7,"offset":0,"style":"BOLD"}],"text":"Минусы:","type":"unstyled","key":"cp9pr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Усложняет код из-за введения дополнительных классов.","type":"unordered-list-item","key":"6bq8h"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Иногда приходится писать много кода для простого преобразования.","type":"unordered-list-item","key":"88u8c"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Особенности Go","type":"header-three","key":"2ura9"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Интерфейсы\n в Go позволяют легко адаптировать любой тип, если он реализует нужные \nметоды. Можно даже адаптировать функцию, используя тип-адаптер. \nНапример:","type":"unstyled","key":"2ndch"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"type HandlerFunc func(http.ResponseWriter, *http.Request)\n\nfunc (f HandlerFunc) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n f(w, r)\n}","type":"blockquote","key":"ch3pf"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Это адаптация функции к интерфейсу http.Handler.","type":"unstyled","key":"6vubr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Дополнительные паттерны (краткий обзор)","type":"header-two","key":"7atou"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Строитель (Builder)","type":"header-three","key":"9mbg6"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Отделяет\n конструирование сложного объекта от его представления, позволяя \nсоздавать разные представления с помощью одного процесса \nконструирования. В Go часто реализуется через структуру с методами, \nвозвращающими саму структуру (цепочка вызовов).","type":"unstyled","key":"emrm0"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Команда (Command)","type":"header-three","key":"327br"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Превращает\n запросы в объекты, позволяя передавать их как аргументы, ставить в \nочередь, логировать и поддерживать отмену операций.","type":"unstyled","key":"2qlhj"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Состояние (State)","type":"header-three","key":"6b7mr"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Позволяет\n объекту менять поведение при изменении его внутреннего состояния. Похож\n на Стратегию, но состояние само определяет переходы.","type":"unstyled","key":"d3vpe"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Фасад (Facade)","type":"header-three","key":"braof"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Предоставляет простой интерфейс к сложной системе подсистем, скрывая её внутренние детали.","type":"unstyled","key":"4cvho"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Эти паттерны также легко реализуются в Go и могут быть полезны.","type":"unstyled","key":"bg6js"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Заключение","type":"header-two","key":"snq4"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Паттерны проектирования — это не догма, а набор проверенных решений, которые помогают разработчикам справляться с типовыми задачами. В Go, благодаря \nпростоте языка и мощным возможностям интерфейсов и композиции, многие \nпаттерны реализуются естественным образом и часто в более лаконичной \nформе, чем в классических ОО-языках.","type":"unstyled","key":"1opt5"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Однако важно помнить, что использование паттернов должно быть оправдано. Не стоит внедрять паттерн только ради паттерна — это может привести к \nизлишней сложности. Всегда оценивайте, действительно ли проблема, \nкоторую решает паттерн, присутствует в вашем проекте.","type":"unstyled","key":"7o4rc"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"Изучение паттернов помогает развить архитектурное мышление и улучшить \nкоммуникацию в команде. Надеемся, что данное подробное руководство \nпоможет вам уверенно применять Singleton, Factory, Strategy, Observer, \nDecorator и Adapter в своих проектах на Go.","type":"unstyled","key":"6qg0s"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"3mblq"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"header-two","key":"br76t"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"unstyled","key":"8m564"},{"data":{},"depth":0,"entityRanges":[],"inlineStyleRanges":[],"text":"","type":"marker","key":"NxAVPrYS4Tib9u22wjfc"}],"entityMap":{}},"mentions":[]}