Variable an Funktion

Auf dieser Seite:

Auf Variablen welche ausserhalb einer Funktion definiert wurden hat man innerhalb einer Funktion nicht ohne weiteres Zugriff. (Auch umgekehrt hat man von ausserhalb einer Funktion auf die Variablen innerhalb einer Funktion keinen Zugriff.) Gleiche Variablennamen in verschiedenen Funktionen machen also keine Probleme, es sei denn, sie werden globalisiert.

Globale Variable

Normalerweise empfängt eine Funktion ihre VariablenWerte ja durch die Argumente im Aufruf. Muss aus einer Funktion heraus auf eine Variable ausserhalb zugegriffen werden, hilft die Anweisung global der Funktion über ihren Zaun zu springen:

global

<?php
$Name="Marcel Biefer"; // Variable auf welche die folgende Funktion eigentlich keinen Zugriff hat
function halloName() // deklariert Funktion welche kein Argument erwartet
{
global $Name; // oeffnet die Zugriffsgrenzen der Funktion
print "Hallo $Name"; // Funktion soll 'Hallo Variable' schreiben
}
halloName(); // aufrufen der Funktion ohne Uebergabe eines Arguments
?>

Diese Funktion ist nicht eigenständig und somit nichts für eine Bibliothek.

Hallo Marcel Biefer

Globale Variable verändern

Die Variable ausserhalb der Funktion kann so (statt durch die Funktion bloss ausgegeben zu werden) auch verändert werden:

<?php
$anzAufrufe=0; // Variable ausserhalb
function numTitel($tit) //Funktionsdefinition
{
global $anzAufrufe; // globalisieren der Variablen
$anzAufrufe++; // inkrementieren der Variablen
print "<h3>$anzAufrufe.$tit</h3>"; // Ausgabebefehl
}
numTitel('Auge'); // Funktionsaufrufe
numTitel('Regen');
numTitel('Wein');
?>

1.Auge
2.Regen
3.Wein

Achtung: Die Änderung der Variablen wirkt sich nicht nur auf diese Funktion aus, sondern gilt für das ganze Script.

Funktion dynamisch aufrufen

So macht man aus einer Funktion ein Variable: Der Funktionsname wird als String einer Variablen zugewiesen. Diese Variable kann dann wie ein Funktionsaufruf verwendet werden. Was ist hier eher komisch wirkt, kann eingesetzt werden um je nach Fall eine andere Funktion zu starten.

<?php
function servus($Name)
{
print "Servus $Name"; // Funktion schreibt 'Servus Argument'
}
$case2="servus"; // Funktionsname im String einer Variablen
$case2(" Marcel Biefer"); // dynamisch aufrufen der Funktion als Variable
print "<br>"; // Zeilenumbruch
servus(" Marcel Biefer"); // Funktion kann nach wie vor auch normal aufgerufen werden?>

Servus Marcel Biefer
Servus Marcel Biefer

Funktion mit Rückgabewert

Auch zum weiterverarbeiten: eine Funktion welche einen Wert (in Variable verpackt) zurück gibt.

return

<?php
$x="Velo"; // irgendwoher kommen 3 Variable
$y="mit Seitenruder";
$z="und Heckklappe!";
function Mach3($x,$y,$z) // Funktion Mach3 erwartet 3 Argumente durch Kommas zu trennen
{
$resultat = "$x $y $z"; // Funktion soll alle 3 Argumente in eine Variable speichern
return $resultat; // Funktion soll beim Aufruf die Variable zurück geben
}
print Mach3("$x ","$y ","$z"); // Funktionsaufruf lässt die zurückgegebene Variable ausdrucken
?>

Velo mit Seitenruder und Heckklappe!

Variable als Referenz übergeben

Beim Aufruf einer Funktion wird normalerweise nur eine Kopie des Arguments in der Parametervariablen gespeichert, die Veränderungen durch die Funktion an dieser Variablen wirkt sich nur Lokal aus, das ursprüngliche Argument wird nicht verändert:

<?php
function plus100($Parameter) // Variable Parameter nimt Kopie des Arguments - der Variablen Ursprung auf
{
$Parameter=$Parameter+100; // die Kopie, nicht die Ursprungsvariable wird verändert
// kein return
}
$Ursprung=777; // Ursprungsvariable wird definiert
plus100($Ursprung); // aufrufen der Funktion mit Uebergabe des Arguments
print ($Ursprung); // Ursprungsvariable hat sich nicht verändert
?>

Ursprung ist: 777

&$

Ein einziges & verändert dieses Verhalten, & in der Funktionsdefinition referenziert die Ursprungsvariable, die Funktion arbeitet jetzt nicht mehr mit einer Kopie der Ursprungsvariablen, sondern greift auf sie direkt zu und verändert sie.

<?php
function pluss100(&$Parameter) // Variable Parameter nimt keine Kopie auf, sondern greift über das Argument - direkt auf die Variable Ursprung zurück
{
$Parameter += 100; // jetzt wird die referenzierte Ursprungsvariable verändert
// kein return
}
$Ursprung=777; // Ursprungsvariable wird definiert
pluss100($Ursprung); // aufrufen der Funktion mit Uebergabe des Arguments
print ($Ursprung); // Ursprungsvariable hat sich also verändert
?>

Ursprung ist: 877
PS. 'Call-Time Pass-by-Reference' erlaubte es, die Referenzierung erst im Funktionsaufruf vorzunehmen: pluss(&$Ursprung); dies ist eine veraltete Technik!

Referenz zurückliefern

<?php
function &plusss100(&$Parameter) // 2 &&
{
$Parameter += 100; // jetzt wird die referenzierte Ursprungsvariable verändert
return $Parameter; // Rückgabebefehl
}
$Ursprung=777; // Ursprungsvariable wird definiert
$Return= &plusss100($Ursprung); //
$Ursprung+=100; // jetzt wird die zurückgegebene Ursprungsvariable wieder verändert
print ($Return); // $Ursprung und $Return sind wie Synonyme
?>

Zurückgegebene Referenz ist: 977

Check den Code.

Variable an Seite >> << Funktion

Ich bin hier: > PHP Lehrling >>> Variable an Funktion