PHP: Nozioni di base

Nozioni di base

class

La definizione più semplice di una classe è composta dal termine class, seguito dal nome della classe, seguito da una coppia di parentesi graffe che racchiudono le definizioni delle proprietà e dei metodi che fanno parte della classe stessa.

Il nome della classe può essere una qualunque etichetta valida che non sia una parola riservata di PHP. Un nome di classe valido inizia con una lettera o un underscore, seguiti da lettere, numeri, o underscores. Questa regola può essere rappresentata dalla seguente espressione regolare: ^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$.

Una classe può contenere le proprie costanti, variabili (chiamate "proprietà"), e funzioni (chiamate "methods").

Example #1 Semplice definizione di una classe

<?php
class SimpleClass
{
    // dichiarazione di proprietà
    public $var = 'un valore di default';

    // dichiarazione di metodi
    public function mostraVar() {
        echo $this->var;
    }
}
?>

La pseudo-variabile $this è disponibile quando un metodo è invocato dall'interno del contesto di un oggetto. $this è il valore dell'oggetto chiamante.

Avviso

La chiamata in modo statico di un metodo non statico genera un Error. Prima di PHP 8.0.0, questo generava un avviso di deprecazione e $this non sarebbe stato definito.

Example #2 Esempi della pseudo-variabile $this

<?php
class A
{
    function foo()
    {
        if (isset($this)) {
            echo '$this è definito (';
            echo get_class($this);
            echo ")\n";
        } else {
            echo "\$this non è definito.\n";
        }
    }
}

class B
{
    function bar()
    {
        A::foo();
    }
}

$a = new A();
$a->foo();

A::foo();

$b = new B();
$b->bar();

B::bar();
?>

Output of the above example in PHP 7:

$this è definito (A)

Deprecated: Non-static method A::foo() should not be called statically in %s  on line 27
$this non è definito.

Deprecated: Non-static method A::foo() should not be called statically in %s  on line 20
$this non è definito.

Deprecated: Non-static method B::bar() should not be called statically in %s  on line 32

Deprecated: Non-static method A::foo() should not be called statically in %s  on line 20
$this non è definito.

Output of the above example in PHP 8:

$this è definito (A)

Fatal error: Uncaught Error: Non-static method A::foo() cannot be called statically in %s :27
Stack trace:
#0 {main}
  thrown in %s  on line 27

Classi readonly

A partire da PHP 8.2.0, una classe può essere marcata con il modificatore readonly. Marcando una classe come readonly si aggiungerà il modificatore readonly ad ogni proprietà dichiarata, e preverrà la creazione di proprietà dinamiche. Inoltre, è impossibile aggiungere il loro supporto utilizzando l'attributo AllowDynamicProperties. Provando ad utilizzarlo si innescherà un errore in fase di compilazione.

<?php
#[\AllowDynamicProperties]
readonly class Foo {
}

// Fatal error: Cannot apply #[AllowDynamicProperties] to readonly class Foo
?>

Poiché né le proprietà non tipizzate né quelle statiche possono essere contrassegnate con il modificatore readonly, le classi readonly non possono dichiarare nemmeno loro:

<?php
readonly class Foo
{
    public $bar;
}

// Fatal error: Readonly property Foo::$bar must have type
?>

<?php
readonly class Foo
{
    public static int $bar;
}

// Fatal error: Readonly class Foo cannot declare static properties
?>

Una classe readonly può essere estesa se, e solo se, la classe figlia è anche una classe readonly.

new

Per creare un'istanza di una classe, deve essere usata la parola chiave new. Un oggetto sarà sempre creato a meno che la classe abbia un costruttore definito il quale sollevi un' eccezione in caso di errore. Le classi dovrebbero essere definite prima dell'istanziazione (in alcuni casi questo è un requisito).

Se viene usata una stringa contenente il nome di una classe con new, verrà creata una nuova istanza di quella classe. Se la classe appartiene ad un namespace, deve essere utilizzato il suo nome completamente qualificato.

Nota:
Se non ci sono argomenti da passare al costruttore della classe, le parentesi dopo il nome della classe possono essere omesse.

Example #3 Creazione di un'istanza

<?php
$instance = new SimpleClass();

// è anche possibile istanziare una classe il cui nome sia contenuto in una variabile:
$className = 'SimpleClass';
$instance = new $className(); // new SimpleClass()
?>

Da PHP 8.0.0, l'utilizzo di new con espressioni arbitrarie è supportato. Ciò consente istanziazioni più complesse se l'espressione produce una stringa. Le espressioni devono essere racchiuse tra parentesi.

Example #4 Creazione di un'istanza utilizzando un'espressione arbitraria

Nell'esempio fornito mostriamo più esempi di espressioni arbitrarie valide che producono un nome di classe. Questo mostra una chiamata a una funzione, la concatenazione di stringhe e la costante ::class.

<?php

class ClassA extends \stdClass {}
class ClassB extends \stdClass {}
class ClassC extends ClassB {}
class ClassD extends ClassA {}

function getSomeClass(): string
{
    return 'ClassA';
}

var_dump(new (getSomeClass()));
var_dump(new ('Class' . 'B'));
var_dump(new ('Class' . 'C'));
var_dump(new (ClassD::class));
?>

Output of the above example in PHP 8:

object(ClassA)#1 (0) {
}
object(ClassB)#1 (0) {
}
object(ClassC)#1 (0) {
}
object(ClassD)#1 (0) {
}

Nel contesto di una classe, è possibile creare un nuovo oggetto con le espressioni new self e new parent.

Quando si assegna un'istanza già creata ad una nuova variabile, la nuova variabile farà riferimento alla stessa istanza cui fa riferimento la variabile originale. Questo stesso comportamento si ha quando vengono passate istanze ad una funzione. Si può ottenere una copia di un oggetto già creato per mezzo della clonazione.

Example #5 Assegnazione di oggetti

<?php

$instance = new SimpleClass();

$assigned   =  $instance;
$reference  =& $instance;

$istance->var = '$assigned avrà questo valore';

$instance = null; // $instance e $reference diventano null

var_dump($instance);
var_dump($reference);
var_dump($assigned);
?>

Il precedente esempio visualizzerà:

NULL
NULL
object(SimpleClass)#1 (1) {
   ["var"]=>
     string(30) "$assigned avrà questo valore"
}

È possibile creare istanze di un oggetto in due modi:

Example #6 Creazione di nuovi oggetti

<?php
class Test
{
    static public function getNew()
    {
        return new static;
    }
}

class Child extends Test
{}

$obj1 = new Test();
$obj2 = new $obj1;
var_dump($obj1 !== $obj2);

$obj3 = Test::getNew();
var_dump($obj3 instanceof Test);

$obj4 = Child::getNew();
var_dump($obj4 instanceof Child);
?>

Il precedente esempio visualizzerà:

bool(true)
bool(true)
bool(true)

È possibile accedere ad un membro di un oggetto appena creato in una singola espressione:

Example #7 Accesso al membro dell'oggetto appena creato

<?php
echo (new DateTime())->format('Y');
?>

Il precedente esempio visualizzerà qualcosa simile a:

Nota: Prima di PHP 7.1, gli argomenti non vengono valutati se non esiste una funzione costruttore definita.

Proprietà e metodi

Le proprietà e i metodi della classe vivono in "namespace" separati, quindi è possibile avere una proprietà ed un metodo con lo stesso nome. Dato che sia una proprietà che un metodo hanno la stessa notazione, e la scelta se verrà letta la proprietà o se verrà chiamato il metodo, dipende solo dal contesto, per esempio se l'uso è un accesso ad una variabile o una chiamata ad una funzione.

Example #8 Accesso alla proprietà vs. chiamata del metodo

<?php
class Foo
{
    public $bar = 'property';
    
    public function bar() {
        return 'method';
    }
}

$obj = new Foo();
echo $obj->bar, PHP_EOL, $obj->bar(), PHP_EOL;

Il precedente esempio visualizzerà:

property
method

Ciò significa che chiamare una funzione anonima che è stata assegnata ad una proprietà non è direttamente possibile. Per esempio, la proprietà deve essere assegnata prima ad una variabile. È possibile chiamare questo tipo di proprietà direttamente racchiudendola tra parentesi.

Example #9 Chiamare una funzione anonima memorizzata in una proprietà

<?php
class Foo
{
    public $bar;
    
    public function __construct() {
        $this->bar = function() {
            return 42;
        };
    }
}

$obj = new Foo();

echo ($obj->bar)(), PHP_EOL;

Il precedente esempio visualizzerà:

extends

Una classe può ereditare le costanti, i metodi e le proprietà di un'altra classe utilizzando la parola chiave extends nella dichiarazione della classe. Non è possibile estendere più di una classe per volta; ogni classe può ereditare da una sola altra classe.

Le costanti, i metodi e le proprietà ereditate possono essere sovrascritte ridichiarandole nella nuova classe con lo stesso nome definito nella classe padre. Questo non sarà comunque possibile se il metodo o la costante che si intende ridefinire è stato dichiarato nella classe padre come final. Si può accedere alle proprietà statiche e ai metodi ridefiniti riferendosi ad essi con parent::.

Nota: A partire da PHP 8.1.0, le costanti possono essere dichiarate come final.

Example #10 Ereditarietà semplice

<?php
class ExtendClass extends SimpleClass
{
    // Ridefinisce il metodo presente in ClasseSemplice
    function displayVar()
    {
        echo "Classe figlia\n";
        parent::displayVar();
    }
}

$extended = new ExtendClass();
$extended->displayVar();
?>

Il precedente esempio visualizzerà:

Classe figlia
un valore di default

Regole di compatibilità della firma

Quando si sovrascrive un metodo, la sua firma deve essere compatibile con il metodo padre. Altrimenti, viene emesso un errore fatale o, prima di PHP 8.0.0, viene generato un errore di livello E_WARNING. Una firma è compatibile se rispetta le regole di varianza, rende facoltativo un parametro obbligatorio e se i nuovi parametri sono opzionali. Questo è noto come Principio di Sostituzione di Liskov, o LSP in breve. I metodi costruttore e privati sono esenti da queste regole di compatibilità della firma e quindi non genereranno un errore fatale nel caso di una mancata corrispondenza della firma.

Example #11 Metodi figli compatibili

<?php

class Base
{
    public function foo(int $a) {
        echo "Valido\n";
    }
}

class Extend1 extends Base
{
    function foo(int $a = 5)
    {
        parent::foo($a);
    }
}

class Extend2 extends Base
{
    function foo(int $a, $b = 5)
    {
        parent::foo($a);
    }
}

$extended1 = new Extend1();
$extended1->foo();
$extended2 = new Extend2();
$extended2->foo(1);

Il precedente esempio visualizzerà:

Valido
Valido

I seguenti esempi dimostrano che un metodo figlio che rimuove un parametro o rende obbligatorio un parametro facoltativo non è compatibile con il metodo padre.

Example #12 Errore fatale quando un metodo figlio rimuove un parametro

<?php

class Base
{
    public function foo(int $a = 5) {
        echo "Valido\n";
    }
}

class Extend extends Base
{
    function foo()
    {
        parent::foo(1);
    }
}

Output of the above example in PHP 8 is similar to:

Fatal error: Declaration of Extend::foo() must be compatible with Base::foo(int $a = 5) in /in/evtlq on line 13

Example #13 Errore fatale quando un metodo figlio rende obbligatorio un parametro facoltativo

<?php

class Base
{
    public function foo(int $a = 5) {
        echo "Valido\n";
    }
}

class Extend extends Base
{
    function foo(int $a)
    {
        parent::foo($a);
    }
}

Output of the above example in PHP 8 is similar to:

Fatal error: Declaration of Extend::foo(int $a) must be compatible with Base::foo(int $a = 5) in /in/qJXVC on line 13

Avviso

Rinominare il parametro di un metodo in una classe figlia non è un'incompatibilità di firma. Tuttavia, questo è sconsigliato poiché risulterà in un Errore di runtime se vengono utilizzati gli argomenti con nome.

Example #14 Errore durante l'utilizzo di argomenti e parametri con nome rinominati in una classe figlia

<?php

class A {
    public function test($foo, $bar) {}
}

class B extends A {
    public function test($a, $b) {}
}

$obj = new B;

// Passa i parametri in base al contratto A::test()
$obj->test(foo: "foo", bar: "bar"); // ERRORE!

Il precedente esempio visualizzerà qualcosa simile a:

Fatal error: Uncaught Error: Unknown named parameter $foo in /in/XaaeN:14
Stack trace:
#0 {main}
  thrown in /in/XaaeN on line 14

::class

La parola chiave class è anche usata per la risoluzione del nome della classe. Per ottenere il nome completo di una classe ClassName utilizzare ClassName::class. Questo è particolarmente utile con le classi presenti nei namespace.

Example #15 Risoluzione del nome della classe

<?php
namespace NS {
    class ClassName {
    }
    
    echo ClassName::class;
}
?>

Il precedente esempio visualizzerà:

NS\ClassName

Nota:
La risoluzione del nome della classe utilizzando ::class è una trasformazione in fase di compilazione. Ciò significa che al momento della creazione della stringa del nome della classe non è ancora stato eseguito il caricamento automatico. Di conseguenza, i nomi delle classi vengono espansi anche se la classe non esiste. In questo caso non viene emesso alcun errore.
Example #16 Risoluzione del nome della classe mancante

<?php print Does\Not\Exist::class; ?>

Il precedente esempio visualizzerà:
Does\Not\Exist

A partire da PHP 8.0.0, la costante ::class può essere utilizzata anche sugli oggetti. Questa risoluzione avviene in fase di esecuzione, non in fase di compilazione. Il suo effetto è lo stesso della chiamata di get_class() sull'oggetto.

Example #17 Risoluzione del nome dell'oggetto

<?php
namespace NS {
    class ClassName {
    }
}
$c = new ClassName();
print $c::class;
?>

Il precedente esempio visualizzerà:

NS\ClassName

Metodi e proprietà nullsafe

A partire da PHP 8.0.0, è possibile accedere alle proprietà e ai metodi anche con l'operatore "nullsafe": ?->. L'operatore nullsafe funziona allo stesso modo dell'accesso alla proprietà o al metodo come sopra, tranne per il fatto che se l' oggetto da dereferenziare è null allora null verrà restituito piuttosto che un'eccezione generata. Se la dereferenziazione fa parte di una catena, il resto della catena viene saltato.

L'effetto è simile ad effettuare prima il wrap su ogni accesso in un controllo is_null(), ma più compatto.

Example #18 L'Operatore Nullsafe

<?php

// A partire da PHP 8.0.0, questa riga:
$result = $repository?->getUser(5)?->name;

// È equivalente al seguente blocco di codice:
if (is_null($repository)) {
    $result = null;
} else {
    $user = $repository->getUser(5);
    if (is_null($user)) {
        $result = null;
    } else {
        $result = $user->name;
    }
}
?>

Nota:
L'operatore nullsafe viene utilizzato al meglio quando null è considerato un valore possibile valido e previsto per una proprietà o return di un metodo. Per indicare un errore, è preferibile un'eccezione generata.

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 11 notes

down

641

aaron at thatone dot com ¶

16 years ago

I was confused at first about object assignment, because it's not quite the same as normal assignment or assignment by reference. But I think I've figured out what's going on.

First, think of variables in PHP as data slots. Each one is a name that points to a data slot that can hold a value that is one of the basic data types: a number, a string, a boolean, etc. When you create a reference, you are making a second name that points at the same data slot. When you assign one variable to another, you are copying the contents of one data slot to another data slot.

Now, the trick is that object instances are not like the basic data types. They cannot be held in the data slots directly. Instead, an object's "handle" goes in the data slot. This is an identifier that points at one particular instance of an obect. So, the object handle, although not directly visible to the programmer, is one of the basic datatypes. 

What makes this tricky is that when you take a variable which holds an object handle, and you assign it to another variable, that other variable gets a copy of the same object handle. This means that both variables can change the state of the same object instance. But they are not references, so if one of the variables is assigned a new value, it does not affect the other variable.

<?php
// Assignment of an object
Class Object{
   public $foo="bar";
};

$objectVar = new Object();
$reference =& $objectVar;
$assignment = $objectVar

//
// $objectVar --->+---------+
//                |(handle1)----+
// $reference --->+---------+   |
//                              |
//                +---------+   |
// $assignment -->|(handle1)----+
//                +---------+   |
//                              |
//                              v
//                  Object(1):foo="bar"
//
?>

$assignment has a different data slot from $objectVar, but its data slot holds a handle to the same object. This makes it behave in some ways like a reference. If you use the variable $objectVar to change the state of the Object instance, those changes also show up under $assignment, because it is pointing at that same Object instance.

<?php
$objectVar->foo = "qux";
print_r( $objectVar );
print_r( $reference );
print_r( $assignment );

//
// $objectVar --->+---------+
//                |(handle1)----+
// $reference --->+---------+   |
//                              |
//                +---------+   |
// $assignment -->|(handle1)----+
//                +---------+   |
//                              |
//                              v
//                  Object(1):foo="qux"
//
?>

But it is not exactly the same as a reference. If you null out $objectVar, you replace the handle in its data slot with NULL. This means that $reference, which points at the same data slot, will also be NULL. But $assignment, which is a different data slot, will still hold its copy of the handle to the Object instance, so it will not be NULL.

<?php
$objectVar = null;
print_r($objectVar);
print_r($reference);
print_r($assignment);

//
// $objectVar --->+---------+
//                |  NULL   | 
// $reference --->+---------+
//                           
//                +---------+
// $assignment -->|(handle1)----+
//                +---------+   |
//                              |
//                              v
//                  Object(1):foo="qux"
?>

down

kStarbe at gmail point com ¶

7 years ago

You start using :: in second example although the static concept has not been explained. This is not easy to discover when you are starting from the basics.

down

129

Doug ¶

14 years ago

What is the difference between  $this  and  self ?

Inside a class definition, $this refers to the current object, while  self  refers to the current class.

It is necessary to refer to a class element using  self ,
and refer to an object element using  $this .
Note also how an object variable must be preceded by a keyword in its definition.

The following example illustrates a few cases:

<?php
class Classy {

const       STAT = 'S' ; // no dollar sign for constants (they are always static)
static     $stat = 'Static' ;
public     $publ = 'Public' ;
private    $priv = 'Private' ;
protected  $prot = 'Protected' ;

function __construct( ){  }

public function showMe( ){
    print '<br> self::STAT: '  .  self::STAT ; // refer to a (static) constant like this
    print '<br> self::$stat: ' . self::$stat ; // static variable
    print '<br>$this->stat: '  . $this->stat ; // legal, but not what you might think: empty result
    print '<br>$this->publ: '  . $this->publ ; // refer to an object variable like this
    print '<br>' ;
}
}
$me = new Classy( ) ;
$me->showMe( ) ;

/* Produces this output:
self::STAT: S
self::$stat: Static
$this->stat:
$this->publ: Public
*/
?>

down

Hayley Watson ¶

6 years ago

Class names are case-insensitive:
<?php
class Foo{}
class foo{} //Fatal error.
?>

Any casing can be used to refer to the class
<?php
class bAr{}
$t = new Bar();
$u = new bar();
echo ($t instanceof $u) ? "true" : "false"; // "true"
echo ($t instanceof BAR) ? "true" : "false"; // "true"
echo is_a($u, 'baR') ? "true" : "false"; // "true"
?>

But the case used when the class was defined is preserved as "canonical":
<?php
echo get_class($t); // "bAr"
?>

And, as always, "case-insensitivity" only applies to ASCII.
<?php
class пасха{}
class Пасха{} // valid
$p = new ПАСХА(); // Uncaught warning.
?>

down

wbcarts at juno dot com ¶

16 years ago

CLASSES and OBJECTS that represent the "Ideal World"

Wouldn't it be great to get the lawn mowed by saying $son->mowLawn()? Assuming the function mowLawn() is defined, and you have a son that doesn't throw errors, the lawn will be mowed. 

In the following example; let objects of type Line3D measure their own length in 3-dimensional space. Why should I or PHP have to provide another method from outside this class to calculate length, when the class itself holds all the neccessary data and has the education to make the calculation for itself?

<?php

/*
 * Point3D.php
 *
 * Represents one locaton or position in 3-dimensional space
 * using an (x, y, z) coordinate system.
 */
class Point3D
{
    public $x;
    public $y;
    public $z;                  // the x coordinate of this Point.

    /*
     * use the x and y variables inherited from Point.php.
     */
    public function __construct($xCoord=0, $yCoord=0, $zCoord=0)
    {
        $this->x = $xCoord;
    $this->y = $yCoord;
        $this->z = $zCoord;
    }

    /*
     * the (String) representation of this Point as "Point3D(x, y, z)".
     */
    public function __toString()
    {
        return 'Point3D(x=' . $this->x . ', y=' . $this->y . ', z=' . $this->z . ')';
    }
}

/*
 * Line3D.php
 *
 * Represents one Line in 3-dimensional space using two Point3D objects.
 */
class Line3D
{
    $start;
    $end;

    public function __construct($xCoord1=0, $yCoord1=0, $zCoord1=0, $xCoord2=1, $yCoord2=1, $zCoord2=1)
    {
        $this->start = new Point3D($xCoord1, $yCoord1, $zCoord1);
        $this->end = new Point3D($xCoord2, $yCoord2, $zCoord2);
    }

    /*
     * calculate the length of this Line in 3-dimensional space.
     */ 
    public function getLength()
    {
        return sqrt(
            pow($this->start->x - $this->end->x, 2) +
            pow($this->start->y - $this->end->y, 2) +
            pow($this->start->z - $this->end->z, 2)
        );
    }

    /*
     * The (String) representation of this Line as "Line3D[start, end, length]".
     */
    public function __toString()
    {
        return 'Line3D[start=' . $this->start .
            ', end=' . $this->end .
            ', length=' . $this->getLength() . ']';
    }
}

/*
 * create and display objects of type Line3D.
 */
echo '<p>' . (new Line3D()) . "</p>\n";
echo '<p>' . (new Line3D(0, 0, 0, 100, 100, 0)) . "</p>\n";
echo '<p>' . (new Line3D(0, 0, 0, 100, 100, 100)) . "</p>\n";

?>

  <--  The results look like this  -->

Line3D[start=Point3D(x=0, y=0, z=0), end=Point3D(x=1, y=1, z=1), length=1.73205080757]

Line3D[start=Point3D(x=0, y=0, z=0), end=Point3D(x=100, y=100, z=0), length=141.421356237]

Line3D[start=Point3D(x=0, y=0, z=0), end=Point3D(x=100, y=100, z=100), length=173.205080757]

My absolute favorite thing about OOP is that "good" objects keep themselves in check. I mean really, it's the exact same thing in reality... like, if you hire a plumber to fix your kitchen sink, wouldn't you expect him to figure out the best plan of attack? Wouldn't he dislike the fact that you want to control the whole job? Wouldn't you expect him to not give you additional problems? And for god's sake, it is too much to ask that he cleans up before he leaves?

I say, design your classes well, so they can do their jobs uninterrupted... who like bad news? And, if your classes and objects are well defined, educated, and have all the necessary data to work on (like the examples above do), you won't have to micro-manage the whole program from outside of the class. In other words... create an object, and LET IT RIP!

down

moty66 at gmail dot com ¶

15 years ago

I hope that this will help to understand how to work with static variables inside a class

<?php

class a {

    public static $foo = 'I am foo';
    public $bar = 'I am bar';
    
    public static function getFoo() { echo self::$foo;    }
    public static function setFoo() { self::$foo = 'I am a new foo'; }
    public function getBar() { echo $this->bar;    }            
}

$ob = new a();
a::getFoo();     // output: I am foo    
$ob->getFoo();    // output: I am foo
//a::getBar();     // fatal error: using $this not in object context
$ob->getBar();    // output: I am bar
                // If you keep $bar non static this will work
                // but if bar was static, then var_dump($this->bar) will output null 

// unset($ob);
a::setFoo();    // The same effect as if you called $ob->setFoo(); because $foo is static
$ob = new a();     // This will have no effects on $foo
$ob->getFoo();    // output: I am a new foo 

?>

Regards
Motaz Abuthiab

down

pawel dot zimnowodzki at gmail dot com ¶

2 years ago

Although there is no null-safe operator for not existed array keys I found workaround for it: ($array['not_existed_key'] ?? null)?->methodName()

down

Notes on stdClass ¶

15 years ago

stdClass is the default PHP object. stdClass has no properties, methods or parent. It does not support magic methods, and implements no interfaces.

When you cast a scalar or array as Object, you get an instance of stdClass. You can use stdClass whenever you need a generic object instance.
<?php
// ways of creating stdClass instances
$x = new stdClass;
$y = (object) null;        // same as above
$z = (object) 'a';         // creates property 'scalar' = 'a'
$a = (object) array('property1' => 1, 'property2' => 'b');
?>

stdClass is NOT a base class! PHP classes do not automatically inherit from any class. All classes are standalone, unless they explicitly extend another class. PHP differs from many object-oriented languages in this respect.
<?php
// CTest does not derive from stdClass
class CTest {
    public $property1;
}
$t = new CTest;
var_dump($t instanceof stdClass);            // false
var_dump(is_subclass_of($t, 'stdClass'));    // false
echo get_class($t) . "\n";                   // 'CTest'
echo get_parent_class($t) . "\n";            // false (no parent)
?>

You cannot define a class named 'stdClass' in your code. That name is already used by the system. You can define a class named 'Object'.

You could define a class that extends stdClass, but you would get no benefit, as stdClass does nothing.

(tested on PHP 5.2.8)

down

johannes dot kingma at gmail dot com ¶

3 years ago

BEWARE! 

Like Hayley Watson pointed out class names are not case sensitive. 

<?php
class Foo{}
class foo{} // Fatal error: Cannot declare class foo, because the name is already in use
?>
As well as
<?php
class BAR{}
$bar = new Bar();
echo get_class($bar);
?> 

Is perfectly fine and will return 'BAR'.

This has implications on autoloading classes though. The standard spl_autoload function will strtolower the class name to cope with case in-sensitiveness and thus the class BAR can only be found if the file name is bar.php (or another variety if an extension was registered with spl_autoload_extensions(); ) not BAR.php for a case sensitive file and operating system like linux. Windows file system is case sensitive but the OS is not  and there for autoloading BAR.php will work.

down

Jeffrey ¶

16 years ago

A PHP Class can be used for several things, but at the most basic level, you'll use classes to "organize and deal with like-minded data". Here's what I mean by "organizing like-minded data". First, start with unorganized data.

<?php
$customer_name;
$item_name;
$item_price;
$customer_address;
$item_qty;
$item_total;
?>

Now to organize the data into PHP classes:

<?php
class Customer {
  $name;          // same as $customer_name
  $address;       // same as $customer_address
}

class Item {
  $name;          // same as $item_name
  $price;         // same as $item_price
  $qty;           // same as $item_qty
  $total;         // same as $item_total
}
?>

Now here's what I mean by "dealing" with the data. Note: The data is already organized, so that in itself makes writing new functions extremely easy.

<?php
class Customer {
  public $name, $address;                   // the data for this class...

  // function to deal with user-input / validation
  // function to build string for output
  // function to write -> database
  // function to  read <- database
  // etc, etc
}

class Item {
  public $name, $price, $qty, $total;        // the data for this class...

  // function to calculate total
  // function to format numbers
  // function to deal with user-input / validation
  // function to build string for output
  // function to write -> database
  // function to  read <- database
  // etc, etc
}
?>

Imagination that each function you write only calls the bits of data in that class. Some functions may access all the data, while other functions may only access one piece of data. If each function revolves around the data inside, then you have created a good class.

down

Anonymous ¶

6 years ago

At first I was also confused by the assignment vs referencing but here's how I was finally able to get my head around it. This is another example which is somewhat similar to one of the comments but can be helpful to those who did not understand the first example. Imagine object instances as rooms where you can store and manipulate your properties and functions.  The variable that contains the object simply holds 'a key' to this room and thus access to the object. When you assign this variable to another new variable, what you are doing is you're making a copy of the key and giving it to this new variable. That means these two variable now have access to the same 'room' (object) and can thus get in and manipulate the values. However, when you create a reference, what you doing is you're making the variables SHARE the same key. They both have access to the room. If one of the variable is given a new key, then the key that they are sharing is replaced and they now share a new different key. This does not affect the other variable with a copy of the old key...that variable still has access to the first room

＋add a note