Wykonałem krótkie testy porównujące szybkości działania funkcji z parametrem przekazanym przez wartość, referencję i obiekt. Musze przyznać, że wyniki troche mnie zaskoczyły.

Środowisko:
PHP 5.2.1RC2
Apache 2.2.4

Przykład 1

[PHP] pobierz, plaintext 
<?php
class C1
{
	public $data=array();
 
	public function UstawZTablicy ($tab)
	{
		foreach ($tab as $key => $value)
		{
			$this->data[$key] = $value;
		}
	}
	public function ObjMet()
	{
		echo $this->data['pole8455'];
	}
}
 
function Tab ($tab)
{
	echo $tab['pole8455'];
}
 
function TabRef (&$tab)
{
	echo $tab['pole8455'];
}
 
function ObjFunc ($obj)
{
	echo $obj->pole8455;
}
 
$tab = array();
for ($ptl=1; $ptl<10000; $ptl++)
{
	$tab['pole'.$ptl] = $ptl;
}
$obj = new C1();
$obj->UstawZTablicy($tab);
 
$timeTests = array();
 
$timeTests[0]['czas'] = microtime(true);
$timeTests[0]['znak'] = 'start';
 
//test funkcji z parametrem wartosciowym
for ($ptl=0; $ptl<4000; $ptl++)
{
	Tab($tab);
}
 
$timeTests[4]['czas'] = microtime(true);
$timeTests[4]['znak'] = 'Tab';
 
//test funkcji z przekazaniem jej parametru: obiekt
for ($ptl=0; $ptl<4000; $ptl++)
{
	ObjFunc($obj);
}
 
$timeTests[1]['czas'] = microtime(true);
$timeTests[1]['znak'] = 'ObjFunc';
 
//test metody obiektu
for ($ptl=0; $ptl<4000; $ptl++)
{
	$obj->ObjMet();
}
 
$timeTests[2]['czas'] = microtime(true);
$timeTests[2]['znak'] = 'ObjMet';
 
//test funkcji z parametrem referencyjnym
for ($ptl=0; $ptl<4000; $ptl++)
{
	TabRef($tab);
}
 
$timeTests[3]['czas'] = microtime(true);
$timeTests[3]['znak'] = 'TabRef';
 
 
echo '<br />';
$timePrev = 0;
foreach ($timeTests as $time)
{
	echo $time['znak'].': '.($time['czas'] - $timePrev).'<br />';
	$timePrev = $time['czas'];
}
?>
[PHP] pobierz, plaintext 

Średnie wyniki z 10 pomiarów:
ObjFunc: 0,03630816936492920
ObjMet: 0,01625814437866210
Tab: 0,02549026012420650
TabRef: 0,01591291427612310

Opis wyników
ObjFunc jest 2x wolniejsze niż wywołanie metody obiektu ObjMet
Tab jest 1.6x wolniejsze od funkcji z parametrem referencyjnym!!!

Wnioski
1. Okazuje się, że wbrew dokumentacji PHP, przekazanie parametu przez referencję jest dużo szybsze niż przekazanie wartości. Należy się domyślać, że dotyczy to raczej zmiennych o dość rozmiarach.
2. Wywołanie metody obiektu jest znacznie szybsze niż (trochę dziwna) funkcja.

Drugi test jest jeszcze ciekawszy!
Tym razem modyfikujemy zmienną przekazaną do funkcji/metody.

Przykład 2

[PHP] pobierz, plaintext 
<?php
class C1
{
	public $data=array();
 
	public function UstawZTablicy ($tab)
	{
		foreach ($tab as $key => $value)
		{
			$this->data[$key] = $value;
		}
	}
	public function ObjMet()
	{
		$this->data['pole8455'] = 34534;
	}
}
 
function Tab ($tab)
{
	$tab['pole8455'] = 34534;
}
 
function TabRef (&$tab)
{
	$tab['pole8455'] = 34534;
}
 
function ObjFunc ($obj)
{
	$obj->pole8455 = 34534;
}
 
$tab = array();
for ($ptl=1; $ptl<10000; $ptl++)
{
	$tab['pole'.$ptl] = $ptl;
}
$obj = new C1();
$obj->UstawZTablicy($tab);
 
$timeTests = array();
 
$timeTests[0]['czas'] = microtime(true);
$timeTests[0]['znak'] = 'start';
 
//test funkcji z parametrem wartosciowym
for ($ptl=0; $ptl<4000; $ptl++)
{
	Tab($tab);
}
 
$timeTests[4]['czas'] = microtime(true);
$timeTests[4]['znak'] = 'Tab';
 
//test funkcji z przekazaniem jej parametru: obiekt
for ($ptl=0; $ptl<4000; $ptl++)
{
	ObjFunc($obj);
}
 
$timeTests[1]['czas'] = microtime(true);
$timeTests[1]['znak'] = 'ObjFunc';
 
//test metody obiektu
for ($ptl=0; $ptl<4000; $ptl++)
{
	$obj->ObjMet();
}
 
$timeTests[2]['czas'] = microtime(true);
$timeTests[2]['znak'] = 'ObjMet';
 
//test funkcji z parametrem referencyjnym
for ($ptl=0; $ptl<4000; $ptl++)
{
	TabRef($tab);
}
 
$timeTests[3]['czas'] = microtime(true);
$timeTests[3]['znak'] = 'TabRef';
 
 
echo '<br />';
$timePrev = 0;
foreach ($timeTests as $time)
{
	echo $time['znak'].': ';
	echo ($time['czas'] - $timePrev).'<br />';
	$timePrev = $time['czas'];
}
?>
[PHP] pobierz, plaintext 

Średnie wyniki z 10 pomiarów:
ObjFunc: 0,00535948276519776
ObjMet: 0,00558812618255616
Tab: 12,12336094379430000
TabRef: 0,00451698303222655

Opis wyników
ObjFunc i ObjMet mają bardzo zbliżone wyniki.
Zaskakuje natomiast funkcja Tab z wynikiem ponad 2000x gorszym od innych sposobów!!!! w tym od funkcji z parametrem referencyjnym.

Wnioski
1. Porównując wyniki z Przykładu 1 i 2 widzimy, że PHP wykonując funkcję z parametrem wartościowym nie tworzy kopii tego paremetru za każdym razem. Taka kopia generowana jest tylko wtedy, gdy zmienna ulega zmianie wewnątrz funkcji!
2. Przekazywanie do funkcji dużych zmiennych przez wartość jest wolniejsze niż przekazanie ich przez referencję, nawet jeśli zmienna nie ulega modyfikacji wewnątrz funkcji!
3. Wywoływanie i działanie fukcji/metod na obiektach może być nieco wolniejsze od funkcji na tablicach, ale różnica nie jest duża.

Jaka wersja PHP?

Teraz wykonamy wersję testu 1, ale tym razem z 10x mniejszą zmienną.

Przykład 3

[PHP] pobierz, plaintext 
<?php
class C1
{
	public $data=array();
 
	public function UstawZTablicy ($tab)
	{
		foreach ($tab as $key => $value)
		{
			$this->data[$key] = $value;
		}
	}
	public function ObjMet()
	{
		echo $this->data['pole845'];
	}
}
 
function Tab ($tab)
{
	echo $tab['pole845'];
}
 
function TabRef (&$tab)
{
	echo $tab['pole845'] = 34534;
}
 
function ObjFunc ($obj)
{
	echo $obj->pole845;
}
 
$tab = array();
for ($ptl=1; $ptl<1000; $ptl++)
{
	$tab['pole'.$ptl] = $ptl;
}
$obj = new C1();
$obj->UstawZTablicy($tab);
 
$timeTests = array();
 
$timeTests[0]['czas'] = microtime(true);
$timeTests[0]['znak'] = 'start';
 
//test funkcji z parametrem wartosciowym
for ($ptl=0; $ptl<4000; $ptl++)
{
	Tab($tab);
}
 
$timeTests[4]['czas'] = microtime(true);
$timeTests[4]['znak'] = 'Tab';
 
//test funkcji z przekazaniem jej parametru: obiekt
for ($ptl=0; $ptl<4000; $ptl++)
{
	ObjFunc($obj);
}
 
$timeTests[1]['czas'] = microtime(true);
$timeTests[1]['znak'] = 'ObjFunc';
 
//test metody obiektu
for ($ptl=0; $ptl<4000; $ptl++)
{
	$obj->ObjMet();
}
 
$timeTests[2]['czas'] = microtime(true);
$timeTests[2]['znak'] = 'ObjMet';
 
//test funkcji z parametrem referencyjnym
for ($ptl=0; $ptl<4000; $ptl++)
{
	TabRef($tab);
}
 
$timeTests[3]['czas'] = microtime(true);
$timeTests[3]['znak'] = 'TabRef';
 
 
echo '<br />';
$timePrev = 0;
foreach ($timeTests as $time)
{
	echo $time['znak'].': ';
	echo ($time['czas'] - $timePrev).'<br />';
	$timePrev = $time['czas'];
}
?>
[PHP] pobierz, plaintext 

Średnie wyniki z 10 pomiarów:
ObjFunc: 0,04068577289581310
ObjMet: 0,03742690086364740
Tab: 0,01934800148010270
TabRef: 0,03726780414581290

Opis wyników
Tab jest 2x szybsze od TabRef

Wnioski
W porównaniu do przykładu 1, widzimy dużo lepsze wyniki funkcji Tab. Dlatego łatwo można wyciągnąć wniosek, że funkcja z parametrem wartościowym jest jednak szybsza od fukcji z parametrem referencyjnym. Przekazanie tablicy przez referencję jest porównywalnie szybkie jak przekazanie obiektu lub wywołanie metody obiektu.

I ostatni test
Tym razem zmiejszyłem rozmiar zmiennej do 10 pól integer (z 10000 w pierwszym teście) i wykonałem funkcje modyfikujące przekazaną zmienną, tym razem równierz funckaj Tab, która nieznacznie zmieniłem, aby zwracała zmienną o nowej wartości.

Przykład 4

[PHP] pobierz, plaintext 
<?php
class C1
{
	public $data=array();
 
	public function UstawZTablicy ($tab)
	{
		foreach ($tab as $key => $value)
		{
			$this->data[$key] = $value;
		}
	}
	public function ObjMet()
	{
		$this->data['pole8'] = 34534;
	}
}
 
function Tab ($tab)
{
	$tab['pole8'] = 34534;
	return $tab;
}
 
function TabRef (&$tab)
{
	$tab['pole8'] = 34534;
}
 
function ObjFunc ($obj)
{
	$obj->pole8 = 34534;
}
 
$tab = array();
for ($ptl=1; $ptl<10; $ptl++)
{
	$tab['pole'.$ptl] = $ptl;
}
$obj = new C1();
$obj->UstawZTablicy($tab);
 
$timeTests = array();
 
$timeTests[0]['czas'] = microtime(true);
$timeTests[0]['znak'] = 'start';
 
//test funkcji z parametrem wartosciowym
for ($ptl=0; $ptl<4000; $ptl++)
{
	$tab = Tab($tab);
}
 
$timeTests[4]['czas'] = microtime(true);
$timeTests[4]['znak'] = 'Tab';
 
//test funkcji z przekazaniem jej parametru: obiekt
for ($ptl=0; $ptl<4000; $ptl++)
{
	ObjFunc($obj);
}
 
$timeTests[1]['czas'] = microtime(true);
$timeTests[1]['znak'] = 'ObjFunc';
 
//test metody obiektu
for ($ptl=0; $ptl<4000; $ptl++)
{
	$obj->ObjMet();
}
 
$timeTests[2]['czas'] = microtime(true);
$timeTests[2]['znak'] = 'ObjMet';
 
//test funkcji z parametrem referencyjnym
for ($ptl=0; $ptl<4000; $ptl++)
{
	TabRef($tab);
}
 
$timeTests[3]['czas'] = microtime(true);
$timeTests[3]['znak'] = 'TabRef';
 
 
echo '<br />';
$timePrev = 0;
foreach ($timeTests as $time)
{
	echo $time['znak'].': ';
	echo ($time['czas'] - $timePrev).'<br />';
	$timePrev = $time['czas'];
}
?>
[PHP] pobierz, plaintext 

Średnie wyniki z 10 pomiarów:
ObjFunc: 0,01284565925598150
ObjMet: 0,01222741603851320
Tab: 0,03661031723022470
TabRef: 0,01396517753601080

Opis wyników
Tab jest (tylko) 2.6x wolniejsza od TabRef.

Wnioski
1. Jeżeli w wyniku działania funkcji zmienna ma ulec zmianie, to przekazanie do funkcji nawet stosunkowo małych zmiennych przez referencję jest korzystniejsze niż przekaznie ich przez wartość.
2. Dlatego może się opłacać zamienieie tablicy na obiekt, albo wogle korzystanie z samych obiektów.

wydaje mi się że w testach powinieneś uwzględnić czas tworzenia zmiennych/tablic/obiektów - bo co z tego że operacja jest szybsza skoro operacja plus utworzenie obiektu/tablicy jest już znacznie wolniejsza.

W testach chodziło o porównanie parametrów wartościowych i referencyjnych. Obiekty dodałem tylko dla porównania, czy ich stosowanie różni się od stosowania innych typów referencyjnych. Nie miałem zamiaru udowadniać wyższości programowania obiektowego czy strukturalnego.

Ale zawsze możesz na podstawie załączonego kodu wykonać własne testy i przedstawić wyniki.

nie zrozum mnie źle - nie chcę udowadniać wyższości jednego nad drugim. Twierdze tylko że nieuwzględnienie w testach czasu potrzebnego na zbudowanie danej zmiennej (czy to tablicy czy obiektu) nie jest miarodajne. Ogólni test bardzo fajny - wyniki faktycznie nieco zasakujące.

Test nie związany z tematem, ale mam nadzieję zaspokajający ciekawość devnula...

Tworzymy 1000 tablic, każda po 10 pól i 1000 obiektów każdy po 10 pól:

[PHP] pobierz, plaintext 
<?php
class C2
{
	public $data = array();
}
 
$timeTests = array();
 
$timeTests[0]['czas'] = microtime(true);
$timeTests[0]['znak'] = 'start';
 
for ($ptl=0; $ptl<1000; $ptl++)
{
	${'tab'.$ptl} = array();
	for ($pole=0; $pole<10; $pole++)
	{
		${'tab'.$ptl}[$pole] = $pole;
	}
}
 
$timeTests[1]['czas'] = microtime(true);
$timeTests[1]['znak'] = 'Tabele';
 
for ($ptl=0; $ptl<1000; $ptl++)
{
	${'obj'.$ptl} = new C2();
	for ($pole=0; $pole<10; $pole++)
	{
		${'obj'.$ptl}->data[$pole] = $pole;
	}
}
 
$timeTests[2]['czas'] = microtime(true);
$timeTests[2]['znak'] = 'Obiekty';
 
 
echo '<br />';
$timePrev = 0;
foreach ($timeTests as $time)
{
	echo $time['znak'].': ';
	echo ($time['czas'] - $timePrev).'<br />';
	$timePrev = $time['czas'];
}
?>
[PHP] pobierz, plaintext 

Wyniki
Tabele: 0.026139974594116
Obiekty: 0.031857967376709

Wnioski
Tabele zgodnie z oczekiwaniami są szybsze od obiektów, ale nie jest to różnica powalająca, zaledwie 22%.