PHP/referencing - Revision history

Woozle at 15:18, 18 March 2026

2026-03-18T15:18:10Z

← Older revision		Revision as of 15:18, 18 March 2026
Line 62:		Line 62:
	* [https://www.php.net/manual/en/functions.returning-values.php Returning values]: see "Example #3 Returning a reference from a function"		* [https://www.php.net/manual/en/functions.returning-values.php Returning values]: see "Example #3 Returning a reference from a function"
	* [https://www.php.net/manual/en/language.oop5.references.php Objects and references]: they're not handled quite the same		* [https://www.php.net/manual/en/language.oop5.references.php Objects and references]: they're not handled quite the same
			** In PHP 8.4, at least, objects passed to a function and then modified within the function do ''not'' seem to affect the original.
	** short explanation: objects are looked up in a different table from references		** short explanation: objects are looked up in a different table from references

Woozle: /* Concepts */

2025-11-21T00:22:14Z

Concepts

← Older revision		Revision as of 00:22, 21 November 2025
Line 10:		Line 10:

	'''Yet another way to look at it:''' If you think of ''all'' variables in PHP as being {{l/wp\|Pointer (computer programming)\|pointers}}, then <code>=&</code> is the only operator which acts directly on the address in each pointer variable; all the others automatically dereference any variables they touch.		'''Yet another way to look at it:''' If you think of ''all'' variables in PHP as being {{l/wp\|Pointer (computer programming)\|pointers}}, then <code>=&</code> is the only operator which acts directly on the address in each pointer variable; all the others automatically dereference any variables they touch.
	* Given this, referring to the <code>&</code> syntax as "referencing" is actually kind of backwards.		* Given this, referring to the <code>&</code> syntax as "referencing" is actually kind of backwards; it would be more accurately called "dereferencing".

	==Clarification==		==Clarification==

Woozle: /* Concepts */

2025-11-21T00:20:32Z

Concepts

← Older revision		Revision as of 00:20, 21 November 2025
Line 5:		Line 5:
	References do allow some of the functionality provided by pointers in other languages (like C/C++), but unlike pointers they are always de-referenced from the standpoint of the PHP code. A better analogy (the PHP manual [https://www.php.net/manual/en/language.references.whatare.php agrees]) is to think of them like hard file links in Unix. Conceptually, <code>$b = &$a</code> means "$b and $a now point to the same content", ''not'' "$b is a pointer to $a's content".		References do allow some of the functionality provided by pointers in other languages (like C/C++), but unlike pointers they are always de-referenced from the standpoint of the PHP code. A better analogy (the PHP manual [https://www.php.net/manual/en/language.references.whatare.php agrees]) is to think of them like hard file links in Unix. Conceptually, <code>$b = &$a</code> means "$b and $a now point to the same content", ''not'' "$b is a pointer to $a's content".

	A better cognitive model, perhaps, is to think of "=" and "=&" as what ~~it says on the tin:~~ different operations ~~applied to the same variables~~:		'''A better cognitive model''', perhaps, is to think of "<code>=</code>" and "<code>=&</code>" as what they look like — different operations:
	* <code>$A = $B</code> copies $B's '''holder contents''' to $A, so $A and $B have the same value.		* <code>$A = $B</code> copies $B's '''holder contents''' to $A, so $A and $B have the same value.
	* <code>$A =& $B</code> copies $B's '''holder address''' to $A, so $A and $B use the same value-holder.		* <code>$A =& $B</code> copies $B's '''holder address''' to $A, so $A and $B use the same value-holder.

	'''~~Another~~ way to look at it:''' If you think of ''all'' variables in PHP as being {{l/wp\|Pointer (computer programming)\|pointers}}, then <code>=&</code> is the only operator which acts directly on the address in each pointer variable; all the others automatically dereference any variables they touch.		'''Yet another way to look at it:''' If you think of ''all'' variables in PHP as being {{l/wp\|Pointer (computer programming)\|pointers}}, then <code>=&</code> is the only operator which acts directly on the address in each pointer variable; all the others automatically dereference any variables they touch.
	* Given this, ~~the term "referencing"~~ to ~~describe~~ the <code>=&</code> ~~operator~~ is actually kind of backwards.		* Given this, referring to the <code>&</code> syntax as "referencing" is actually kind of backwards.

	==Clarification==		==Clarification==

Woozle: /* Concepts */

2025-11-21T00:14:42Z

Concepts

← Older revision		Revision as of 00:14, 21 November 2025
Line 8:		Line 8:
	* <code>$A = $B</code> copies $B's '''holder contents''' to $A, so $A and $B have the same value.		* <code>$A = $B</code> copies $B's '''holder contents''' to $A, so $A and $B have the same value.
	* <code>$A =& $B</code> copies $B's '''holder address''' to $A, so $A and $B use the same value-holder.		* <code>$A =& $B</code> copies $B's '''holder address''' to $A, so $A and $B use the same value-holder.

			'''Another way to look at it:''' If you think of ''all'' variables in PHP as being {{l/wp\|Pointer (computer programming)\|pointers}}, then <code>=&</code> is the only operator which acts directly on the address in each pointer variable; all the others automatically dereference any variables they touch.
			* Given this, the term "referencing" to describe the <code>=&</code> operator is actually kind of backwards.

	==Clarification==		==Clarification==
	There are no reference ''types'' (you can't declare, for example, <code>&array</code> or <code>&int</code> variables or return values); there are only reference ''operations'' -- and the reference operation is basically a qualifier (indicated by <code>&</code>) on a variable-access.		There are no reference ''types'' (you can't declare, for example, <code>&array</code> or <code>&int</code> variables or return values); there are only reference ''operations'' -- and the reference operation is basically a qualifier (indicated by <code>&</code>) on a variable-access.

Woozle: /* correct */

2024-08-19T13:39:53Z

correct

← Older revision		Revision as of 13:39, 19 August 2024
Line 13:		Line 13:
	This is seemingly at odds with the fact that functions which return references are declared using the "&" prefix on the ''function name'' rather than on the ''return variable'', but if you think of "return" as a function which returns a reference whenever one is available (i.e. when returning a variable) and only reverts to returning a value when that's all it's got, then it makes more sense. The function having returned a reference, you want to be sure to capture that (and not just the value) by using <code>=&</code>.		This is seemingly at odds with the fact that functions which return references are declared using the "&" prefix on the ''function name'' rather than on the ''return variable'', but if you think of "return" as a function which returns a reference whenever one is available (i.e. when returning a variable) and only reverts to returning a value when that's all it's got, then it makes more sense. The function having returned a reference, you want to be sure to capture that (and not just the value) by using <code>=&</code>.
	===correct===		===correct===
	* <syntaxhighlight lang=php inline>function &Ref(&$a) { $b=$a; return $b; }</syntaxhighlight>// Ref() returns a reference to $a		* <syntaxhighlight lang=php inline>$w =& $v;</syntaxhighlight>// after this line, setting $v or $w now sets the other too – because they're both using the same memory-space
	* <syntaxhighlight lang=php inline>$y =& Ref($x);</syntaxhighlight>// setting $x or $y now sets the other too, because they're both using the same memory-space		* <syntaxhighlight lang=php inline>function &Ref(&$a) { $b=$a; return $b; }</syntaxhighlight>// Ref() returns a reference to whatever variable is passed as $a
			* <syntaxhighlight lang=php inline>$y =& Ref($x);</syntaxhighlight>// after this line, setting $x or $y now sets the other too – because they're both using the same memory-space

	===wrong===		===wrong===

Woozle: /* correct */

2024-08-19T13:36:09Z

correct

← Older revision		Revision as of 13:36, 19 August 2024
Line 14:		Line 14:
	===correct===		===correct===
	* <syntaxhighlight lang=php inline>function &Ref(&$a) { $b=$a; return $b; }</syntaxhighlight>// Ref() returns a reference to $a		* <syntaxhighlight lang=php inline>function &Ref(&$a) { $b=$a; return $b; }</syntaxhighlight>// Ref() returns a reference to $a
	* <syntaxhighlight lang=php inline>$y =& Ref($x);</syntaxhighlight>// setting $y now sets $x		* <syntaxhighlight lang=php inline>$y =& Ref($x);</syntaxhighlight>// setting $x or $y now sets the other too, because they're both using the same memory-space

	===wrong===		===wrong===
	* <code>function <span style="color:red;">R</span>ef(&$a) { $b=$a; return $b; }</code> - missing "&" before "Ref"		* <code>function <span style="color:red;">R</span>ef(&$a) { $b=$a; return $b; }</code> - missing "&" before "Ref"

Woozle: /* Basics */ "return" was confusing

2024-08-19T13:12:43Z

Basics: "return" was confusing

← Older revision		Revision as of 13:12, 19 August 2024
Line 21:		Line 21:

	==Basics==		==Basics==
	To ~~return~~ a reference instead of a value, use the <code>&</code> operator when referring to the source variable:		To copy (assign) a reference instead of a value, use the <code>&</code> operator when referring to the source variable:
	<syntaxhighlight lang=php>		<syntaxhighlight lang=php>
	$vtest = 'test value';		$vtest = 'test value';

Woozle: /* Clarification */ examples corrected and simplified

2024-08-19T13:11:17Z

Clarification: examples corrected and simplified

← Older revision		Revision as of 13:11, 19 August 2024
Line 11:		Line 11:
	There are no reference ''types'' (you can't declare, for example, <code>&array</code> or <code>&int</code> variables or return values); there are only reference ''operations'' -- and the reference operation is basically a qualifier (indicated by <code>&</code>) on a variable-access.		There are no reference ''types'' (you can't declare, for example, <code>&array</code> or <code>&int</code> variables or return values); there are only reference ''operations'' -- and the reference operation is basically a qualifier (indicated by <code>&</code>) on a variable-access.

	This is seemingly at odds with the fact that functions which return references are declared using the "&" prefix on the ''function name'' rather than on the ''return variable'':		This is seemingly at odds with the fact that functions which return references are declared using the "&" prefix on the ''function name'' rather than on the ''return variable'', but if you think of "return" as a function which returns a reference whenever one is available (i.e. when returning a variable) and only reverts to returning a value when that's all it's got, then it makes more sense. The function having returned a reference, you want to be sure to capture that (and not just the value) by using <code>=&</code>.
	<syntaxhighlight lang=php>		===correct===
	~~// THIS:~~		* <syntaxhighlight lang=php inline>function &Ref(&$a) { $b=$a; return $b; }</syntaxhighlight>// Ref() returns a reference to $a
	function &Ref(&$a) { $b=$a; return $b; }		* <syntaxhighlight lang=php inline>$y =& Ref($x);</syntaxhighlight>// setting $y now sets $x
	$y =& Ref(); // setting $y now sets $a		===wrong===
			* <code>function <span style="color:red;">R</span>ef(&$a) { $b=$a; return $b; }</code> - missing "&" before "Ref"
	~~class cThings {~~		* <code>function &Ref(<span style="color:red;">$</span>a) { $b=$a; return $b; }</code> - missing "&" before "$a"
	~~private $arIn~~ = ~~[];~~		* <code>function &Ref(&$a) { $b=$a; return <span style="color:red;">&</span>$b; }</code> - extra "&" after "return"
	function ~~&InputArray()~~ : ~~array { return $this-~~>~~arIn; }~~
	~~function Stuff~~() {
	$ar =& $~~this->InputArray()~~;
	$~~ar = $_GET~~; /~~/ sets $this-~~>~~arIn~~
	}
	}

	~~// -- BUT -~~-

	~~// NEITHER this~~
	function Ref(&$a) { $b=$a; return &$b; }
	/~~/ NOR this~~
	function &Ref($a) { $b=$a; return $b; }

	</~~syntaxhighlight~~>

	==Basics==		==Basics==

Woozle at 19:59, 2 April 2023

2023-04-02T19:59:30Z

← Older revision		Revision as of 19:59, 2 April 2023
Line 4:		Line 4:

	References do allow some of the functionality provided by pointers in other languages (like C/C++), but unlike pointers they are always de-referenced from the standpoint of the PHP code. A better analogy (the PHP manual [https://www.php.net/manual/en/language.references.whatare.php agrees]) is to think of them like hard file links in Unix. Conceptually, <code>$b = &$a</code> means "$b and $a now point to the same content", ''not'' "$b is a pointer to $a's content".		References do allow some of the functionality provided by pointers in other languages (like C/C++), but unlike pointers they are always de-referenced from the standpoint of the PHP code. A better analogy (the PHP manual [https://www.php.net/manual/en/language.references.whatare.php agrees]) is to think of them like hard file links in Unix. Conceptually, <code>$b = &$a</code> means "$b and $a now point to the same content", ''not'' "$b is a pointer to $a's content".

			A better cognitive model, perhaps, is to think of "=" and "=&" as what it says on the tin: different operations applied to the same variables:
			* <code>$A = $B</code> copies $B's '''holder contents''' to $A, so $A and $B have the same value.
			* <code>$A =& $B</code> copies $B's '''holder address''' to $A, so $A and $B use the same value-holder.
	==Clarification==		==Clarification==
	There are no reference ''types'' (you can't declare, for example, <code>&array</code> or <code>&int</code> variables or return values); there are only reference ''operations'' -- and the reference operation is basically a qualifier (indicated by <code>&</code>) on a variable-access.		There are no reference ''types'' (you can't declare, for example, <code>&array</code> or <code>&int</code> variables or return values); there are only reference ''operations'' -- and the reference operation is basically a qualifier (indicated by <code>&</code>) on a variable-access.

Woozle: another example; formatting for clarity

2023-03-10T14:56:25Z

another example; formatting for clarity

← Older revision		Revision as of 14:56, 10 March 2023
Line 11:		Line 11:
	// THIS:		// THIS:
	function &Ref(&$a) { $b=$a; return $b; }		function &Ref(&$a) { $b=$a; return $b; }
	// ~~NOT THIS~~		$y =& Ref(); // setting $y now sets $a

			class cThings {
			private $arIn = [];
			function &InputArray() : array { return $this->arIn; }
			function Stuff() {
			$ar =& $this->InputArray();
			$ar = $_GET; // sets $this->arIn
			}
			}

			// -- BUT --

			// NEITHER this
	function Ref(&$a) { $b=$a; return &$b; }		function Ref(&$a) { $b=$a; return &$b; }
	// ~~OR THIS~~		// NOR this
	function &Ref($a) { $b=$a; return $b; }		function &Ref($a) { $b=$a; return $b; }
	~~// AND DON'T FORGET~~
	~~$y =& Ref(); // not $y = Ref();~~
	</syntaxhighlight>		</syntaxhighlight>