Как составить ссылку php

/* Присвоение массивов */

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

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!

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 == $an";
echo "$arr3[0] == {$arr3[0]}n";
$arr4 = $arr3;
$arr4[0]++;
echo "nafter:n";
echo "$a == $an";
echo "$arr3[0] == {$arr3[0]}n";
echo "$arr4[0] == {$arr4[0]}n";
?>

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)

<?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 $barn");

print( $bar );

print(

"n");

print("Now $baz is referenced to $bar and printing $bar and $bazn");

$baz =& $bar;

print( $bar );

print(

"n");

print("Now Creating MasterOne and Two and passing $bar to both constructorsn");

$m1 = new MasterOne( $bar );

$m2 = new MasterTwo( $bar );

print( $m1 );

print( $m2 );

print(

"n");

print("Now changing value of $bar and printing $bar and $bazn");

$bar->setName('baz');

print( $bar );

print( $baz );

print(

"n");

print("Now printing again MasterOne and Twon");

print( $m1 );

print( $m2 );

print(

"n");

print("Now changing MasterTwo's foo name and printing again MasterOne and Twon");

$m2->setFooName( 'MasterTwo's Foo' );

print( $m1 );

print( $m2 );

print(

"Also printing $bar and $bazn");

print( $bar );

print( $baz );

?>

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.

<?php $arr = array(1); ?>
$arr here contains a reference to which the array is located.
Writing :
<?php echo $arr[0]; ?>
dereferences the array to access its very first element.

Now something that you should also be aware of  (even you are not new to programming languages) is that PHP use references to contains the different values of an array. And that makes sense because the type of the elements of a PHP array can be different.

Consider the following example :

<?php

$arr

= array(1, 'test');$point_to_test =& $arr[1];$new_ref = 'new';$arr[1] =& $new_ref;

echo

$arr[1]; // echo 'new';
echo $point_to_test; // echo 'test' ! (still pointed somewhere in the memory)?>

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

<?php
$a1 = array('a'=>'a');
$a2 = array('a'=>'b');

foreach (

$a1 as $k=>&$v)
$v = 'x';

echo

$a1['a']; // will echo xunset($GLOBALS['v']);

foreach (

$a2 as $k=>$v)
{}

echo

$a1['a']; // will echo x?>

for example
<?php
foreach($var as &$value)
{
...
}
unset($value);
?>

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

?>

Here we are working with values so working on a reference updates original variable too;

$a = 1;
$c = 22;

$b = & $a;
echo "$a, $b"; //Output: 1, 1

$b++;
echo "$a, $b";//Output: 2, 2 both values are updated

$b = 10;
echo "$a, $b";//Output: 10, 10 both values are updated

$b =$c; //This assigns value 2 to $b which also updates $a
echo "$a, $b";//Output: 22, 22

But, if instead of $b=$c you do
$b = &$c; //Only value of $b is updated, $a still points to 10, $b serves now reference to variable $c

echo "$a, $b"//Output: 10, 22

<?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"
?>

Example:
<?php
function foo(&$bar) {
    $bar = "hellon";
}foo($unset);
echo($unset);
foo($set = "setn");
echo($set);?>

Output:
hello
set

It baffles me, but there you have it.

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

$b = 2;
$a =& $b;
$c = $a;
echo $c;

// Then... $c = 2

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

<?php
$a1 = array('a'=>'a');
$a2 = array('a'=>'b');

foreach (

$a1 as $k=>&$v)
$v = 'x';

echo

$a1['a']; // will echo xforeach ($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)

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

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.

<?php
class reftest
{
    public $a = 1;
    public $c = 1;

    public function

reftest1()
    {
        $b =& $this->a;
        $b++;
    }

    public function

reftest2()
    {
        $d =& $this->c;
        $d++;
    }

        public function

reftest()
    {
       echo "REFTEST() called here!n";
    }
}$reference = new reftest();
/*You must notice the above will also implicitly call reference->reftest()*/$reference->reftest1();
$reference->reftest2();

echo

$reference->a."n"; //Echoes 2, not 3 as previously noticed.
echo $reference->c."n"; //Echoes 2.
?>

The above outputs:

REFTEST() called here!
2
2

Notice that reftest() appears to be called (though no explicit call to it was made)!

<?php
$a = 0;$b =& $a;
$a =& $b;$a = 5;
echo $a . ', ' . $b;
//ouputs: 5,5echo ' | ';$b = 6;
echo $a . ',' . $b;
//outputs: 6,6echo ' | ';
unset( $a );
echo $a . ', ' . $b;//outputs: , 6 class Product {

    public

$id;
    private $productid;

    public function

__construct( $id = null ) {
        $this->id =& $this->productid;
        $this->productid =& $this->id;
        $this->id = $id;
    }

    public function

getProductId() {
        return $this->productid;
    }

}

echo

' | ';$Product = new Product( 1 );
echo $Product->id . ', ' . $Product->getProductId();
//outputs 1, 1
$Product->id = 2;
echo ' | ';
echo $Product->id . ', ' . $Product->getProductId();
//outputs 2, 2
$Product->id = null;
echo ' | ';
echo $Product->id . ', ' . $Product->getProductId();
//outouts ,