public

La parola chiave public in PHP

public è uno dei tre modificatori di visibilità (accesso) di PHP, insieme a private e protected. Un membro di classe dichiarato public può essere letto e scritto — oppure, nel caso dei metodi, chiamato — da qualsiasi punto: all'interno della classe, da una sottoclasse e da qualsiasi codice che possiede un'istanza della classe.

Questa pagina tratta la sintassi, dove si applica public, le differenze rispetto agli altri modificatori, le regole di visibilità predefinita e le insidie pratiche dell'esporre membri pubblicamente. Se le classi sono una novità per te, inizia da Classi e Oggetti PHP.

Sintassi

Inserisci la parola chiave public prima della dichiarazione di una proprietà, metodo o costante:

class MyClass {
  public $myPublicProperty;          // public property
  public const VERSION = '1.0';      // public constant (PHP 7.1+)

  public function myPublicMethod() {
    // accessible from anywhere
  }
}

public può modificare:

• Proprietà — public $name;
• Metodi — public function greet() { ... }
• Costanti — public const MAX = 10; (PHP 7.1+; le costanti sono implicitamente public se non viene specificato alcun modificatore)
• Parametri promossi nel costruttore — public function __construct(public string $name) {} (PHP 8.0+)

Visibilità predefinita

La visibilità è facoltativa in PHP. Il valore predefinito dipende dal tipo di membro:

• Un metodo senza modificatore è implicitamente public. function honk() e public function honk() hanno lo stesso significato.
• Una proprietà deve usare uno dei modificatori (public, protected o private) oppure var. Storicamente var $x; era un alias per public $x; ed è ancora accettato ma sconsigliato.
• Una costante di classe senza modificatore è implicitamente public.

Scrivere public in modo esplicito è lo stile raccomandato — rende l'intenzione evidente a chiunque legga il codice.

Esempi

Vediamo alcuni esempi pratici di come si può usare la parola chiave "public":

Esempi della parola chiave public in PHP

<?php

// Example 1
class Car
{
  public $model;
  public $color;

  public function __construct($model, $color)
  {
    $this->model = $model . PHP_EOL;
    $this->color = $color;
  }

  public function honk()
  {
    return "Beep beep!" . PHP_EOL;
  }
}

$myCar = new Car("Tesla", "red");
echo $myCar->model; // Output: Tesla
echo $myCar->honk(); // Output: Beep beep!

// Example 2
class Math
{
  public static function add($a, $b)
  {
    return $a + $b;
  }

  public static function multiply($a, $b)
  {
    return $a * $b;
  }
}

echo Math::add(5, 10); // Output: 15
echo Math::multiply(5, 10); // Output: 50

Qui $model, honk() e i metodi statici di Math sono tutti public, quindi il codice chiamante vi accede direttamente tramite -> (istanze) o :: (membri statici).

Promozione del costruttore (PHP 8.0+)

Da PHP 8.0 è possibile dichiarare e inizializzare una proprietà pubblica direttamente da un parametro del costruttore, eliminando il codice ripetitivo $this->x = $x;:

<?php

class Point
{
  public function __construct(
    public int $x = 0,
    public int $y = 0
  ) {}
}

$p = new Point(3, 4);
echo "$p->x,$p->y" . PHP_EOL; // Output: 3,4

Questo equivale a dichiarare public int $x; e assegnarlo nel corpo del costruttore. Consulta PHP Constructor per un quadro completo.

public vs. protected vs. private

PHP dispone di tre modificatori di visibilità. La differenza sta in dove è possibile accedere a un membro:

Il seguente script mostra i limiti in azione:

<?php

class Base
{
  public $open = 'public';
  protected $family = 'protected';
  private $secret = 'private';

  public function reveal()
  {
    // Inside the class, all three are reachable.
    return "$this->open / $this->family / $this->secret" . PHP_EOL;
  }
}

$b = new Base();

echo $b->open . PHP_EOL;  // Output: public  (allowed from outside)
echo $b->reveal();        // Output: public / protected / private

// echo $b->family;       // Fatal error: Cannot access protected property
// echo $b->secret;       // Fatal error: Cannot access private property

Solo $open è raggiungibile direttamente dall'esterno della classe. $family e $secret possono essere letti solo attraverso il metodo pubblico reveal().

Quando usare public

Usa public per le parti di una classe che costituiscono la sua API — i metodi e i dati su cui vuoi che altro codice faccia affidamento. Tieni tutto il resto private o protected.

• Esponi il comportamento, non lo stato grezzo. Preferisci metodi public (getEmail(), withdraw($amount)) alle proprietà public, così mantieni il controllo sulla validazione e puoi modificare gli interni in seguito senza rompere i chiamanti.
• Una proprietà public è un contratto: una volta che codice esterno dipende da essa, rinominarla o rimuoverla è una modifica che rompe la compatibilità.
• Usa public static per metodi di utilità/factory che non richiedono un'istanza (vedi PHP Static Methods).
• I metodi di un'interfaccia sono sempre effettivamente public — vedi PHP Interfaces.

Riepilogo

• public rende un membro di classe accessibile da qualsiasi punto; è il più permissivo dei tre modificatori di visibilità di PHP.
• Metodi e costanti sono public per impostazione predefinita; le proprietà devono dichiarare esplicitamente la propria visibilità.
• Riserva public all'API prevista di una classe e nascondi i dettagli implementativi dietro private/protected per una migliore incapsulazione.

Continua con private, protected e PHP Inheritance per completare la comprensione della visibilità.

Pratica