PHP: controlla se object/array è un riferimento

Question

Scusa se lo chiedo, è tardi e non riesco a immaginare un modo per farlo ... qualcuno può aiutarti?

$users = array(
    array(
     "name" => "John", 
     "age" => "20" 
    ), 
    array(
     "name" => "Betty", 
     "age" => "22" 
    ) 
); 

$room = array(
    "furniture" => array("table","bed","chair"), 
    "objects" => array("tv","radio","book","lamp"), 
    "users" => &$users 
); 

var_dump $ sala mostra:

... 
'users' => & 
... 

che significa "utenti" è un punto di riferimento.

vorrei fare qualcosa di simile:

foreach($room as $key => $val) { 
    if(is_reference($val)) unset($room[$key]); 
} 

L'obiettivo principale è quello di copiare l'array senza alcun riferimento.

È possibile?

Grazie.

Answer 1

È possibile verificare i riferimenti in un array multidimensionale facendo una copia della matrice, e quindi alterando e testare ogni voce, a sua volta:

$roomCopy = $room; 
foreach ($room as $key => $val) { 
    $roomCopy[$key]['_test'] = true; 
    if (isset($room[$key]['_test'])) { 
    // It's a reference 
    unset($room[$key]); 
    } 
} 
unset($roomCopy); 

con i tuoi dati di esempio, $room['furniture'] e $roomCopy['furniture'] sarà array separati (come $roomCopy è una copia di $room), quindi l'aggiunta di una nuova chiave a una non influirà sull'altra. Ma, $room['users'] e $roomCopy['users'] saranno riferimenti allo stesso array $users (poiché è il riferimento che viene copiato, non l'array), quindi quando aggiungiamo una chiave a $roomCopy['users'] è visibile in $room['users'].

Answer 2

forse qualcosa di ricorsivo.

function removeReferences($inbound) 
{ 
    foreach($inbound as $key => $context) 
    { 
     if(is_array($context)) 
     { 
      $inbound[$key] = removeReferences($context) 
     }elseif(is_object($context) && is_reference($context)) 
     { 
      unset($inbound[$key]); //Remove the entity from the array. 
     } 
    } 
    return $inbound; 
} 

Answer 3

Il meglio che posso gestire è un test di due variabili per determinare se uno è un riferimento all'altro:

$x = "something"; 
$y = &$x; 
$z = "something else"; 

function testReference(&$xVal,&$yVal) { 
    $temp = $xVal; 
    $xVal = "I am a reference"; 
    if ($yVal == "I am a reference") { echo "is reference<br />"; } else { echo "is not reference<br />"; } 
    $xVal = $temp; 
} 

testReference($x,$y); 
testReference($y,$x); 

testReference($x,$z); 
testReference($z,$x); 

testReference($y,$z); 
testReference($z,$y); 

ma dubito se si tratta di molto aiuto

metodo molto sporca (non ben testati):

$x = "something"; 
$y = &$x; 
$z = "something else"; 

function isReference(&$xVal) { 
    ob_start(); 
    debug_zval_dump(&$xVal); 
    $dump = ob_get_clean(); 
    preg_match('/refcount\((\d*)\)/',$dump,$matches); 
    if ($matches[1] > 4) { return true; } else { return false; } 
} 

var_dump(isReference($x)); 
var_dump(isReference($y)); 
var_dump(isReference($z)); 

Per utilizzare quest'ultimo metodo nel codice, è necessario eseguire alcune cosa come:

foreach($room as $key => $val) { 
    if(isReference($room[$key])) unset($room[$key]); 
} 

perché $ val è mai un punto di riferimento in quanto è una copia dell'elemento matrice originale; e l'utilizzo di & $ val rende sempre un riferimento

Answer 4

function var_reference_count(&$xVal) { 
    $ao = is_array($xVal)||is_object($xVal); 

    if($ao) { $temp= $xVal; $xVal=array(); } 

    ob_start();   
    debug_zval_dump(&$xVal); 
    $dump = ob_get_clean(); 

    if($ao) $xVal=$temp; 

    preg_match('/refcount\((\d*)\)/',$dump,$matches); 
    return $matches[1] - 3; 
} 
//------------------------------------------------------------------------------------------- 

Questo funziona con gli oggetti e gli array hudge.

Answer 5

se si vuole sbarazzarsi di elementi ricorsivi:

<?php 
$arr=(object)(NULL); $arr->a=3; $arr->b=&$arr; 
//$arr=array('a'=>3, 'b'=>&$arr); 
print_r($arr); 

$arr_clean=eval('return '.strtr(var_export($arr, true), array('stdClass::__set_state'=>'(object)')).';'); 
print_r($arr_clean); 
?> 

uscita:

stdClass Object ([a] => 3 [b] => stdClass Object *RECURSION*) 
stdClass Object ([a] => 3 [b] =>)