PHP
Variabelt omfattning

Introduktion

Användardefinierade globala variabler

Räckvidden utanför någon funktion eller klass är den globala räckvidden. När ett PHP-skript innehåller ett annat (med include eller require ) förblir omfånget detsamma. Om ett skript ingår utanför någon funktion eller klass ingår det globala variabler i samma globala omfång, men om ett skript ingår från en funktion, ligger variablerna i det inkluderade skriptet inom ramen för funktionen.

Inom ramen för en funktion eller klassmetod kan det global nyckelordet användas för att skapa en åtkomst av användardefinierade globala variabler.

<?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

Ett andra sätt att komma åt variabler från det globala omfånget är att använda den speciella PHP-definierade $ GLOBALS-arrayen.

$ GLOBALS-matrisen är en associerande matris med namnet på den globala variabeln som är nyckeln och innehållet i den variabeln är värdet på arrayelementet. Lägg märke till hur $ GLOBALS finns i något omfattning, det beror på att $ GLOBALS är en superglobal.

Detta betyder att log_message() -funktionen kan skrivas om som:

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;
}

Man kan fråga sig, varför använda $ GLOBALS-matrisen när det global nyckelordet också kan användas för att få värdet på en global variabel? Det främsta skälet är att använda det global nyckelordet kommer att leda variabeln till räckvidd. Du kan då inte använda samma variabelnamn i det lokala omfånget.

Superglobalvariabler

Superglobalvariabler definieras av PHP och kan alltid användas var som helst utan det global nyckelordet.

<?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', '');

Statiska egenskaper och variabler

Statiska klassegenskaper som definieras med public synlighet är funktionellt desamma som globala variabler. De kan nås från var som helst klassen definieras.

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;

Funktioner kan också definiera statiska variabler inom sitt eget räckvidd. Dessa statiska variabler kvarstår genom flera funktionssamtal, till skillnad från vanliga variabler definierade i ett funktionsomfång. Detta kan vara ett mycket enkelt och enkelt sätt att implementera Singleton-designmönstret:

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);