Vannak PHP változók által elfogadott érték alapján, vagy?

szavazat
174

Vannak PHP változók által elfogadott érték alapján, vagy?

A kérdést 03/08/2008 23:51
a forrás felhasználó
Más nyelveken...                            


14 válasz

szavazat
-6

Függ a változat, 4 érték szerint az 5-ös hivatkozunk.

Válaszolt 03/08/2008 23:52
a forrás felhasználó

szavazat
19

PHP változókat jelöli érték átadott funkciókat értéket, és amikor tartalmazó / képviselő objektumok átadása hivatkozás. Rá lehet kényszeríteni változókat átadni referenciaként használva &

Értékek tartoznak / referenciapélda:

$var1 = "test";
$var2 = $var1;
$var2 = "new test";
$var3 = &$var2;
$var3 = "final test";

print ("var1: $var1, var2: $var2, var3: $var3);

kiad

var1: teszt, var2: utolsó teszt, VAR3: végső vizsgálati

Által elfogadott érték / referencia exampe:

$var1 = "foo";
$var2 = "bar";

changeThem($var1, $var2);

print "var1: $var1, var2: $var2";

function changeThem($var1, &$var2){
    $var1 = "FOO";
    $var2 = "BAR";
}

kimenete:

var1: ize, var2 BAR

Objektum tulajdonságait átadása hivatkozás exampe:

class Foo{
    public $var1;

    function __construct(){
        $this->var1 = "foo";
    }

    public function printFoo(){
        print $this->var1;
    }
}


$foo = new Foo();

changeFoo($foo);

$foo->printFoo();

function changeFoo($foo){
    $foo->var1 = "FOO";
}

Kimenete:

FOO

(Ez utóbbi például lehetne jobb talán ...)

Válaszolt 03/08/2008 23:52
a forrás felhasználó

szavazat
215

Ez az érték szerinti PHP dokumentáció .

Alapértelmezésben a függvény paraméterei érték szerint adódnak át (vagyis ha az érték a függvényen belül megváltozik, de nem látszik kívül módosult a funkció). Ahhoz, hogy a függvény módosítsa az érveket, azokat referencia szerint kell átadni.

Ahhoz, hogy egy érv, hogy a függvény mindig telt referenciaként elé egy jel ( & ) az argumentum neve a függvény definícióját.

<?php
function add_some_extra(&$string)
{
    $string .= 'and something extra.';
}

$str = 'This is a string, ';
add_some_extra($str);
echo $str;    // outputs 'This is a string, and something extra.'
?>
Válaszolt 04/08/2008 00:06
a forrás felhasználó

szavazat
24

http://www.php.net/manual/en/migration5.oop.php

A PHP 5-ben létezik egy új Object Model. A PHP tárgyak teljesen át lett írva, ami jobb teljesítményt és funkciókat. A korábbi verziók PHP, tárgyak kezelték, mint a primitív típusok (például az egész és a húrok). A hátránya ennek a módszernek az volt, hogy szemantikailag az egész objektumot másolták, amikor egy változó jelöltek vagy átadva paraméterként eljárás. Az új megközelítés, tárgyak által hivatkozott nyél, és nem érték (lehet gondolni egy fogantyú, mint egy objektum azonosítója).

Válaszolt 04/08/2008 00:57
a forrás felhasználó

szavazat
4

Változókat tartalmazó primitív típusokat érték szerint adódnak át a PHP5. A változók tartalmazó tárgyak átadása hivatkozás. Van elég érdekes cikket a Linux Journal 2006, amely megemlíti ezen és más OO különbségek a 4. és 5..

http://www.linuxjournal.com/article/9170

Válaszolt 04/08/2008 01:05
a forrás felhasználó

szavazat
52

Úgy tűnik, egy csomó ember összezavarodik mellesleg objektumokat át, és az hogyan szerint átadott eszközökkel. Object változókat is elhaladt érték, annak csak az érték, amely telt PHP5 utalás fogantyút. Bizonyítékként:

<?php
class Holder {
    private $value;

    public function __construct($value) {
        $this->value = $value;
    }

    public function getValue() {
        return $this->value;
    }
}

function swap($x, $y) {
    $tmp = $x;
    $x = $y;
    $y = $tmp;
}

$a = new Holder('a');
$b = new Holder('b');
swap($a, $b);

echo $a->getValue() . ", " . $b->getValue() . "\n";

kimenetek:

a, b

Ahhoz, hogy át való hivatkozással azt jelenti, hogy módosítsa a változókat, amelyek láthatók a hívó. Amely egyértelműen a fenti kódot nem csinál. Meg kell változtatni a swap függvény a:

<?php
function swap(&$x, &$y) {
    $tmp = $x;
    $x = $y;
    $y = $tmp;
}

$a = new Holder('a');
$b = new Holder('b');
swap($a, $b);

echo $a->getValue() . ", " . $b->getValue() . "\n";

kimenetek:

b, a

annak érdekében, hogy adja át hivatkozunk.

Válaszolt 11/08/2008 03:09
a forrás felhasználó

szavazat
5

Meg tudod csinálni mindkét irányban.

hogy egy „&” jel elé, és a változó elhervadtok válik egy és ugyanaz, mint annak eredetét. azaz akkor át történő hivatkozással, ahelyett, hogy egy-egy példányt.

így

    $fred = 5;
    $larry = & $fred;
    $larry = 8;
    echo $fred;//this will output 8, as larry and fred are now the same reference.
Válaszolt 22/02/2009 10:17
a forrás felhasználó

szavazat
1

Tárgyak átadása hivatkozás a PHP 5 és érték a PHP 4-változók érték szerint adódnak át alapértelmezés szerint!

Olvassa el itt: http://www.webeks.net/programming/php/ampersand-operator-used-for-assigning-reference.html

Válaszolt 09/01/2010 17:34
a forrás felhasználó

szavazat
1
class Holder
{
    private $value;

    public function __construct( $value )
    {
        $this->value = $value;
    }

    public function getValue()
    {
        return $this->value;
    }

    public function setValue( $value )
    {
        return $this->value = $value;
    }
}

class Swap
{       
    public function SwapObjects( Holder $x, Holder $y )
    {
        $tmp = $x;

        $x = $y;

        $y = $tmp;
    }

    public function SwapValues( Holder $x, Holder $y )
    {
        $tmp = $x->getValue();

        $x->setValue($y->getValue());

        $y->setValue($tmp);
    }
}


$a1 = new Holder('a');

$b1 = new Holder('b');



$a2 = new Holder('a');

$b2 = new Holder('b');


Swap::SwapValues($a1, $b1);

Swap::SwapObjects($a2, $b2);



echo 'SwapValues: ' . $a2->getValue() . ", " . $b2->getValue() . "<br>";

echo 'SwapObjects: ' . $a1->getValue() . ", " . $b1->getValue() . "<br>";

Az attribútumok még módosítható, ha nem telt el referenciaként így vigyázz.

output:

SwapObjects: b, a SwapValues: a, b

Válaszolt 11/05/2010 16:51
a forrás felhasználó

szavazat
37

A PHP alapértelmezés tárgyak kerülnek átadásra referencia példányt egy új objektum.

Lásd ezt a példát .............

class X {
  var $abc = 10; 
}

class Y {

  var $abc = 20; 
  function changeValue($obj)
  {
   $obj->abc = 30;
  }
}

$x = new X();
$y = new Y();

echo $x->abc; //outputs 10
$y->changeValue($x);
echo $x->abc; //outputs 30

Most látni ezt ..............

class X {
  var $abc = 10; 
}

class Y {

  var $abc = 20; 
  function changeValue($obj)
  {
    $obj = new Y();
  }
}

$x = new X();
$y = new Y();

echo $x->abc; //outputs 10
$y->changeValue($x);
echo $x->abc; //outputs 10 not 20 same as java does.

Most látni ezt ..............

class X {
  var $abc = 10; 
}

class Y {

  var $abc = 20; 
  function changeValue(&$obj)
  {
    $obj = new Y();
  }
}

$x = new X();
$y = new Y();

echo $x->abc; //outputs 10
$y->changeValue($x);
echo $x->abc; //outputs 20 not possible in java.

remélem ezt megérted.

Válaszolt 14/03/2012 07:09
a forrás felhasználó

szavazat
7

Tudod ki a változót a függvény referenciaként. Ez a funkció képes lesz módosítani az eredeti változót.

Megadhatjuk a folyosón való hivatkozással a függvénydefinícióban

<?php
function changeValue(&$var)
{
    $var++;
}

$result=5;
changeValue($result);

echo $result; // $result is 6 here
?>
Válaszolt 21/12/2014 09:27
a forrás felhasználó

szavazat
0

Valójában mind a módszerek érvényes, de függ a requirement.Pass értékek referenciaként gyakran teszi a script lassú. Így a jobb, hogy adja át a változókat értéket tekintve idő a végrehajtás. Szintén a kódot áramlás jobban megfelel, ha át változók értékét.

Válaszolt 15/07/2015 11:25
a forrás felhasználó

szavazat
0

Használja ezt a funkciót, ha szeretné, hogy egyszerűen módosítja az eredeti változó és vissza újra ugyanarra a változó nevét az új értéket rendelve.

function add(&$var){ // The &amp; is before the argument $var
   $var++;
}
$a = 1;
$b = 10;
add($a);
echo "a is $a,";
add($b);
echo " a is $a, and b is $b"; // Note: $a and $b are NOT referenced
Válaszolt 31/03/2018 12:34
a forrás felhasználó

szavazat
0

Mindenki számára, aki átjön ez a jövőben szeretnék megosztani ezt a gem a PHP docs, írt egy névtelen felhasználó :

Úgy tűnik, hogy némi zavar van. A megkülönböztetése mutatók és referenciák nem különösebben hasznos. A viselkedés néhány „átfogó” példák már kifüggesztett magyarázható egyszerűbb egyesítő szempontjából. Hayley kód, például, csinál pontosan mit kell várni kellene. (Használata> = 5,3)

Első elv: pointer tárolja a memória cím eléréséhez egy tárgyat. Minden alkalommal egy objektum van rendelve, egy mutatót keletkezik. (Én még nem sokat foglalkoztunk túl mélyen a Zend motor még, de amennyire én látom, ez vonatkozik)

2. elv, és forrása a legtöbb zavart: Átadás egy változó függvényében történik meg alapértelmezésként mint érték át, azaz dolgozik egy másolatot. „De tárgyak átadása hivatkozás!” Általános tévhit mind itt, mind a Java világ. Soha nem mondtam, egy példányt, hogy mi. Az alapértelmezett elhaladó történik értéket. Mindig. Mi másolása és telt, azonban a mutatót. Amikor a „->”, akkor természetesen éri el ugyanazt a belső, mint az eredeti változót a hívó függvény. Csak a „=” csak játszani példányban.

3. elv: „&” automatikusan és véglegesen meghatározza egy változó nevét / pointer azonos memória cím, mint valami mást, amíg el függetleníteni őket. Helytálló használni a „alias” itt. Gondold azt, hogy csatlakozott a két mutató, a csípő, amíg erőszakkal elválasztani „kivetési ()”. Ez a funkció létezik mind ugyanabban a körét, és amikor egy érv vezetjük a funkciót. Gyakran a telt érv az úgynevezett „referencia”, mivel bizonyos közötti különbségtétel „elhaladó érték” és a „elhaladó referencia”, amelyek világosabb C és C ++.

Csak emlékezz arra: mutatókat tárgyak, nem tárgyak magukat, átadásra kerül funkciókat. Ezeket a mutatókat másolatai az eredeti, ha nem használja a „+” a paraméter lista, hogy ténylegesen át az eredeti. Csak akkor, ha beleveti magát a belső egy objektum az eredeti változik.

És itt van a példa nyújtanak:

<?php

//The two are meant to be the same
$a = "Clark Kent"; //a==Clark Kent
$b = &$a; //The two will now share the same fate.

$b="Superman"; // $a=="Superman" too.
echo $a;
echo $a="Clark Kent"; // $b=="Clark Kent" too.
unset($b); // $b divorced from $a
$b="Bizarro";
echo $a; // $a=="Clark Kent" still, since $b is a free agent pointer now.

//The two are NOT meant to be the same.
$c="King";
$d="Pretender to the Throne";
echo $c."\n"; // $c=="King"
echo $d."\n"; // $d=="Pretender to the Throne"
swapByValue($c, $d);
echo $c."\n"; // $c=="King"
echo $d."\n"; // $d=="Pretender to the Throne"
swapByRef($c, $d);
echo $c."\n"; // $c=="Pretender to the Throne"
echo $d."\n"; // $d=="King"

function swapByValue($x, $y){
$temp=$x;
$x=$y;
$y=$temp;
//All this beautiful work will disappear
//because it was done on COPIES of pointers.
//The originals pointers still point as they did.
}

function swapByRef(&$x, &$y){
$temp=$x;
$x=$y;
$y=$temp;
//Note the parameter list: now we switched 'em REAL good.
}

?>

Írtam egy kiterjedt, részletes blogbejegyzést erről a témáról a Java , de azt hiszem, az is lehetséges, hogy a PHP, C ++, és bármely más nyelvű, ahol az emberek úgy tűnik, hogy zavaros érték szerint átadott vs. szerint átadott.

Nyilvánvaló, PHP, mint a C ++, a nyelv, amely nem támogatja szerint átadott. Alapértelmezésben tárgyak érték szerint adódnak át. Amikor dolgozik változók tárgyak tárolására, ez segít, hogy ezeket a változókat mutatók (mert ez alapvetően, amit ők, a szerelési szinten). Ha át egy mutatót értéket, akkor is „nyom” a mutatót, és módosítsa a tulajdonságait a tárgy mutatott. Amit nem tehetünk, hogy azt pont egy másik objektumot. Csak akkor, ha kifejezetten kijelentik paraméterként vezetjük referenciaként leszel képes erre.

Válaszolt 05/02/2020 22:22
a forrás felhasználó

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more