PHP Academy · leksjon

Statiske egenskaper og metoder

Bruk statiske medlemmer og forstå når de kan kalles uten en instans.

Leksjon 3 av 413 trinn

Statiske egenskaper og metoder er en gratis leksjon i PHP Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i PHP Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i PHP Academy inneholder totalt 4 leksjoner.

Introduksjon: Statiske egenskaper og metoder

Statiske medlemmer tilhører selve klassen i stedet for en instans. Få tilgang til dem med ClassName::member eller self:: inne i klassen. De deles av alle instanser.

Grunnleggende konsepter

Viktige konsepter for statiske egenskaper og metoder:

Deklarer med nøkkelordet static
Få tilgang med :: (scope resolution-operatoren)
self:: inne i klassen; ClassName:: utenfra
Sen statisk binding med static::

Statisk egenskap

Eksempel:

<?php
class AppConfig {
    private static array $settings = [];

    public static function set(string $key, mixed $val): void {
        self::$settings[$key] = $val;
    }

    public static function get(string $key, mixed $default = null): mixed {
        return self::$settings[$key] ?? $default;
    }
}

AppConfig::set('debug', true);
echo AppConfig::get('debug') ? 'debug on' : 'debug off';

Statisk metode

Fortsettelse:

<?php
class MathHelper {
    public static function clamp(float $v, float $min, float $max): float {
        return max($min, min($max, $v));
    }

    public static function lerp(float $a, float $b, float $t): float {
        return $a + ($b - $a) * $t;
    }
}

echo MathHelper::clamp(150, 0, 100); // 100
echo MathHelper::lerp(0, 100, 0.5);  // 50

Singleton-mønsteret

Øvelse:

<?php
class Database {
    private static ?Database $instance = null;

    private function __construct() {
        echo 'Connected to DB';
    }

    public static function getInstance(): self {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

$db1 = Database::getInstance();  // 'Connected to DB'
$db2 = Database::getInstance();  // no output — same instance
echo ($db1 === $db2) ? 'same' : 'different'; // same

Statisk teller

Fordypning:

<?php
class EventEmitter {
    private static int $instanceCount = 0;

    public function __construct() {
        self::$instanceCount++;
    }

    public static function count(): int {
        return self::$instanceCount;
    }
}

new EventEmitter();
new EventEmitter();
new EventEmitter();
echo EventEmitter::count();  // 3

Sen statisk binding

Avansert bruk:

<?php
class ParentClass {
    public static function create(): static {
        return new static();  // resolves to calling subclass
    }

    public function getClass(): string {
        return static::class;  // late static binding
    }
}

class ChildClass extends ParentClass {}

$obj = ChildClass::create();
echo $obj->getClass();  // ChildClass

Statisk fabrikk

Praktisk mønster:

<?php
class Response {
    private function __construct(
        private int   $status,
        private mixed $body
    ) {}

    public static function ok(mixed $data): self {
        return new self(200, $data);
    }

    public static function notFound(): self {
        return new self(404, ['error' => 'Not Found']);
    }

    public function toJson(): string {
        return json_encode(['status' => $this->status, 'body' => $this->body]);
    }
}

echo Response::ok(['users' => []])->toJson();

Avveininger mellom statisk og instansbasert bruk

Beste praksis:

<?php
// Static: no object needed, but harder to test/mock
class Validator {
    public static function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}

// Instance: injectable dependency, testable
class ValidatorService {
    public function isEmail(string $s): bool {
        return (bool) filter_var($s, FILTER_VALIDATE_EMAIL);
    }
}
// Prefer instance classes in larger applications

Praktisk mønster

Her settes alt sammen i et praktisk mønster for statiske egenskaper og metoder.

Vanlige fallgruver

Unngå disse vanlige feilene med statiske egenskaper og metoder:

Statiske medlemmer deles av alle instanser
Foretrekk sen statisk binding (static::) fremfor self:: i klasser som kan arves
Singletoner er et vanlig, men iblant overbrukt mønster
Statiske metoder er vanskeligere å mocke i enhetstester

Rask kontroll

Hvilket nøkkelord gir tilgang til en statisk egenskap inne i klassen og tar hensyn til arv (sen statisk binding)?

Besvar den i den interaktive leksjonen

Oppsummering: Statiske egenskaper og metoder

De har gått gjennom statiske egenskaper og metoder. Viktige punkter å huske:

Statiske medlemmer deles av alle instanser
Foretrekk sen statisk binding (static::) fremfor self:: i klasser som kan arves
Singletoner er et vanlig, men iblant overbrukt mønster
Statiske metoder er vanskeligere å mocke i enhetstester

Gratis å komme i gang

Lær deg PHP med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 49
Leksjoner: 195

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Statiske egenskaper og metoder» gratis?

Ja – hele teksten i «Statiske egenskaper og metoder» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av PHP Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i PHP Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Statiske egenskaper og metoder»?

Bruk statiske medlemmer og forstå når de kan kalles uten en instans. Du øver på PHP Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med PHP Academy?

Ingen tidligere erfaring er nødvendig. PHP Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Statiske egenskaper og metoder»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne PHP Academy-leksjonen?

Ja. Alle PHP Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til PHP Academy