// Интерфейс + структура - проще и гибче, чем абстрактный класс
type Logger interface {
    Log(msg string)
}

type ConsoleLogger struct{}
func (ConsoleLogger) Log(msg string) { fmt.Println(msg) }

type FileLogger struct{ path string }
func (l FileLogger) Log(msg string) {
    os.WriteFile(l.path, []byte(msg), 0644)
}

В Go интерфейс реализуется неявно - не нужно писать implements. Если структура имеет нужные методы - она уже реализует интерфейс. Это делает паттерны легковеснее.

interface Logger
{
    public function log(string $msg): void;
}

final class ConsoleLogger implements Logger
{
    public function log(string $msg): void
    {
        echo $msg, PHP_EOL;
    }
}

final class FileLogger implements Logger
{
    public function __construct(
        private readonly string $path,
    ) {}

    public function log(string $msg): void
    {
        file_put_contents($this->path, $msg . "\n", FILE_APPEND);
    }
}

В PHP интерфейс реализуется явно через implements - компилятор контролирует контракт. В отличие от Go, где интерфейсы неявные (тип удовлетворяет интерфейсу автоматически, если у него есть нужные методы) - в PHP контракт декларируется в сигнатуре класса. Для большинства паттернов хватает интерфейса + final-классов + DI через конструктор. Symfony и Laravel опираются на эту модель.

// В JS нет интерфейсов - есть duck-typing: «есть метод log() - значит это Logger»
class ConsoleLogger {
  log(msg) {
    console.log(msg);
  }
}

class FileLogger {
  #path;
  constructor(path) {
    this.#path = path;
  }
  log(msg) {
    const fs = require('node:fs');
    fs.appendFileSync(this.#path, msg + '\n');
  }
}

function useLogger(logger) {
  logger.log('hello');
}

useLogger(new ConsoleLogger());
useLogger(new FileLogger('/tmp/app.log'));

В JS контракт неформальный - как в Go (по факту наличия методов), но без проверки компилятора. JSDoc-аннотации (@implements) или TypeScript-interface нужны, если хочется проверки на этапе сборки. Приватные поля через # появились в ES2022 и нужны, когда состояние не должно утечь наружу.

type User struct {
    Email        string
    Subscription Subscription // Free / Premium
    Roles        []Role       // [Reader, Editor, Admin]
}

// «Премиум-админ» - это просто значение
u := User{
    Email:        "a@b.c",
    Subscription: Premium{},
    Roles:        []Role{Admin{}},
}

<?php
declare(strict_types=1);

final readonly class User
{
    /** @param list<Role> $roles */
    public function __construct(
        public string $email,
        public Subscription $subscription, // Free / Premium
        public array $roles,               // [Reader, Editor, Admin]
    ) {}
}

// «Премиум-админ» - это просто значение
$user = new User('a@b.c', new Premium(), [new Admin()]);

class User {
  constructor({ email, subscription, roles }) {
    this.email = email;
    this.subscription = subscription; // Free / Premium
    this.roles = roles;               // [Reader, Editor, Admin]
  }
}

// «Премиум-админ» - это просто значение
const user = new User({
  email: 'a@b.c',
  subscription: new Premium(),
  roles: [new Admin()],
});

type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }

// Один и тот же json.Decoder работает с любой стратегией чтения
json.NewDecoder(os.Stdin).Decode(&v)              // из stdin
json.NewDecoder(file).Decode(&v)                  // из файла
json.NewDecoder(http.Response.Body).Decode(&v)    // из HTTP-ответа
json.NewDecoder(strings.NewReader(s)).Decode(&v)  // из строки

<?php
declare(strict_types=1);

use Psr\Http\Message\StreamInterface;

// PSR-7 StreamInterface - тот же приём: один интерфейс над разными источниками
function decode(StreamInterface $stream): array
{
    /** @var array<string, mixed> $data */
    $data = json_decode((string) $stream, associative: true, flags: JSON_THROW_ON_ERROR);

    return $data;
}

decode($psrRequest->getBody());          // из HTTP-запроса
decode(Utils::streamFor($fileResource)); // из файлового ресурса
decode(Utils::streamFor($jsonString));   // из строки

// В Node.js Web Streams API играет ту же роль - единый ReadableStream
// над файлом, HTTP-телом, in-memory буфером
async function decode(stream) {
  const text = await new Response(stream).text();
  return JSON.parse(text);
}

await decode(request.body);                                // из HTTP-запроса
await decode(fs.createReadStream('data.json'));            // из файла
await decode(new Blob([jsonString]).stream());             // из строки

type Handler interface { ServeHTTP(w ResponseWriter, r *Request) }

// HandlerFunc - адаптер, превращающий обычную функцию в Handler
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { f(w, r) }

http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello"))
})
// HandleFunc внутри делает: handler := HandlerFunc(f); router.Register(handler)

<?php
declare(strict_types=1);

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;

// PSR-15 RequestHandlerInterface - интерфейс с одним методом handle()
// Адаптер превращает обычное замыкание в RequestHandlerInterface
final class CallableHandler implements RequestHandlerInterface
{
    /** @param callable(ServerRequestInterface): ResponseInterface $fn */
    public function __construct(
        private $fn,
    ) {}

    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        return ($this->fn)($request);
    }
}

$router->add('/hello', new CallableHandler(
    fn (ServerRequestInterface $r) => $responses->text('hello'),
));

// В Express маршрут принимает callback (req, res) - это и есть адаптер
// функции под обработчик. Класс с методом handle() оборачивается так же:
app.get('/hello', (req, res) => {
  res.send('hello');
});

class HelloHandler {
  handle(req, res) { res.send('hello'); }
}

const handler = new HelloHandler();
app.get('/hello', (req, res) => handler.handle(req, res));

func logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        slog.Info("req", "path", r.URL.Path, "took", time.Since(start))
    })
}

handler = recovery(logging(auth(myHandler)))

<?php
declare(strict_types=1);

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\Log\LoggerInterface;

final class LoggingMiddleware implements MiddlewareInterface
{
    public function __construct(
        private readonly LoggerInterface $logger,
    ) {}

    public function process(
        ServerRequestInterface $request,
        RequestHandlerInterface $handler,
    ): ResponseInterface {
        $t = microtime(true);
        try {
            return $handler->handle($request);
        } finally {
            $ms = (int) ((microtime(true) - $t) * 1000);
            $this->logger->info(sprintf('%s %d ms', $request->getUri(), $ms));
        }
    }
}

// Стек = recovery + logging + auth + handler
$pipeline = new Pipeline([$recovery, $logging, $auth], $myHandler);

// Express: middleware = (req, res, next) => { ... next(); }
function logging(req, res, next) {
  const start = Date.now();
  res.on('finish', () => {
    console.log(`${req.url} ${Date.now() - start} ms`);
  });
  next();
}

// Стек = recovery + logging + auth + handler
app.use(recovery);
app.use(logging);
app.use(auth);
app.get('/me', myHandler);

var (
    once sync.Once
    db   *sql.DB
)

func GetDB() *sql.DB {
    once.Do(func() {
        db, _ = sql.Open("postgres", os.Getenv("DATABASE_URL"))
    })
    return db
}

<?php
declare(strict_types=1);

// В Symfony DI-контейнер сам делает сервис лениво-singleton-ом.
// Без контейнера - простой кэш на статическом поле фабрики.
final class DbFactory
{
    private static ?PDO $db = null;

    public static function get(): PDO
    {
        return self::$db ??= new PDO(getenv('DATABASE_URL'));
    }
}

$pdo = DbFactory::get();

// Идиома Node.js: ленивый кэш модульного уровня. Модуль грузится один раз,
// поэтому переменная по сути singleton.
let db = null;

export function getDb() {
  return db ??= new Pool({ connectionString: process.env.DATABASE_URL });
}

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}
func Sort(data Interface)        // алгоритм фиксирован, шаги переопределяются

<?php
declare(strict_types=1);

// usort - алгоритм сортировки фиксирован, стратегия сравнения передаётся колбэком
$users = [/* ... */];

usort($users, static fn (User $a, User $b): int => $a->createdAt <=> $b->createdAt);

// Array.prototype.sort - алгоритм фиксирован (стабильный TimSort с ES2019),
// стратегия сравнения передаётся колбэком
const users = [/* ... */];

users.sort((a, b) => a.createdAt - b.createdAt);

// Over-engineering
type ServiceFactoryFactory interface {
    NewServiceFactory(env string) ServiceFactory
}
type ServiceFactory interface {
    NewService(cfg Config) Service
}
type Service interface {
    Do(ctx context.Context, req Req) (Resp, error)
}

// Чтобы получить Service:
ff := NewProdFactoryFactory()
f  := ff.NewServiceFactory("prod")
s  := f.NewService(cfg)

<?php
declare(strict_types=1);

// Over-engineering
interface ServiceFactoryFactory
{
    public function newServiceFactory(string $env): ServiceFactory;
}

interface ServiceFactory
{
    public function newService(Config $cfg): Service;
}

interface Service
{
    public function do(Request $req): Response;
}

// Чтобы получить Service:
$ff = new ProdFactoryFactory();
$f  = $ff->newServiceFactory('prod');
$s  = $f->newService($cfg);

// Over-engineering
class ProdFactoryFactory {
  newServiceFactory(env) { return new ProdServiceFactory(env); }
}
class ProdServiceFactory {
  newService(cfg) { return new Service(cfg); }
}

// Чтобы получить Service:
const ff = new ProdFactoryFactory();
const f  = ff.newServiceFactory('prod');
const s  = f.newService(cfg);

// В Go обычно достаточно конструктора-функции
func NewService(cfg Config) (*Service, error) {
    return &Service{cfg: cfg}, nil
}
s, err := NewService(cfg)

<?php
declare(strict_types=1);

// В PHP обычно достаточно конструктора + DI-контейнера (Symfony)
final class Service
{
    public function __construct(
        private readonly Config $cfg,
    ) {}
}

$service = new Service($cfg);

// Обычно достаточно конструктора + DI через параметры
class Service {
  #cfg;
  constructor(cfg) { this.#cfg = cfg; }
}

const service = new Service(cfg);