PART 2.A.

PHP Vanilla - 10 Domande con Risposte

1. Qual è il concetto di ereditarietà in PHP?

Risposta:
L'ereditarietà permette a una classe figlia di ereditare proprietà e metodi da una classe padre, riutilizzando codice e facilitando la modularità.

Esempio:

class ParentClass {
    protected $name = "Base Class";

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

class ChildClass extends ParentClass {
    public function show() {
        return "This is: " . $this->getName();
    }
}

$obj = new ChildClass();
echo $obj->show();  // Output: This is: Base Class

---

2. Cosa sono le references (&) in PHP e come funzionano?

Risposta:
Le references permettono di creare alias per una variabile. Quando si usa &, entrambe le variabili puntano allo stesso spazio di memoria.

Esempio:

$a = 10;
$b = &$a;  // $b è un riferimento a $a

$b = 20;  
echo $a; // Output: 20, perché $a e $b puntano alla stessa memoria

---

3. Qual è la differenza tra clone e = in PHP?

Risposta:
L'assegnazione = copia il riferimento all'oggetto, mentre clone crea una copia indipendente.

Esempio:

class Test {
    public $value;
}

$obj1 = new Test();
$obj1->value = 10;

$obj2 = $obj1;   // $obj2 e $obj1 puntano allo stesso oggetto
$obj3 = clone $obj1; // $obj3 è una copia indipendente

$obj2->value = 20;
echo $obj1->value; // Output: 20
echo $obj3->value; // Output: 10 (rimane indipendente)

---

4. Cosa fa il Garbage Collector in PHP?

Risposta:
Il Garbage Collector (GC) rimuove dalla memoria gli oggetti non più referenziati, evitando memory leaks.

Esempio:

class Demo {
    public function __destruct() {
        echo "Oggetto distrutto";
    }
}

$obj = new Demo();
unset($obj);  // Output: Oggetto distrutto

---

5. Cosa succede se si assegna una reference a una variabile in una funzione?

Risposta:
Se si passa una variabile per riferimento (&), la modifica avrà effetto sulla variabile originale.

Esempio:

function addTen(&$num) {
    $num += 10;
}

$value = 5;
addTen($value);
echo $value; // Output: 15

---

6. Qual è la differenza tra self:: e parent:: in PHP?

Risposta:

• self:: si riferisce alla classe in cui viene chiamato.

• parent:: richiama il metodo della classe genitore.

Esempio:

class A {
    public static function who() {
        echo "A\n";
    }

    public static function test() {
        self::who();
    }
}

class B extends A {
    public static function who() {
        echo "B\n";
    }
}

B::test();  // Output: A

Se si volesse eseguire il metodo della classe figlia, si dovrebbe usare static::who().

---

7. Qual è la differenza tra unset() e null su una variabile?

Risposta:

• unset($var): distrugge la variabile dalla memoria.

• $var = null: assegna il valore null ma la variabile esiste ancora.

Esempio:

$var = "Hello";
unset($var);  
// echo $var;  // Errore: variabile non definita

$var = "Hello";
$var = null;
echo $var;  // Nessun output, ma la variabile esiste ancora

---

8. Cosa sono le Late Static Binding in PHP?

Risposta:
Il Late Static Binding permette di riferirsi alla classe chiamante invece che a quella dichiarata inizialmente, usando static:: invece di self::.

Esempio:

class A {
    public static function who() {
        echo "A\n";
    }

    public static function test() {
        static::who();  // Late Static Binding
    }
}

class B extends A {
    public static function who() {
        echo "B\n";
    }
}

B::test();  // Output: B (anziché A)

---

9. Qual è la differenza tra require e include in PHP?

Risposta:

• require: interrompe l'esecuzione in caso di errore.

• include: genera solo un warning, ma lo script continua.

Esempio:

// include "file_non_esistente.php";  // Warning, ma il codice continua
// require "file_non_esistente.php";  // Fatal error, esecuzione interrotta

---

10. Cosa fa il metodo __call() in PHP?

Risposta:
Il metodo __call() intercetta chiamate a metodi non esistenti in un oggetto.

Esempio:

class Magic {
    public function __call($name, $arguments) {
        echo "Il metodo $name non esiste!";
    }
}

$obj = new Magic();
$obj->nonEsistente();  // Output: Il metodo nonEsistente non esiste!

---

In PHP, le classi e i loro membri (proprietà e metodi) possono avere diversi modificatori di accesso e tipologie. Ecco un elenco delle principali tipologie di classi e modificatori di accesso:

---

PART 2.B.

1. Modificatori di Accesso (Visibility)

Si applicano a proprietà e metodi all'interno di una classe:

• public → accessibile ovunque.

• protected → accessibile solo dalla classe e dalle sue sottoclassi.

• private → accessibile solo all'interno della classe stessa.

Esempio:

class Example {
    public $publicVar = "Public";      // Accessibile ovunque
    protected $protectedVar = "Protected";  // Accessibile solo dalla classe o sottoclassi
    private $privateVar = "Private";  // Accessibile solo nella classe

    public function showVars() {
        echo $this->publicVar . "\n"; 
        echo $this->protectedVar . "\n";
        echo $this->privateVar . "\n";
    }
}

$obj = new Example();
echo $obj->publicVar;  // OK
// echo $obj->protectedVar;  // Errore
// echo $obj->privateVar;  // Errore

---

2. Classi Normali

Una classe normale viene definita senza modificatori particolari.

class NormalClass {
    public function greet() {
        return "Hello!";
    }
}

---

3. Classi Astratte (abstract)

• Non possono essere istanziate direttamente.

• Possono avere metodi astratti (abstract function), che devono essere implementati nelle sottoclassi.

Esempio:

abstract class Animal {
    abstract public function makeSound(); // Deve essere definito nelle sottoclassi
}

class Dog extends Animal {
    public function makeSound() {
        return "Bark!";
    }
}

$dog = new Dog();
echo $dog->makeSound();  // Output: Bark!

---

4. Classi Finali (final)

• Non possono essere estese.

• I metodi final non possono essere sovrascritti.

Esempio:

final class Unextendable {
    public function sayHello() {
        return "Hello!";
    }
}

// class Test extends Unextendable {}  // Errore: non si può estendere una classe final

---

5. Classi Statiche

• Contengono solo metodi e proprietà static.

  Guarda a tal proposito 5.a e 5.b

• Non possono essere istanziate.

Esempio:

phpCopyEditclass MathUtils {
    public static function square($num) {
        return $num * $num;
    }
}

echo MathUtils::square(5);  // Output: 25

---

5.a Metodi e Proprietà Statiche (static)

• Metodi e proprietà statiche appartengono alla classe, non alle istanze.

• Si accedono con ClassName::method() invece di $object->method().

• Non usano $this, ma self:: o static::.

Esempio:

class Math {
    public static $pi = 3.14;
    public static function square($num) {
        return $num * $num;
    }
}

echo Math::$pi;  // Output: 3.14
echo Math::square(4);  // Output: 16

---

5.b Alternative a static

1. Metodi normali (istanza)

   • Richiedono un'istanza ($this).

   • Non si accedono con :: ( il cosidetto Scope Resolution Operator/Paamayim Nekudotayim/doppio due punto).

Esempio:

    class Normal {
        public function greet() {
            return "Hello";
        }
    }
    $obj = new Normal();
    echo $obj->greet();  // OK

2. Costanti di Classe (const)

   • Come le proprietà static, ma immutabili.

Esempio:

    class Config {
        const VERSION = "1.0";
    }
    echo Config::VERSION;  // Output: 1.0

3. Variabili globali

   • Dichiarate fuori dalla classe.

   • Usate con global.

Esempio:

    $globalVar = "Hello";
    function showVar() {
        global $globalVar;
        echo $globalVar;
    }
    showVar();  // Output: Hello

4. Singleton (Pattern)

   • Alternativa avanzata per gestire unica istanza.

Esempio:

    class Singleton {
        private static $instance;
        private function __construct() {}
        public static function getInstance() {
            if (!self::$instance) {
                self::$instance = new self();
            }
            return self::$instance;
        }
    }
    $obj1 = Singleton::getInstance();

5. Closure (Funzione anonima)

   • Alternativa a metodi statici con funzioni anonime.

Esempio:

    $square = function($num) {
        return $num * $num;
    };
    echo $square(4);  // Output: 16

---

6. Classi Anonime

• Classi dichiarate al volo senza nome.

• Utilizzate per oggetti temporanei.

Esempio:

$anonClass = new class {
    public function sayHello() {
        return "Hello from anonymous class!";
    }
};

echo $anonClass->sayHello();

---

7. Interfacce (interface)

• Definiscono solo metodi senza implementazione.

• Le classi che implementano un’interfaccia devono definirne i metodi.

Esempio:

interface Vehicle {
    public function move();
}

class Car implements Vehicle {
    public function move() {
        return "Car is moving";
    }
}

$car = new Car();
echo $car->move();  // Output: Car is moving

---

8. Trait

• Permettono di riutilizzare metodi tra classi senza ereditarietà.

Esempio:

trait Logger {
    public function log($message) {
        echo "Log: $message";
    }
}

class User {
    use Logger;
}

$user = new User();
$user->log("User created.");  // Output: Log: User created.

---

Riassunto

---

PART 2.C.

A. L'operatore -> (freccia) e le sue alternative.

L'operatore -> (freccia) in PHP è usato per accedere alle proprietà e ai metodi di un oggetto.

Funziona solo con gli oggetti, non con gli array o le proprietà statiche.

Example:

class Test {
    public $value;
}

$obj1 = new Test();
$obj1->value = 10;  // Assigns 10 to the property `value`
echo $obj1->value;  // Output: 10

---

B. L'operatore :: in PHP

L'operatore :: in PHP si chiama Scope Resolution Operator (operatore di risoluzione dello scope), noto anche come Paamayim Nekudotayim.

---

B.1. Usi principali di ::

1. Accedere a proprietà e metodi statici

Permette di accedere a proprietà e metodi statici senza creare un'istanza della classe.

class Example {
    public static $var = "Hello";
    public static function greet() {
        return "Hi!";
    }
}

echo Example::$var;       // Output: Hello
echo Example::greet();    // Output: Hi!

---

2. Accedere a costanti di classe

class Config {
    const VERSION = "1.0";
}

echo Config::VERSION; // Output: 1.0

---

3. Usare parent:: per chiamare metodi della classe genitore

class A {
    public static function sayHello() {
        return "Hello from A";
    }
}

class B extends A {
    public static function greet() {
        return parent::sayHello(); // Chiama il metodo della classe padre
    }
}

echo B::greet(); // Output: Hello from A

---

4. Usare self:: e static::

• self:: → Si riferisce sempre alla classe in cui è definito il metodo.

• static:: → Usa Late Static Binding, quindi si riferisce alla classe chiamante.

class Base {
    public static function who() {
        return "Base";
    }
    public static function test() {
        return self::who();  // Sempre "Base"
    }
}

class Derived extends Base {
    public static function who() {
        return "Derived";
    }
}

echo Derived::test(); // Output: Base (perché usa `self::`)

Se invece usiamo static::, si ottiene il comportamento dinamico:

class Base {
    public static function who() {
        return "Base";
    }
    public static function test() {
        return static::who();  // Late Static Binding
    }
}

class Derived extends Base {
    public static function who() {
        return "Derived";
    }
}

echo Derived::test(); // Output: Derived

---

Riassunto

---

B.2. Alternativa a :: per proprietà e metodi statici

Uso standard con ::

class Example {
    public static $var = "Hello";
    public static function greet() {
        return "Hi!";
    }
}

echo Example::$var;       // Output: Hello
echo Example::greet();    // Output: Hi!

Alternativa: Uso di un'istanza (ma non funziona con static)

$instance = new Example();
echo $instance->greet(); // Funziona solo se non è static

🚨 Non valido per proprietà e metodi static, che devono usare ::.

---

2. Alternativa a :: per costanti di classe

Uso standard con ::

class Config {
    const VERSION = "1.0";
}

echo Config::VERSION; // Output: 1.0

Alternativa con define()

Se non hai bisogno di una classe:

define("VERSION", "1.0");
echo VERSION; // Output: 1.0

❌ Limite: define() è globale, mentre const è legata alla classe.

---

3. Alternativa a :: per parent:: (Ereditarietà)

Uso standard con parent::

class A {
    public function sayHello() {
        return "Hello from A";
    }
}

class B extends A {
    public function sayHello() {
        return parent::sayHello() . " and B";
    }
}

$obj = new B();
echo $obj->sayHello(); // Output: Hello from A and B

Alternativa con call_user_func()

class C extends A {
    public function sayHello() {
        return call_user_func([new A(), "sayHello"]) . " and C";
    }
}

$obj = new C();
echo $obj->sayHello(); // Output: Hello from A and C

❌ Limite: Più verboso, ma evita parent::.

---

4. Alternativa a :: per self::

Uso standard con self::

class Example {
    public static function who() {
        return "Example";
    }
    public static function test() {
        return self::who();
    }
}

echo Example::test(); // Output: Example

Alternativa con $this e metodi normali

class Alternative {
    public function who() {
        return "Alternative";
    }
    public function test() {
        return $this->who();
    }
}

$obj = new Alternative();
echo $obj->test(); // Output: Alternative

❌ Limite: $this non funziona nei metodi static.

---

5. Alternativa a :: con static:: (Late Static Binding)

Uso standard con static::

class Base {
    public static function who() {
        return "Base";
    }
    public static function test() {
        return static::who();
    }
}

class Derived extends Base {
    public static function who() {
        return "Derived";
    }
}

echo Derived::test(); // Output: Derived

Alternativa con get_called_class()

class AlternativeBase {
    public static function who() {
        return get_called_class();
    }
    public static function test() {
        return self::who();
    }
}

class AlternativeDerived extends AlternativeBase {}

echo AlternativeDerived::test(); // Output: AlternativeDerived

✅ Vantaggio: Più dinamico rispetto a self::.

---

Riassunto delle Alternative

---

---

PART 2.D.

PHP Vanilla - 10 Nuove Domande con Risposte

---

1. Qual è la differenza tra == e === in PHP?

Risposta:

• == confronta i valori, senza considerare il tipo.

• === confronta sia il valore che il tipo di dato.

Esempio:

$a = 5;
$b = "5";

echo ($a == $b) ? "Uguali\n" : "Diversi\n";  // Output: Uguali
echo ($a === $b) ? "Uguali\n" : "Diversi\n"; // Output: Diversi

---

2. Cosa fa il costruttore (__construct) in PHP?

Risposta:
Il costruttore (__construct) è un metodo speciale che viene eseguito automaticamente quando si crea un'istanza di una classe.

Esempio:

class User {
    public $name;

    public function __construct($name) {
        $this->name = $name;
    }
}

$user = new User("Mario");
echo $user->name;  // Output: Mario

---

3. Come si usa foreach per iterare un array associativo?

Risposta:
foreach permette di scorrere un array associativo e accedere sia alla chiave che al valore.

Esempio:

$data = ["nome" => "Luca", "età" => 30];

foreach ($data as $key => $value) {
    echo "$key: $value\n";
}
// Output:
// nome: Luca
// età: 30

---

4. Qual è la differenza tra isset() e empty()?

Risposta:

• isset($var): true se la variabile esiste ed è diversa da null.

• empty($var): true se la variabile è vuota (0, "", null, false, array(), unset()).

Esempio:

$var1 = "";
$var2 = "Hello";

echo isset($var1) ? "SET\n" : "NOT SET\n";   // Output: SET
echo empty($var1) ? "EMPTY\n" : "NOT EMPTY\n"; // Output: EMPTY

---

5. Cosa fa explode() in PHP?

Risposta:
explode() divide una stringa in un array, separandola con un delimitatore.

Esempio:

$string = "apple,banana,orange";
$array = explode(",", $string);

print_r($array);
// Output:
// Array ( [0] => apple [1] => banana [2] => orange )

---

6. Cosa fa implode() in PHP?

Risposta:
implode() crea una stringa unendo gli elementi di un array, separandoli con un carattere specifico.

Esempio:

$array = ["red", "blue", "green"];
$string = implode(" - ", $array);

echo $string; // Output: red - blue - green

---

7. Come si definisce e utilizza un'interfaccia in PHP?

Risposta:
Un'interfaccia definisce metodi obbligatori che una classe deve implementare.

Esempio:

interface Vehicle {
    public function move();
}

class Car implements Vehicle {
    public function move() {
        return "L'auto si muove";
    }
}

$car = new Car();
echo $car->move();  // Output: L'auto si muove

---

8. Qual è la differenza tra session e cookie?

Risposta:

• Session: dati salvati sul server, legati a un utente.

• Cookie: dati salvati sul browser dell'utente.

Esempio:

// Impostare una sessione
session_start();
$_SESSION["user"] = "Luca";

// Impostare un cookie valido per 1 giorno
setcookie("username", "Luca", time() + 86400);

---

9. Cosa fa il metodo __toString() in PHP?

Risposta:
__toString() permette di stampare un oggetto come stringa.

Esempio:

class Person {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function __toString() {
        return "Persona: " . $this->name;
    }
}

$p = new Person("Mario");
echo $p;  // Output: Persona: Mario

---

10. Cosa sono gli anonymous classes in PHP?

Risposta:
Le classi anonime sono classi senza nome, dichiarate direttamente in una variabile.

Esempio:

$object = new class {
    public function greet() {
        return "Hello from anonymous class!";
    }
};

echo $object->greet();  // Output: Hello from anonymous class!

---