Sobes.tech
Hulp bij sollicitatiegesprekken
Hulpbronnen
Voorbereiding op sollicitatiegesprek
Hulpbronnen
Zoeken naar een baan
Hulpbronnen
Legaal
Terug naar vragen
Junior

Met welke ontwerppatronen bent u bekend?

sobes.tech AI

Antwoord van AI

Ik ben bekend met verschillende ontwerppatronen die in Go worden gebruikt. Enkele van de meest voorkomende:

Creational patterns:

  • Singleton: Zorgt ervoor dat er slechts één instantie van een klasse bestaat en biedt een globaal toegangspunt daartoe. In Go wordt dit vaak geïmplementeerd met sync.Once.
    package main

import (
	"sync"
)

type singleton struct{}

var instance *singleton
var once sync.Once

func GetInstance() *singleton {
	once.Do(func() {
		instance = &singleton{}
	})
	return instance
}
  • Factory Method: Definieert een interface voor het maken van een object, maar laat subklassen beslissen welke klasse te instantiëren. In Go wordt dit vaak geïmplementeerd met functies die interfaces retourneren.
    package main

type Product interface {
	Operate()
}

type ConcreteProductA struct{}

func (p *ConcreteProductA) Operate() {
	// Implementatie van de operatie
}

type ConcreteProductB struct{}

func (p *ConcreteProductB) Operate() {
	// Implementatie van de operatie
}

func NewProduct(productType string) Product {
	switch productType {
	case "A":
		return &ConcreteProductA{}
	case "B":
		return &ConcreteProductB{}
	default:
		return nil // Of fout
	}
}
  • Abstract Factory: Biedt een interface voor het creëren van families van gerelateerde of afhankelijke objecten zonder hun concrete klassen te specificeren.
  • Builder: Scheidt het proces van het construeren van een complex object van zijn representatie.

Structural patterns:

  • Adapter: Converteert de interface van een klasse naar een andere die door de klanten wordt verwacht. Maakt het mogelijk dat incompatibele klassen samenwerken.
  • Decorator: Voegt dynamisch nieuwe verantwoordelijkheden toe aan een object. Decorators bieden een flexibeler alternatief voor overerving om functionaliteit uit te breiden.
  • Facade: Biedt een geünificeerde interface voor een set interfaces in een subsysteem. Definieert een high-level interface die het gebruik van het subsysteem vergemakkelijkt.
  • Proxy: Biedt een vervanger of vertegenwoordiger voor een ander object om toegang te beheren.

Gedragspatronen:

  • Observer: Definieert een "een-op-velen" afhankelijkheid tussen objecten. Wanneer de toestand van een object verandert, worden alle afhankelijke objecten op de hoogte gesteld en automatisch bijgewerkt.
  • Strategy: Definieert een familie van algoritmen, kapselt elk ervan in en maakt ze verwisselbaar. Maakt het mogelijk algoritmen onafhankelijk van de clients die ze gebruiken te variëren.
    package main

type Strategy interface {
	Execute(data string)
}

type ConcreteStrategyA struct{}

func (s *ConcreteStrategyA) Execute(data string) {
	// Implementatie van strategie A
}

type ConcreteStrategyB struct{}

func (s *ConcreteStrategyB) Execute(data string) {
	// Implementatie van strategie B
}

type Context struct {
	strategy Strategy
}

func (c *Context) SetStrategy(strategy Strategy) {
	c.strategy = strategy
}

func (c *Context) ExecuteStrategy(data string) {
	c.strategy.Execute(data)
}
  • Template Method: Definieert het raamwerk van een algoritme in een operatie, waarbij sommige stappen aan subklassen worden overgelaten. Hiermee kunnen subklassen bepaalde stappen van een algoritme herdefiniëren zonder de structuur te wijzigen.

Naast de genoemde patronen, ken ik ook patronen zoals Command, Chain of Responsibility, Iterator, Mediator, Memento, State, Visitor. In Go worden ook vaak idioms van ontwerp gebruikt die specifiek zijn voor de taal, zoals het gebruik van interfaces voor abstractie, goroutines en kanalen voor parallelisme.

VorigeVolgende