PHP Academy · Lektion

Statiske egenskaber og metoder

Brug statiske medlemmer, og forstå, hvornår De kan kalde dem uden en instans.

Lektion 3 af 413 trin

Statiske egenskaber og metoder er en gratis PHP Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i PHP Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. PHP Academy-kurset indeholder 4 lektioner i alt.

Introduktion: Statiske egenskaber og metoder

Statiske medlemmer hører til selve klassen i stedet for en instans. Du får adgang til dem med ClassName::member eller self:: inde i klassen. De deles af alle instanser.

Kernebegreber

Vigtige begreber om statiske egenskaber og metoder:

Erklær dem med nøgleordet static
Få adgang med :: (operatoren til bestemmelse af synlighedsområde)
self:: inde i klassen; ClassName:: udefra
Sen statisk binding med static::

Statisk egenskab

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

Fortsat:

<?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

Singletonmønster

Ø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 tæller

Fordybelse:

<?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

Avanceret brug:

<?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 fabrik

Mønster fra praksis:

<?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();

Afvejninger mellem statisk og instans

Bedste 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 samler du det hele i et praktisk mønster for statiske egenskaber og metoder.

Almindelige faldgruber

Undgå disse almindelige fejl med statiske egenskaber og metoder:

Statiske medlemmer deles af alle instanser
Foretræk sen statisk binding (static::) frem for self:: i klasser, der kan nedarves fra
Singletoner er et almindeligt, men undertiden overbrugt mønster
Statiske metoder er sværere at mocke i enhedstests

Hurtig kontrol

Hvilket nøgleord giver adgang til en statisk egenskab inde i klassen og respekterer nedarvning (sen statisk binding)?

Besvar den i den interaktive lektion

Opsummering: Statiske egenskaber og metoder

Du har gennemgået statiske egenskaber og metoder. Vigtige punkter at huske:

Statiske medlemmer deles af alle instanser
Foretræk sen statisk binding (static::) frem for self:: i klasser, der kan nedarves fra
Singletoner er et almindeligt, men undertiden overbrugt mønster
Statiske metoder er sværere at mocke i enhedstests

Gratis at komme i gang

Lær PHP med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 49
Lektioner: 195

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Statiske egenskaber og metoder” gratis?

Ja — hele teksten til “Statiske egenskaber og metoder” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af PHP Academy-kurset, skal du opgradere til CoddyKit PRO. PHP Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Statiske egenskaber og metoder”?

Brug statiske medlemmer, og forstå, hvornår De kan kalde dem uden en instans. Du øver dig i PHP Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på PHP Academy?

Der kræves ingen tidligere erfaring. PHP Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Statiske egenskaber og metoder”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne PHP Academy-lektion?

Ja. Alle PHP Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til PHP Academy