Was Referenzen sind
in PHP you don't really need pointer anymore if you want to share an object across your program
<?php
class foo{
protected $name;
function __construct($str){
$this->name = $str;
}
function __toString(){
return 'my name is "'. $this->name .'" and I live in "' . __CLASS__ . '".' . "\n";
}
function setName($str){
$this->name = $str;
}
}
class MasterOne{
protected $foo;
function __construct($f){
$this->foo = $f;
}
function __toString(){
return 'Master: ' . __CLASS__ . ' | foo: ' . $this->foo . "\n";
}
function setFooName($str){
$this->foo->setName( $str );
}
}
class MasterTwo{
protected $foo;
function __construct($f){
$this->foo = $f;
}
function __toString(){
return 'Master: ' . __CLASS__ . ' | foo: ' . $this->foo . "\n";
}
function setFooName($str){
$this->foo->setName( $str );
}
}
$bar = new foo('bar');
print("\n");
print("Only Created \$bar and printing \$bar\n");
print( $bar );
print("\n");
print("Now \$baz is referenced to \$bar and printing \$bar and \$baz\n");
$baz =& $bar;
print( $bar );
print("\n");
print("Now Creating MasterOne and Two and passing \$bar to both constructors\n");
$m1 = new MasterOne( $bar );
$m2 = new MasterTwo( $bar );
print( $m1 );
print( $m2 );
print("\n");
print("Now changing value of \$bar and printing \$bar and \$baz\n");
$bar->setName('baz');
print( $bar );
print( $baz );
print("\n");
print("Now printing again MasterOne and Two\n");
print( $m1 );
print( $m2 );
print("\n");
print("Now changing MasterTwo's foo name and printing again MasterOne and Two\n");
$m2->setFooName( 'MasterTwo\'s Foo' );
print( $m1 );
print( $m2 );
print("Also printing \$bar and \$baz\n");
print( $bar );
print( $baz );
?>
Was Referenzen leisten
PHP Referenzen erlauben es, zwei Variablennamen, sich auf den gleichen Variableninhalt beziehen zu lassen. Das heißt im folgenden Beispiel, dass sich $a und $b auf dieselbe Variable beziehen:
<?php
$a =& $b
?>
Hinweis:
$a und $b sind hier gleichwertig, und $a ist nicht nur ein Zeiger auf $b oder umgekehrt, sondern $a und $b zeigen auf den selben Inhalt.
Hinweis:
Wenn ein Array mit Referenzen kopiert wird, werden seine Werte nicht dereferenziert. Dies gilt auch für Array, die per Wert an Funktionen übergeben werden
Hinweis:
Wenn man eine undefinierte Variable per Referenz zuweist, übergibt oder zurückgibt, wird sie erstellt.
Beispiel #1 Referenzen mit undefinierten Variablen benutzen
<?php
function foo(&$var) { }
foo($a); // $a wird "erstellt" mit dem Wert null
$b = array();
foo($b['b']);
var_dump(array_key_exists('b', $b)); // bool(true)
$c = new StdClass;
foo($c->d);
var_dump(property_exists($c, 'd')); // bool(true)
?>
Diese Syntax kann auch mit Funktionen, die Referenzen zurückgeben, benutzt werden und seit PHP 4.0.4 auch in Verbindung mit dem new-Operator.
<?php
$bar =& new fooclass();
$foo =& find_var ($bar);
?>
Hinweis:
Wenn der &-Operator nicht verwendet wird, erzeugt PHP eine Kopie des Objekts. Wenn nun $this innerhalb der Klasse verwendet wird, bezieht es sich auf die aktuelle Instanz der Klasse. Die Zuordnung ohne & erzeugt eine Kopie der Instanz (d.h. des Objekts) und $this wird sich auf die Kopie beziehen. In der Regel will man aus Performance- und Speicherverbrausgründen nur eine einzige Instanz einer Klasse erzeugen.
Während man den @-Operator benutzen kann, um Fehler im Konstruktor zu unterdrücken, wenn man ihn als @new benutzt, funktioniert dies nicht bei der Benutzung von &new. Dies ist eine Einschränkung der Zend Engine und resultiert daher in einem Parserfehler.
Warnung
Man sollte global $var; als Abkürzung für
$var =& $GLOBALS['var']; sehen. Deswegen ändert die
Zuweisung per Referenz an $var nur die Referenz
der lokalen Variable.
Wenn man einer als global deklarierten Variable eine Referenz innerhalb einer Funktion zuweist, wird die Referenz nur innerhalb der Funktion sichtbar sein. Dies kann durch die Verwendung des $GLOBALS-Arrays vermieden werden.
Beispiel #2 Globale Variablen innerhalb einer Funktion referenzieren
<?php
$var1 = "Beispielvariable";
$var2 = "";
function global_references($use_globals)
{
global $var1, $var2;
if (!$use_globals) {
$var2 =& $var1; // nur innerhalb der Funktion sichtbar
} else {
$GLOBALS["var2"] =& $var1; // auch im globalen Kontext sichtbar
}
}
global_references(false);
echo "var2 wurde auf '$var2' gesetzt\n"; // var2 ist ''
global_references(true);
echo "var2 wurde auf '$var2' gesetzt\n"; // var2 ist 'Beispielvariable'
?>
Hinweis:
Wenn man einer Variable einen Wert per Referenz in einer foreach-Anweisung zuweist, werden die Referenzen auch geändert.
Beispiel #3 Referenzen und die foreach-Anweisung
<?php
$ref = 0;
$row =& $ref;
foreach (array(1, 2, 3) as $row) {
// do something
}
echo $ref; // 3 - letztes Element des durchlaufenen Arrays
?>
Eine weitere Einsatzmöglichkeit von Referenzen ist die Übergabe von Parametern an eine Funktion mit pass-by-reference. Hierbei beziehen sich der lokale Variablenname als auch der Variablenname der aufrufenden Instanz auf denselben Variableninhalt:
<?php
function foo(&$var) {
$var++;
}
$a=5;
foo($a);
?>
Daneben besteht die Möglichkeit aus Funktionen heraus Werte mit return by-reference zurückzugeben.
add a note
User Contributed Notes
Was Referenzen leisten
nay at woodcraftsrus dot com
08-Jul-2011 11:35
elrah [] polyptych [dot] com
27-Jan-2011 11:38
It appears that references can have side-effects. Below are two examples. Both are simply copying one array to another. In the second example, a reference is made to a value in the first array before the copy. In the first example the value at index 0 points to two separate memory locations. In the second example, the value at index 0 points to the same memory location.
I won't say this is a bug, because I don't know what the designed behavior of PHP is, but I don't think ANY developers would expect this behavior, so look out.
An example of where this could cause problems is if you do an array copy in a script and expect on type of behavior, but then later add a reference to a value in the array earlier in the script, and then find that the array copy behavior has unexpectedly changed.
<?php
// Example one
$arr1 = array(1);
echo "\nbefore:\n";
echo "\$arr1[0] == {$arr1[0]}\n";
$arr2 = $arr1;
$arr2[0]++;
echo "\nafter:\n";
echo "\$arr1[0] == {$arr1[0]}\n";
echo "\$arr2[0] == {$arr2[0]}\n";
// Example two
$arr3 = array(1);
$a =& $arr3[0];
echo "\nbefore:\n";
echo "\$a == $a\n";
echo "\$arr3[0] == {$arr3[0]}\n";
$arr4 = $arr3;
$arr4[0]++;
echo "\nafter:\n";
echo "\$a == $a\n";
echo "\$arr3[0] == {$arr3[0]}\n";
echo "\$arr4[0] == {$arr4[0]}\n";
?>
akinaslan at gmail dot com
08-Jan-2011 06:31
In this example class name is different from its first function and however there is no construction function. In the end as you guess "a" and "c" are equal. So if there is no construction function at same time class and its first function names are the same, "a" and "c" doesn't equal forever. In my opinion php doesn't seek any function for the construction as long as their names differ from each others.
<?php
class reftest_new
{
public $a = 1;
public $c = 1;
public function reftest()
{
$b =& $this->a;
$b++;
}
public function reftest2()
{
$d =& $this->c;
$d++;
}
}
$reference = new reftest_new();
$reference->reftest();
$reference->reftest2();
echo $reference->a; //Echoes 2.
echo $reference->c; //Echoes 2.
?>
Amaroq
16-Jan-2010 04:14
I think a correction to my last post is in order.
When there is a constructor, the strange behavior mentioned in my last post doesn't occur. My guess is that php was treating reftest() as a constructor (maybe because it was the first function?) and running it upon instantiation.
<?php
class reftest
{
public $a = 1;
public $c = 1;
public function __construct()
{
return 0;
}
public function reftest()
{
$b =& $this->a;
$b++;
}
public function reftest2()
{
$d =& $this->c;
$d++;
}
}
$reference = new reftest();
$reference->reftest();
$reference->reftest2();
echo $reference->a; //Echoes 2.
echo $reference->c; //Echoes 2.
?>
Amaroq
15-Jan-2010 07:08
When using references in a class, you can reference $this-> variables.
<?php
class reftest
{
public $a = 1;
public $c = 1;
public function reftest()
{
$b =& $this->a;
$b = 2;
}
public function reftest2()
{
$d =& $this->c;
$d++;
}
}
$reference = new reftest();
$reference->reftest();
$reference->reftest2();
echo $reference->a; //Echoes 2.
echo $reference->c; //Echoes 2.
?>
However, this doesn't appear to be completely trustworthy. In some cases, it can act strangely.
<?php
class reftest
{
public $a = 1;
public $c = 1;
public function reftest()
{
$b =& $this->a;
$b++;
}
public function reftest2()
{
$d =& $this->c;
$d++;
}
}
$reference = new reftest();
$reference->reftest();
$reference->reftest2();
echo $reference->a; //Echoes 3.
echo $reference->c; //Echoes 2.
?>
In this second code block, I've changed reftest() so that $b increments instead of just gets changed to 2. Somehow, it winds up equaling 3 instead of 2 as it should.
strata_ranger at hotmail dot com
26-Sep-2009 05:29
An interesting if offbeat use for references: Creating an array with an arbitrary number of dimensions.
For example, a function that takes the result set from a database and produces a multidimensional array keyed according to one (or more) columns, which might be useful if you want your result set to be accessible in a hierarchial manner, or even if you just want your results keyed by the values of each row's primary/unique key fields.
<?php
function array_key_by($data, $keys, $dupl = false)
/*
* $data - Multidimensional array to be keyed
* $keys - List containing the index/key(s) to use.
* $dupl - How to handle rows containing the same values. TRUE stores it as an Array, FALSE overwrites the previous row.
*
* Returns a multidimensional array indexed by $keys, or NULL if error.
* The number of dimensions is equal to the number of $keys provided (+1 if $dupl=TRUE).
*/
{
// Sanity check
if (!is_array($data)) return null;
// Allow passing single key as a scalar
if (is_string($keys) or is_integer($keys)) $keys = Array($keys);
elseif (!is_array($keys)) return null;
// Our output array
$out = Array();
// Loop through each row of our input $data
foreach($data as $cx => $row) if (is_array($row))
{
// Loop through our $keys
foreach($keys as $key)
{
$value = $row[$key];
if (!isset($last)) // First $key only
{
if (!isset($out[$value])) $out[$value] = Array();
$last =& $out; // Bind $last to $out
}
else // Second and subsequent $key....
{
if (!isset($last[$value])) $last[$value] = Array();
}
// Bind $last to one dimension 'deeper'.
// First lap: was &$out, now &$out[...]
// Second lap: was &$out[...], now &$out[...][...]
// Third lap: was &$out[...][...], now &$out[...][...][...]
// (etc.)
$last =& $last[$value];
}
if (isset($last))
{
// At this point, copy the $row into our output array
if ($dupl) $last[$cx] = $row; // Keep previous
else $last = $row; // Overwrite previous
}
unset($last); // Break the reference
}
else return NULL;
// Done
return $out;
}
// A sample result set to test the function with
$data = Array(Array('name' => 'row 1', 'foo' => 'foo_a', 'bar' => 'bar_a', 'baz' => 'baz_a'),
Array('name' => 'row 2', 'foo' => 'foo_a', 'bar' => 'bar_a', 'baz' => 'baz_b'),
Array('name' => 'row 3', 'foo' => 'foo_a', 'bar' => 'bar_b', 'baz' => 'baz_c'),
Array('name' => 'row 4', 'foo' => 'foo_b', 'bar' => 'bar_c', 'baz' => 'baz_d')
);
// First, let's key it by one column (result: two-dimensional array)
print_r(array_key_by($data, 'baz'));
// Or, key it by two columns (result: 3-dimensional array)
print_r(array_key_by($data, Array('baz', 'bar')));
// We could also key it by three columns (result: 4-dimensional array)
print_r(array_key_by($data, Array('baz', 'bar', 'foo')));
?>
dnhuff at acm dot org
09-Jun-2008 01:33
In reply to Drewseph using foo($a = 'set'); where $a is a reference formal parameter.
$a = 'set' is an expression. Expressions cannot be passed by reference, don't you just hate that, I do. If you turn on error reporting for E_NOTICE, you will be told about it.
Resolution: $a = 'set'; foo($a); this does what you want.
Drewseph
29-May-2008 06:15
If you set a variable before passing it to a function that takes a variable as a reference, it is much harder (if not impossible) to edit the variable within the function.
Example:
<?php
function foo(&$bar) {
$bar = "hello\n";
}
foo($unset);
echo($unset);
foo($set = "set\n");
echo($set);
?>
Output:
hello
set
It baffles me, but there you have it.
Amaroq
01-Apr-2008 12:56
The order in which you reference your variables matters.
<?php
$a1 = "One";
$a2 = "Two";
$b1 = "Three";
$b2 = "Four";
$b1 =& $a1;
$a2 =& $b2;
echo $a1; //Echoes "One"
echo $b1; //Echoes "One"
echo $a2; //Echoes "Four"
echo $b2; //Echoes "Four"
?>
charles at org oo dot com
19-Oct-2007 05:59
points to post below me.
When you're doing the references with loops, you need to unset($var).
for example
<?php
foreach($var as &$value)
{
...
}
unset($value);
?>
Hlavac
09-Oct-2007 04:25
Watch out for this:
foreach ($somearray as &$i) {
// update some $i...
}
...
foreach ($somearray as $i) {
// last element of $somearray is mysteriously overwritten!
}
Problem is $i contians reference to last element of $somearray after the first foreach, and the second foreach happily assigns to it!
dovbysh at gmail dot com
06-Jul-2007 02:50
Solution to post "php at hood dot id dot au 04-Mar-2007 10:56":
<?php
$a1 = array('a'=>'a');
$a2 = array('a'=>'b');
foreach ($a1 as $k=>&$v)
$v = 'x';
echo $a1['a']; // will echo x
unset($GLOBALS['v']);
foreach ($a2 as $k=>$v)
{}
echo $a1['a']; // will echo x
?>
amp at gmx dot info
08-Jun-2007 12:59
Something that might not be obvious on the first look:
If you want to cycle through an array with references, you must not use a simple value assigning foreach control structure. You have to use an extended key-value assigning foreach or a for control structure.
A simple value assigning foreach control structure produces a copy of an object or value. The following code
$v1=0;
$arrV=array(&$v1,&$v1);
foreach ($arrV as $v)
{
$v1++;
echo $v."\n";
}
yields
0
1
which means $v in foreach is not a reference to $v1 but a copy of the object the actual element in the array was referencing to.
The codes
$v1=0;
$arrV=array(&$v1,&$v1);
foreach ($arrV as $k=>$v)
{
$v1++;
echo $arrV[$k]."\n";
}
and
$v1=0;
$arrV=array(&$v1,&$v1);
$c=count($arrV);
for ($i=0; $i<$c;$i++)
{
$v1++;
echo $arrV[$i]."\n";
}
both yield
1
2
and therefor cycle through the original objects (both $v1), which is, in terms of our aim, what we have been looking for.
(tested with php 4.1.3)
firespade at gmail dot com
03-Apr-2007 09:11
Here's a good little example of referencing. It was the best way for me to understand, hopefully it can help others.
$b = 2;
$a =& $b;
$c = $a;
echo $c;
// Then... $c = 2
php at hood dot id dot au
04-Mar-2007 11:56
I discovered something today using references in a foreach
<?php
$a1 = array('a'=>'a');
$a2 = array('a'=>'b');
foreach ($a1 as $k=>&$v)
$v = 'x';
echo $a1['a']; // will echo x
foreach ($a2 as $k=>$v)
{}
echo $a1['a']; // will echo b (!)
?>
After reading the manual this looks like it is meant to happen. But it confused me for a few days!
(The solution I used was to turn the second foreach into a reference too)
ladoo at gmx dot at
17-Apr-2005 04:05
I ran into something when using an expanded version of the example of pbaltz at NO_SPAM dot cs dot NO_SPAM dot wisc dot edu below.
This could be somewhat confusing although it is perfectly clear if you have read the manual carfully. It makes the fact that references always point to the content of a variable perfectly clear (at least to me).
<?php
$a = 1;
$c = 2;
$b =& $a; // $b points to 1
$a =& $c; // $a points now to 2, but $b still to 1;
echo $a, " ", $b;
// Output: 2 1
?>
php.devel at homelinkcs dot com
15-Nov-2004 04:16
In reply to lars at riisgaardribe dot dk,
When a variable is copied, a reference is used internally until the copy is modified. Therefore you shouldn't use references at all in your situation as it doesn't save any memory usage and increases the chance of logic bugs, as you discoved.
joachim at lous dot org
10-Apr-2003 05:46
So to make a by-reference setter function, you need to specify reference semantics _both_ in the parameter list _and_ the assignment, like this:
class foo{
var $bar;
function setBar(&$newBar){
$this->bar =& newBar;
}
}
Forget any of the two '&'s, and $foo->bar will end up being a copy after the call to setBar.