PHP Academy · Lektion

Variabelomfång: lokalt och globalt

Förstå hur PHP avgränsar funktioners omfång och hur nyckelordet global används.

Lektion 3 av 413 steg

Variabelomfång: lokalt och globalt är en gratis lektion i PHP Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för PHP Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i PHP Academy innehåller totalt 4 lektioner.

Variabelomfång i PHP

I PHP har varje variabel ett omfång — det kodområde där den är tillgänglig.

Variabler som skapas utanför funktioner finns i globalt omfång
Variabler som skapas inuti funktioner finns i lokalt omfång
PHP har INTE blockomfång, till skillnad från C och JavaScript

Lokalt omfång

Variabler inuti en funktion är lokala — de försvinner när funktionen returnerar:

<?php
function compute(): void {
    $result = 42;  // local variable
    echo $result;  // 42
}

compute();
echo $result ?? 'undefined';  // undefined — $result is gone

Globala variabler är INTE automatiskt synliga

Till skillnad från många andra språk kan PHP-funktioner inte se globala variabler som standard — de måste importeras uttryckligen:

<?php
$message = 'Hello';

function printMessage(): void {
    echo $message ?? 'not visible';  // 'not visible'
    // $message from global scope is not accessible here
}

Nyckelordet global

Använd global $varName inuti en funktion för att komma åt en global variabel:

<?php
$counter = 0;

function increment(): void {
    global $counter;
    $counter++;
}

increment();
increment();
echo $counter;  // 2

$GLOBALS-superglobalen

$GLOBALS är en array som innehåller alla globala variabler — den är tillgänglig överallt utan nyckelordet global:

<?php
$total = 100;

function addTax(): void {
    $GLOBALS['total'] *= 1.18;  // 18% tax
}

addTax();
echo $total;  // 118

Varför global bör undvikas

Överanvändning av global skapar dolda beroenden — funktioner blir svåra att testa och felsöka. Värden bör i stället skickas som argument:

<?php
// Bad
$db = new PDO(/* ... */);
function getUsers(): array {
    global $db;
    return $db->query('SELECT * FROM users')->fetchAll();
}

// Good
function getUsers(PDO $db): array {
    return $db->query('SELECT * FROM users')->fetchAll();
}

Statiska variabler

En static-variabel behåller sitt värde mellan funktionsanrop, men är fortfarande lokal för funktionen:

<?php
function callCount(): int {
    static $count = 0;
    return ++$count;
}

echo callCount();  // 1
echo callCount();  // 2
echo callCount();  // 3

Closures och variabelfångst

Closures (anonyma funktioner) kan fånga variabler från det yttre omfånget med use:

<?php
$prefix = 'Mr';

$greet = function(string $name) use ($prefix): string {
    return "$prefix. $name";
};

echo $greet('Smith');  // Mr. Smith

Fånga med referens

Fånga med referens genom use (&$var) så att closure-funktionen kan ändra variabeln i det yttre omfånget:

<?php
$total = 0;

$add = function(int $n) use (&$total): void {
    $total += $n;
};

$add(10);
$add(5);
echo $total;  // 15

Pilfunktioner

Pilfunktioner i PHP 7.4 (fn =>) fångar automatiskt det yttre omfånget genom värde — ingen use behövs:

<?php
$multiplier = 3;
$nums = [1, 2, 3, 4];

$result = array_map(fn($n) => $n * $multiplier, $nums);

print_r($result);  // [3, 6, 9, 12]

Nästlade funktioner

PHP tillåter att en funktion definieras inuti en annan, men den inre funktionen blir globalt tillgänglig efter att den yttre har anropats:

<?php
function outer(): void {
    function inner(): void {
        echo 'inner called';
    }
}

// inner(); // Fatal: undefined before outer() is called
outer();
inner(); // works now

Snabb kontroll

Vad gör en static-variabel inuti en PHP-funktion?

Besvara frågan i den interaktiva lektionen

Sammanfattning: variabelomfång

Viktiga regler för omfång i PHP:

Funktioner har ett eget lokalt omfång
Globala variabler måste importeras med global
Använd $GLOBALS['name'] som alternativ
static-variabler finns kvar mellan anrop inom en funktion
Closures fångar variabler från det yttre omfånget med use
Pilfunktioner fångar automatiskt variabler genom värde

Gratis att börja

Lär dig PHP med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 49
Lektioner: 195

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Variabelomfång: lokalt och globalt” gratis?

Ja – hela texten till ”Variabelomfång: lokalt och globalt” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i PHP Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i PHP Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Variabelomfång: lokalt och globalt”?

Förstå hur PHP avgränsar funktioners omfång och hur nyckelordet global används. Ni övar på PHP Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig PHP Academy?

Du behöver inga förkunskaper. Utbildningen i PHP Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Variabelomfång: lokalt och globalt”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här PHP Academy-lektionen?

Ja. Varje PHP Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till PHP Academy