Php reference value transfer learning Notes

In php, you only need to add & amp; before the original object to assign values by reference, $ a & amp; $ B; in fact, the reference in php is that two variables with different names point to the same value. Reference what is in PH

In php, you only need to add one & before the original object to assign values by reference, $ a = & $ B; in fact, the reference in php is that two variables with different names point to the same value.

Reference

Referencing in PHP means accessing the same variable content with different names. This is not like the pointer of C. Instead, the reference is the alias of the symbol table. Note that in PHP, the variable name and variable content are different, so the same content can have different names. The closest analogy is the Unix file name and the file itself-the variable name is a directory entry, while the variable content is the file itself. A reference can be considered as a hardlink in a Unix file system.

I. variable reference,The code is as follows:

2. $ A = 100;
3. $ B = & $;
4. Echo $ B; // output 100
5. Echo $ a; // output 100 here, indicating that the values of $ a and $ B are both one hundred.
6. $ B = 200;
7. Echo $ a; // output 200
8. Echo $ B; // output 200 here, which means they use the same address. Change one, and the other will also change.
9. ?>

2. reference and pass the value in the function,The code is as follows:

2. Function main ($ a, $ B ){
3. $ B = $ a + 100;
4. Return $ B;
5. }
6. Main (55, & $ B); // Here $ B is actually passing its memory address to the $ B parameter in the main function, the value of $ B is changed by changing the parameter $ B.
7. Echo $ B; // The output is 155,
8. ?>

3. pass the reference value of the object,The code is as follows:

2. Class club {
3. Var $ name = "real madrid ";
4. }
5. $ B = new club;
6. $ C = $ B;
7. Echo $ B-> name; // output real madrid
8. Echo $ c-> name; // output real madrid
9. $ B-> name = "ronaldo ";
10. Echo $ c-> name; // output ronaldo
11. ?>

Cancel reference:When you unset a reference, you just disconnect the binding between the variable name and the variable content, which does not mean that the variable content is destroyed, for example, the following code:

2. $ A = 'Ronaldo'
3. $ B = & $;
4. Unset ($ );
5. ?>

It won't unset $ B, just $ a, for example, reference transfer, test1.php, the code is as follows:

2. /**
3. * Reference transfer
4. The following content can be passed through reference:
5. Variable, such as foo ($)
6. New statement, such as foo (new foobar ())
7. Reference returned from the function, for example:
9. */
10. Function foo (& $ var)
11. {
12. $ Var ++;
13. }
15. $ A = 5;
16. // Valid
17. Foo ($ );
18. Foo (new stdClass ());
19. // Illegal use
20. Function bar () // Note the missing &
21. {
22. $ A = 5;
23. Return $;
24. }
25. Foo (bar (); // fatal error caused by PHP 5.0.5
26. Foo ($ a = 5) // expression, not a variable
27. Foo (5) // cause a fatal error
29. ?>

The code for test2.php is as follows:

2. Function test (& $)
3. {
4. $ A = $ a + 100;
5. }
6. $ B = 1;
7. Echo $ B; // output 1
8. 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.
10. Echo"
    ";
12. Echo $ B; // output 101
14. /*****************************
15. *
16. * Note that the parameter after call_user_func_array is required &
17. *
18. *****************************/
20. // Do not add the & symbol before $ B in the above "test ($ B);", but in the function "call_user_func_array", to reference the parameter passing, the & symbol is required, as shown in the following code:
22. Function a (& $ B ){
23. $ B ++;
24. }
25. $ C = 0;
26. Call_user_func_array ('A', array (& $ c ));
27. Echo $ c;
28. // Output 1
29. ?>

Reference return

When you want to use a function to find the variable to which the reference should be bound, do not use the return reference to increase performance. the engine is smart enough to optimize it, A reference is returned only when there are reasonable technical reasons! To return a reference, use the following syntax:

2. Function & test ()
3. {
4. Static $ B = 0; // declare a static variable
5. $ B = $ B + 1;
6. Echo $ B;
7. Return $ B;
8. }
10. $ A = test (); // This statement outputs the value of $ B as 1.
11. $ A = 5;
12. $ A = test (); // This statement outputs the value of $ B to 2.
14. $ A = & test (); // This statement outputs the value of $ B as 3. here, the memory address of the $ B variable in return $ B is pointed to the same place as the memory address of the $ a variable.
15. $ A = 5; // The value of the $ B variable in return $ B has been changed.
17. $ A = test (); // This statement outputs a value of 6 for $ B.
18. /**
19. ?>

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 it for half a day

The example above is as follows: $ a = test () is used to call a function. it only assigns the value of the function to $, $ a does not affect $ B in the function, but calls the function in the $ a = & test () method, the function is to direct the memory address of the $ B variable in return $ B to the memory address of the $ a variable, that is, the equivalent effect ($ a = & $ B;) is generated. Therefore, the value of $ a is changed, and the value of $ B is also changed.

$ 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.

An interesting example is shown on oschina. the code is as follows:

2. $ A = array ('Abe ', 'Ben', 'Cam ');
3. Foreach ($ a as $ k ==>&$ n)
4. $ N = strtoupper ($ n );
5. Foreach ($ a as $ k =>$ n) // notice NO reference here!
6. Echo "$ nn ";
7. Print_r ($ );
8. ?>
9. Will result in:
10.  
11. ABE
12. BEN
13. BEN
14. Array
15. (
16. [0] => ABE
17. [1] => BEN
18. [2] => BEN
19. )
20. // Explanation: the loop in the second foreach is as follows:
21. Array
22. (
23. [0] => ABE
24. [1] => BEN
25. [2] => ABE
26. )
27. Array
28. (
29. [0] => ABE
30. [1] => BEN
31. [2] => BEN
32. )
33. Array
34. (
35. [0] => ABE
36. [1] => BEN
37. [2] => BEN
38. )

Because there is no unset ($ n), it always points to the last element of the array. the first loop in the second foreach changes $ n, that is, $ a [2] to ABE, the second cycle is changed to BEN, and the third cycle is BEN.