PHP excerpt (&)

PHP reference (& amp;) usage details beginner php about & amp; reference official documentation: 1. what is reference: www. php. netmanualzhlanguage. references. whatare. php2. reference: www. php. netmanualzhlanguage. references. whatdo. php3. reference transfer: h PHP reference (&) usage details

Php for beginners

Official documentation:

1. reference what is: http://www.php.net/manual/zh/language.references.whatare.php

2. reference what to do: http://www.php.net/manual/zh/language.references.whatdo.php
3. Reference transfer: http://www.php.net/manual/zh/language.references.pass.php
4. return reference: http://www.php.net/manual/zh/language.references.return.php

Php reference (that is, adding & symbol before variables, functions, and objects)

The reference in PHP means that different names access the same variable content.
The pointer is different from the pointer in C language. the pointer in C language stores the variable content and the address stored in memory.

1. variable reference

PHP reference allows you to use two variables to point to the same content

$ A = "ABC ";
$ B = & $;
Echo $ a; // output here: ABC
Echo $ B; // output here: ABC
$ B = "EFG ";
Echo $ a; // Here, the value of $ a is changed to EFG, So EFG is output.
Echo $ B; // output EFG here
?>

2. function reference transfer (address transfer call))

I will not talk much about the address transfer call. the following code is provided directly.

Function test (& $)
{
$ A = $ a + 100;
}
$ B = 1;
Echo $ B; // output 1
Test ($ B); // here, $ B actually transmits the memory address of the variable content of $ B to the function, you can change the value of $ B by changing the value of $ a in the function.
Echo"
";
Echo $ B; // output 101
?>

Note that test (1); will cause an error.

Note:

In the above "test ($ B);", do not add the & symbol before $ B, but in the function"Call_user_func_array", If you want to reference parameter passing, you need to & symbol, as shown in the following code:

Function a (& $ B ){
$ B ++;
}
$ C = 0;

Call_user_func_array ('A', array (& $ c ));

Echo $ c;

// Output 1

?>

3. function reference return

First look at the code

Function & test ()
{
Static $ B = 0; // declare a static variable
$ B = $ B + 1;
Echo $ B;
Return $ B;
}

$ A = test (); // This statement outputs the value of $ B as 1.
$ A = 5;
$ A = test (); // This statement outputs the value of $ B to 2.

$ A = & test (); // This statement outputs the value of $ B to 3.
$ A = 5;
$ A = test (); // This statement outputs a value of 6 for $ B.
?>

The following explains:
In this way, $ a = test (); is not actually returned by the function reference, which is no different from the normal function call. The reason is: this is the PHP rule.
PHP requires that $ a = & test (); is used to obtain the function reference and return.
As for what is reference return (in the PHP Manual, reference return is used when you want to use a function to find the variable on which the reference should be bound .) I haven't understood this sentence for a long time.

The example above is as follows:
$ A = test () is used to call a function. it only assigns the value of the function to $ a. any change made to $ a does not affect $ B in the function.
But how to call a function through $ a = & test, the function is to direct the memory address of the $ B variable in return $ B to the same place as the memory address of the $ a variable.
That is, the equivalent effect ($ a = & $ B;) is generated. Therefore, changing the value of $ a also changes the value of $ B.
$ A = & test ();
$ A = 5;
Later, the value of $ B is changed to 5.

Static variables are used to help you understand the reference and return functions. In fact, function reference and return are mostly used in objects.

Another official php example is provided:

This is the way how we use pointer to access variable inside the class.

Class talker {

Private $ data = 'hi ';

Public function & get (){
Return $ this-> data;
}

Public function out (){
Echo $ this-> data;
}

}

$ Aa = new talker ();
$ D = & $ aa-> get ();

$ Aa-> out ();
$ D = 'who ';
$ Aa-> out ();
$ D = 'all ';
$ Aa-> out ();
$ D = 'you ';
$ Aa-> out ();
?>

The output is "HiHowAreYou"

4. object reference

Class {
Var $ abc = "ABC ";
}
$ B = new;
$ C = $ B;
Echo $ B-> abc; // output ABC here
Echo $ c-> abc; // output ABC here
$ B-> abc = "DEF ";
Echo $ c-> abc; // output DEF here
?>

The above code is the running effect in PHP5

In PHP5, object assignment is a reference process. In the above column, $ B = new a; $ c = $ B; is equivalent to $ B = new a; $ c = & $ B;
In PHP5, the object is called by reference by default, but sometimes you may want to create a copy of the object and expect that the change of the original object will not affect the copy. for this purpose, PHP5 defines a special method called _ clone.

Since PHP 5, new automatically returns a reference. Therefore, when = & is used here, messages at the E_STRICT level will be generated.

In php4, the value assignment of an object is a copy process,

For example, $ B = new a, where new a generates an anonymous a object instance, and $ B copies the anonymous object. Similarly, $ c = $ B is a copy of $ B content. Therefore, in php4, to save memory space, $ B = new a is generally changed to the reference mode, that is, $ B = & new.

The following is an official example:

In php5, you can get the "object reference" function without adding anything else:

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

Output:

Only Created $ bar and printing $ bar
My name is "bar" and I live in "foo ".

Now $ baz is referenced to $ bar and printing $ bar and $ baz
My name is "bar" and I live in "foo ".

Now Creating MasterOne and Two and passing $ bar to both constructors
Master: MasterOne | foo: my name is "bar" and I live in "foo ".

Master: MasterTwo | foo: my name is "bar" and I live in "foo ".


Now changing value of $ bar and printing $ bar and $ baz
My name is "baz" and I live in "foo ".
My name is "baz" and I live in "foo ".

Now printing again MasterOne and Two
Master: MasterOne | foo: my name is "baz" and I live in "foo ".

Master: MasterTwo | foo: my name is "baz" and I live in "foo ".


Now changing MasterTwo's foo name and printing again MasterOne and Two
Master: MasterOne | foo: my name is "MasterTwo's Foo" and I live in "foo ".

Master: MasterTwo | foo: my name is "MasterTwo's Foo" and I live in "foo ".

Also printing $ bar and $ baz
My name is "MasterTwo's Foo" and I live in "foo ".
My name is "MasterTwo's Foo" and I live in "foo ".

Analysis of the previous example:

$ Bar = new foo ('bar ');
$ M1 = new MasterOne ($ bar );
$ M2 = new MasterTwo ($ bar );

The $ bar in the instance object $ m1 and $ m2 is a reference to the instance $ bar instead of a copy. this is a feature of object reference in php5, that is
1. Inside $ m1 or $ m2, any operation on $ bar will affect the value of $ bar of the external object instance.
2. changes to the external object instance $ bar also affect the reference values of $ m1 and $ m2.

In php4, the equivalent code (that is, reference and call) is similar to the preceding example when an object instance is used as an attribute of another object:

Class foo {
Var $ bar;
Function setBar (& $ newBar ){
$ This-> bar = & newBar;
}
}

5. Role of reference
If the program is large, there are many variables that reference the same object, and you want to manually clear the object after it is used up, I suggest using the & method, then clear it in the form of $ var = null. in other cases, use the default php5 method. in addition, we recommend that you use the "&" method for transferring large arrays in php5 to save memory space.


6. cancel the reference.
When you unset a reference, you just disconnect the binding between the variable name and the variable content. This does not mean that the variable content is destroyed. For example:

$ A = 1;
$ B = & $;
Unset ($ );
?>

Not unset $ B, just $.


7. global reference
When a variable is declared with global $ var, a reference to the global variable is actually created. That is to say, it is the same as doing so:

$ Var = & $ GLOBALS ["var"];
?>

This means that, for example, unset $ var does not unset global variables.

If a function is declaredGlobalThe variable is assigned to a reference, which is only visible within the function. You can use$ GLOBALSArray to avoid this.

Example reference global variables in a function

$ Var1 = "Example variable ";
$ Var2 = "";

Function global_references ($ use_globals)
{
Global $ var1, $ var2;
If (! $ Use_globals ){
$ Var2 = & $ var1; // visible only inside the function
} Else {
$ GLOBALS ["var2"] = & $ var1; // visible also in global context
}
}

Global_references (false );
Echo "var2 is set to '$ var2' \ n"; // var2 is set''
Global_references (true );
Echo "var2 is set to '$ var2' \ n"; // var2 is set to 'example variable'
?>

Set Global $ var;As Yes $ Var = & $ GLOBALS ['var'];. To assign other references $ VarOnly the reference of local variables is changed.

8. $ this
In the method of an object, $ this is always a reference to the object that calls it.


// Next is an episode
In php, the address pointing (similar to pointer) function is not implemented by the user, but is implemented by the Zend core. in php, the reference uses the principle of "copy at Write, unless a write operation occurs, the variables or objects pointing to the same address will not be copied.

In layman's terms
1: if the following code exists:

$ A = "ABC ";
$ B = & $;
?>

In fact, both $ a and $ B point to the same memory address, not $ a and $ B occupy different memory.

2: Add the following code on the basis of the above code:

$ A = "EFG ";
?>

Because the memory data pointed to by $ a and $ B needs to be re-written, the Zend core automatically determines that $ B will generate a $ a data copy, apply for a new memory for storage

Php reference (that is, adding & symbol before variables, functions, and objects) is an advanced topic. it is important for new users to pay more attention to correct understanding of php references, it has a great impact on performance, and understanding errors may lead to program errors!

Many people misunderstand that the reference in php is the same as the pointer in C. in fact, this is not the case and it is quite different. In C language, pointers do not need to be explicitly declared in the array transfer process, but must be fixed using *. in php, pointers to addresses (similar to pointers) the function is not implemented by the user, but by the Zend core. the reference in php adopts the principle of "copy at Write Time", that is, unless a write operation occurs, variables or objects pointing to the same address are not copied, for example, the following code:

$ A = array ('A', 'C'... 'n ');
$ B = $;

If the program is only executed here, $ a and $ B are the same, but not like C, $ a and $ B occupy different memory space, it points to the same memory, which is the difference between php and c. it does not need to be written as $ B = & $ a to indicate that $ B points to $ a memory, zend has already helped you implement the reference, and zend will be very intelligent to help you determine when to handle this, and when not to handle this.

If you continue to write the following code later, add a function, pass parameters by referencing, and print the output array size.

Function printArray (& $ arr) // reference transfer
{
Print (count ($ arr ));

}
PrintArray ($ );

In the above code, we pass the $ a array into the printArray () function through reference. the zend Engine will think that printArray () may cause changes to $, at this time, a $ a data copy is automatically generated for $ B, and a memory is re-applied for storage. This is the "copy at write time" concept mentioned above.

If we change the above code to the following:

Function printArray ($ arr) // value transfer
{
Print (count ($ arr ));
}
PrintArray ($ );

The above code directly transmits the $ a value to printArray (). at this time, there is no reference transfer, so there is no copy at write time.

You can test the execution efficiency of the above two lines of code, for example, adding a loop 1000 times outside to check the running time, the result will let you know that improper use of the reference will lead to a performance reduction of more than 30%.

Self-understanding: values are irrelevant to parameters in the function, which is equivalent to local variables, while values are related to parameters in the function by reference, it is equivalent to a global variable. in terms of performance, the above analysis is sufficient ..