Egenskaper

```mediawiki

Egenskaper

Klassmedlemmars variabler kallas egenskaper. De kan hänvisas till med andra termer som fält, men för syftet med denna referens kommer termen egenskaper att användas. De definieras genom att använda minst en modifierare (som synlighet, statiskt nyckelord eller, från och med PHP 8.1.0, readonly), eventuellt (förutom för readonly-egenskaper), från och med PHP 7.4, följt av en typdeklaration, följt av en vanlig variabeldeklaration. Denna deklaration kan inkludera en initialisering, men denna initialisering måste vara ett konstant värde.

Observera:

Ett föråldrat sätt att deklarera klassegenskaper är att använda nyckelordet `var` istället för en modifierare.

Observera: En egenskap som deklareras utan en synlighetsmodifierare kommer att deklareras som public.

Inom klassmetoder kan icke-statiska egenskaper nås med hjälp av `->` (Objektoperatorn): `$this->property` (där `property` är namnet på egenskapen). Statisk egenskaper nås med hjälp av `::` (Dubbelkolon): `self::$property`. Se Statisk nyckelord för mer information om skillnaden mellan statiska och icke-statiska egenskaper.

Pseudovariabeln `$this` är tillgänglig i vilken klassmetod som helst när den metoden anropas från ett objektkontext. `$this` är värdet av det anropande objektet.

Exempel #1 Egenskapsdeklarationer

<?php
class SimpleClass
{
   public $var1 = 'hej ' . 'värld';
   public $var2 = <<<EOD
hej värld
EOD;
   public $var3 = 1+2;
   // ogiltiga egenskapsdeklarationer:
   public $var4 = self::myStaticMethod();
   public $var5 = $myVar;

   // giltiga egenskapsdeklarationer:
   public $var6 = myConstant;
   public $var7 = [true, false];

   public $var8 = <<<'EOD'
hej värld
EOD;

   // Utan synlighetsmodifierare:
   static $var9;
   readonly int $var10;
}
?>

Observera:

Det finns olika funktioner för att hantera klasser och objekt. Se Klass/Objektfunktioner.

Typdeklarationer

Från och med PHP 7.4.0 kan egenskapsdefinitioner inkludera typdeklarationer, med undantag för callable.

Exempel #2 Exempel på typade egenskaper

<?php

class User
{
    public int $id;
    public ?string $name;

    public function __construct(int $id, ?string $name)
    {
        $this->id = $id;
        $this->name = $name;
    }
}

$user = new User(1234, null);

var_dump($user->id);
var_dump($user->name);

?>

Output av ovanstående exempel:

int(1234)
NULL

Typade egenskaper måste initialiseras innan de används, annars kastas ett fel.

Exempel #3 Åtkomst till egenskaper

<?php

class Shape
{
    public int $numberOfSides;
    public string $name;

    public function setNumberOfSides(int $numberOfSides): void
    {
        $this->numberOfSides = $numberOfSides;
    }

    public function setName(string $name): void
    {
        $this->name = $name;
    }

    public function getNumberOfSides(): int
    {
        return $this->numberOfSides;
    }

    public function getName(): string
    {
        return $this->name;
    }
}

$triangle = new Shape();
$triangle->setName("triangel");
$triangle->setNumberofSides(3);
var_dump($triangle->getName());
var_dump($triangle->getNumberOfSides());

$circle = new Shape();
$circle->setName("cirkel");
var_dump($circle->getName());
var_dump($circle->getNumberOfSides());
?>

Output av ovanstående exempel:

string(8) "triangel"
int(3)
string(6) "cirkel"

Fatal error: Uncaught Error: Typed property Shape::$numberOfSides must not be accessed before initialization

Readonly-egenskaper

Från och med PHP 8.1.0 kan en egenskap deklareras med modifieraren `readonly`, vilket förhindrar modifiering av egenskapen efter initialisering.

Exempel #4 Exempel på readonly-egenskaper

<?php

class Test {
   public readonly string $prop;

   public function __construct(string $prop) {
       // Laglig initialisering.
       $this->prop = $prop;
   }
}

$test = new Test("foobar");
// Laglig läsning.
var_dump($test->prop); // string(6) "foobar"

// Olaglig omdefiniering. Det spelar ingen roll att det tilldelade värdet är detsamma.
$test->prop = "foobar";
// Fel: Kan inte ändra readonly-egenskapen Test::$prop
?>

Observera:

Modifieraren `readonly` kan endast tillämpas på typade egenskaper. En readonly-egenskap utan typbegränsningar kan skapas genom att använda typen `mixed`.

Observera:

Readonly statiska egenskaper stöds inte.

En readonly-egenskap kan endast initialiseras en gång och endast från den scope där den har deklarerats. Varje annan tilldelning eller modifiering av egenskapen kommer att resultera i ett fel undantag.

Exempel #5 Olaglig initialisering av readonly-egenskaper

<?php
class Test1 {
    public readonly string $prop;
}

$test1 = new Test1;
// Olaglig initialisering utanför privat scope.
$test1->prop = "foobar";
// Fel: Kan inte initialisera readonly-egenskapen Test1::$prop från global scope
?>

Observera:

Det är inte tillåtet att specificera ett explicit standardvärde på readonly-egenskaper, eftersom en readonly-egenskap med ett standardvärde i huvudsak är densamma som en konstant, och därför inte särskilt användbar.

<?php

class Test {
    // Fatalt fel: Readonly-egenskapen Test::$prop kan inte ha standardvärde
    public readonly int $prop = 42;
}
?>

Observera:

Readonly-egenskaper kan inte `unset()` efter att de har initialiserats. Det är dock möjligt att `unset()` en readonly-egenskap innan initialiseringen, från den scope där egenskapen har deklarerats.

Modifieringar är inte nödvändigtvis enkla tilldelningar, allt följande kommer också att resultera i ett fel undantag:

<?php

class Test {
    public function __construct(
        public readonly int $i = 0,
        public readonly array $ary = [],
    ) {}
}

$test = new Test;
$test->i += 1;
$test->i++;
++$test->i;
$test->ary[] = 1;
$test->ary[0][] = 1;
$ref =& $test->i;
$test->i =& $ref;
byRef($test->i);
foreach ($test som &$prop);
?>

Readonly-egenskaper utesluter dock inte intern mutabilitet. Objekt (eller resurser) lagrade i readonly-egenskaper kan fortfarande modifieras internt:

<?php

class Test {
    public function __construct(public readonly object $obj) {}
}

$test = new Test(new stdClass);
// Laglig intern mutation.
$test->obj->foo = 1;
// Olaglig omdefiniering.
$test->obj = new stdClass;
?>

Dynamiska egenskaper

Om du försöker tilldela en icke-existerande egenskap på ett objekt, kommer PHP automatiskt att skapa en motsvarande egenskap. Denna dynamiskt skapade egenskap kommer endast att vara tillgänglig på denna klassinstans.

Varning: Dynamiska egenskaper är föråldrade från och med PHP 8.2.0. Det rekommenderas att deklarera egenskapen istället. För att hantera godtyckliga egenskapsnamn bör klassen implementera de magiska metoderna `__get()` och `__set()`. Som en sista utväg kan klassen markeras med attributet `#[\AllowDynamicProperties]`. ```

Sidslut

Orginalhemsidan på Engelska :
PHP
Språkreferens
Språkreferens#Klasser_och_Objekt