Perché il Refcount è 2 non 1?

Question

$var = 1; 
    debug_zval_dump($var); 

uscita:

long(1) refcount(2) 


    $var = 1; 
    $var_dup = &$var; 
    debug_zval_dump($var);exit; 

uscita:

long(1) refcount(1) 

UPDATE

Molto delusi alla risposta ...

Answer 1

vuoto debug_zval_dump (misto $ variabile);

---

Codice:

$var = 1;    # $var's Refcount = 1 
debug_zval_dump($var); # $var is passed by refrence intarlly. 

uscita:

long(1) refcount(2) 

Spiegazione: Come refcount $ di var è 1, PHP ottimizza questo e gestisce la memoria direttamente al posto di fare una copia perché lì non c'è possibilità di contaminare altri riferimenti. PHP passa internamente $ var per riferimento, in modo che possa modificare direttamente la memoria se ne ha bisogno. Il secondo riferimento viene creato quando si chiama effettivamente debug_zval_dump().

Un conteggio di 2, qui, è estremamente non ovvio. Quindi cosa sta succedendo?

Quando una variabile ha un riferimento singolo (come faceva $ var prima che fosse usata come argomento per debug_zval_dump()), il motore di PHP ottimizza il modo in cui viene passato a una funzione. Internamente, PHP considera $ var come un riferimento (in quanto il refcount viene aumentato per lo scopo di questa funzione), con l'avvertenza che se il riferimento passato viene scritto, una copia viene creata, ma solo al momento della scrittura . Questo è noto come "copia su scrittura".

Quindi, se debug_zval_dump() è riuscito a scrivere sul suo unico parametro (e non lo fa), allora una copia sarebbe fatta. Fino ad allora, il parametro rimane un riferimento, facendo in modo che il conto venga incrementato a 2 per l'ambito della chiamata di funzione.

---

Codice:

$var = 1;    # $var's Refcount = 1 
$var_dup = &$var;  # $var's Refcount = 2 
debug_zval_dump($var); # A copy is passed as $var's refcount is 2. 

uscita:

long(1) refcount(1) 

Spiegazione: Questa volta una copia di $ var è stato fatto quando viene chiamata la funzione. Questo perché $ var è referenziato due volte e PHP non vuole contaminare nessun altro riferimento, quindi fa una copia di $ var per il suo funzionamento. Dato che ora c'è un pezzo di memoria separato che viene usato solo per lo scopo della funzione chiamata, ha solo una rifrazione, è se stesso. Quindi per lo scopo della funzione il conto della copia è 1 (è auto).

Answer 2

Proverò a dare un po 'più di luce alla funzione debug_zval_dump() e al modo in cui elabori le tue variabili.Non uccidermi se sbaglio:) ...

$var = 1; 
    debug_zval_dump($var); 

penso che la funzione di debug conta il $var refcount (1) e il 1 refcount (2) dal 1 è il valore di $var.
Se lo guardi logicamente, lo stai dicendo in realtà.

1 = 1; 
    debug_zval_dump(1); 

Seconda parte:

$var = 1; 
$var_dup = &$var; 
debug_zval_dump($var);exit; 

Quello che vedete qui è che si imposta $var-$var_dup ma sta tenendo il suo valore. Il valore di $var è 1 perché è stato "collegato" a $var_dup.

$var = 2; 
$var_dup = &$var; //or $var = &$var_dup; (doesn't matter which one) 
$var = 3; 
debug_zval_dump($var_dup);exit; 

Questo dà long(3) refcount(1) ... Perché è refcount 1? Come puoi vedere il valore di $ var_dup non è mai stato assegnato a 3, dovrebbe essere 2 giusto? No, non dovrebbe perché lo tenete aggiornato con & $ var. Ciò significa che quando hai superato $var = 4 tra $var = 3 e debug_zval_dump($var_dup);exit; il valore di $ var_dup verrà aggiornato automaticamente perché li hai collegati, rendendolo un 1 refcount.

Poi c'è quest'altro evento:

$var = 2; 
$var_dup = $var; 
$var = 4; 
debug_zval_dump($var_dup);exit; 

L'uscita di questo è: long(2) refcount(2). Come puoi vedere il valore di $ var_dup è corretto. $ var era 2, il valore è stato passato a $ var_dup e ne è rimasto fedele. Il Refcount è 2 perché conta $var = 4; e $var_dup = $var;. Quando rimuoviamo il $var = 4; otteniamo questo:

$var = 2; 
$var_dup = $var; 
debug_zval_dump($var_dup);exit; 

L'uscita di questo è: long(2) refcount(3). Ora la funzione di debug conta quanto segue: $var_dup (1), =$var (2) (poiché $ var_dup era originato da $ var) e $var (= 2;) (3).

Spero che tu capisca cosa intendo. Secondo me, questo è più matematica che programmazione, quindi questa potrebbe essere la ragione per cui è una funzione difficile da capire.

E ancora, se mi sbaglio, non uccidermi:) ...
Saluti,
Mixxiphoid

responsabilità
non so quale sia lo scopo di questa funzione è . Non ne ho mai sentito parlare fino ad oggi. Quindi non sono responsabile per l'uso inappropriato :).

Answer 3

Un conteggio di 2, qui, è estremamente non ovvio. Soprattutto considerando gli esempi di cui sopra. Quindi cosa sta succedendo?

Quando una variabile ha un riferimento singolo (come ha fatto $ var1 prima che fosse usato come argomento per debug_zval_dump()), il motore di PHP ottimizza il modo in cui viene passato a una funzione. Internamente, PHP considera $ var1 come un riferimento (in quanto il refcount viene aumentato per lo scopo di questa funzione), con l'avvertenza che se il riferimento passato viene scritto, una copia viene fatta, ma solo al momento della scrittura . Questo è noto come "copia su scrittura"."

Quindi, se debug_zval_dump() è riuscito a scrivere sul suo unico parametro (e non lo fa), allora verrà eseguita una copia. Fino ad allora, il parametro rimane un riferimento, causando l'incremento del conto in 2 per l'ambito della chiamata di funzione

- Credits andare al manuale php Leggi tutta la descrizione che viene fornito con la funzione e si dovrebbe aver persino ha chiesto che

--- Edit:. .. Woops, dovrei leggere altri commenti prima di rispondere: D Comunque, questa è la risposta alla domanda come accennato prima.

Answer 4

Penso che la documentazione relativa a questo metodo lo spiega nella sezione "Attenzione il conte Rif":

debug_zval_dump

Answer 5

Codice:

$var = 1; 
debug_zval_dump($var); 

uscita: long(1) refcount(2)

Spiegazione: Quando una variabile ha un riferimento singolo, come ha fatto $ var prima che fosse usato come argomento per debug_zval_dump(), il motore di PHP ottimizza il modo in cui viene passato a una funzione. PHP, fondamentalmente fa un puntatore alla variabile e internamente, PHP considera $ var come un riferimento e quindi il suo conto è aumentato per lo scopo di questa funzione.

Codice:

$var = 1; 
$var_dup = &$var; 
debug_zval_dump($var);exit; 

uscita: long(1) refcount(1)

Spiegazione: Qui la variabile $ var è copyied on write, rendendo tutta la nuova istanza seprate di quella varable e perché debug_zval_dump a che fare con una copia completamente nuova di $ var, non un riferimento, il suo conteggio è 1. La copia viene quindi distrutta una volta eseguita la funzione.

Spero che lo risolva.