PHP
Zmienny zakres

Wprowadzenie

Zmienne globalne zdefiniowane przez użytkownika

Zakres poza jakąkolwiek funkcją lub klasą jest zasięgiem globalnym. Gdy skrypt PHP zawiera inny (używając opcji include lub require ), zakres pozostaje taki sam. Jeśli skrypt jest zawarty poza jakąkolwiek funkcją lub klasą, jego zmienne globalne są zawarte w tym samym zasięgu globalnym, ale jeśli skrypt jest zawarty w obrębie funkcji, zmienne w dołączonym skrypcie są w zakresie funkcji.

W zakresie metody funkcji lub klasy global słowo kluczowe może być użyte do utworzenia zdefiniowanych przez użytkownika zmiennych globalnych.

<?php

$amount_of_log_calls = 0;

function log_message($message) {
    // Accessing global variable from function scope
    // requires this explicit statement
    global $amount_of_log_calls;

    // This change to the global variable is permanent
    $amount_of_log_calls += 1;

    echo $message;
}

// When in the global scope, regular global variables can be used
// without explicitly stating 'global $variable;'
echo $amount_of_log_calls; // 0

log_message("First log message!");
echo $amount_of_log_calls; // 1

log_message("Second log message!");
echo $amount_of_log_calls; // 2

Drugim sposobem dostępu do zmiennych z zakresu globalnego jest użycie specjalnej tablicy $ GLOBALS zdefiniowanej przez PHP.

Tablica $ GLOBALS jest tablicą asocjacyjną, której kluczem jest nazwa zmiennej globalnej, a zawartość tej zmiennej jest wartością elementu tablicy. Zauważ, że $ GLOBALS istnieje w dowolnym zakresie, ponieważ $ GLOBALS jest superglobalem.

Oznacza to, że funkcję log_message() można przepisać jako:

function log_message($message) {
    // Access the global $amount_of_log_calls variable via the
    // $GLOBALS array. No need for 'global $GLOBALS;', since it
    // is a superglobal variable.
    $GLOBALS['amount_of_log_calls'] += 1;

    echo $messsage;
}

Ktoś może zapytać, po co używać tablicy $ GLOBALS, skoro global słowo kluczowe może być również użyte do uzyskania wartości zmiennej globalnej? Głównym powodem użycia global słowa kluczowego jest wprowadzenie zmiennej do zakresu. Następnie nie można ponownie użyć tej samej nazwy zmiennej w zasięgu lokalnym.

Zmienne superglobalne

Zmienne superglobalne są definiowane przez PHP i zawsze można ich używać z dowolnego miejsca bez global słowa kluczowego.

<?php

function getPostValue($key, $default = NULL) {
    // $_POST is a superglobal and can be used without
    // having to specify 'global $_POST;'
    if (isset($_POST[$key])) {
        return $_POST[$key];
    }

    return $default;
}

// retrieves $_POST['username']
echo getPostValue('username');

// retrieves $_POST['email'] and defaults to empty string
echo getPostValue('email', '');

Właściwości statyczne i zmienne

Właściwości klasy statycznej zdefiniowane za pomocą widoczności public są funkcjonalnie takie same jak zmienne globalne. Dostęp do nich można uzyskać z dowolnego miejsca, w którym zdefiniowano klasę.

class SomeClass {
    public static int $counter = 0;
}

// The static $counter variable can be read/written from anywhere
// and doesn't require an instantiation of the class
SomeClass::$counter += 1;

Funkcje mogą również definiować zmienne statyczne we własnym zakresie. Te zmienne statyczne utrzymują się przez wiele wywołań funkcji, w przeciwieństwie do zwykłych zmiennych zdefiniowanych w zakresie funkcji. Może to być bardzo łatwy i prosty sposób na wdrożenie wzorca projektowego Singleton:

class Singleton {
    public static function getInstance() {
        // Static variable $instance is not deleted when the function ends
        static $instance;

        // Second call to this function will not get into the if-statement,
        // Because an instance of Singleton is now stored in the $instance
        // variable and is persisted through multiple calls
        if (!$instance) {
            // First call to this function will reach this line,
            // because the $instance has only been declared, not initialized
            $instance = new Singleton();
        }

        return $instance;

    }
}

$instance1 = Singleton::getInstance();
$instance2 = Singleton::getInstance();

// Comparing objects with the '===' operator checks whether they are
// the same instance. Will print 'true', because the static $instance
// variable in the getInstance() method is persisted through multiple calls
var_dump($instance1 === $instance2);