Witam, poszukuję optymalnego sposobu na zapis poniższej funkcji (metoda w klasie, której nie wklejam):

[PHP] pobierz, plaintext 
public function __get($key)
{
	if (isset($this->$key))
		$value = $this->$key;
	elseif (isset($this->data[$key]))
		$value = $this->data[$key];
	else
		$value = NULL;
	return $value;
}
[PHP] pobierz, plaintext 

Gdyby w isset() można było dokonać przypisania, to całość sprowadzałaby się do:

[PHP] pobierz, plaintext 
public function __get($key)
{
	return (isset($value = $this->$key) OR isset($value = $this->data[$key])) ? $value : NULL;
}
[PHP] pobierz, plaintext 

Niestety się nie da. Ma ktoś może jakiś pomysł jak to zoptymalizować?

[PHP] pobierz, plaintext 
return isset( $this->key ) ? $this->key : ( isset( $this->data[$key] ) ? $this->data[$key] : NULL );
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
return $this->$key ? $this->$key : ($this->data[$key] ? $this->data[$key] : null);
[PHP] pobierz, plaintext 

Twoja wersja zwróci Notice'y jeżeli nie będzie któreś z wartości

Pozdro

No zgadza się, isset()-y celowo dałem. Dzięki za pomoc Panowie.

Od kiedy to optymalny równa się maksymalnie krótki i nieczytelny?

[PHP] pobierz, plaintext 
if (isset($this->$key)) {
    return $this->$key;
} else if (isset($this->data[$key])) {
    return $this->data[$key];
}
 
return null;
[PHP] pobierz, plaintext 

Nie kombinuj tam gdzie nie potrzeba.

EDIT: Ogólnie to masz paskudną strukturę danych.

A to inna sprawa. Zapis typu ?: jest wolniejszy niz zwykly if - else, wiec Twoje rozwiązanie jest najlepsze Źle się zasugerowałem postem kolegi

Pozdro

Czemu?

Nie wiem dlaczego tak jest Tak wynikało z moich testów

Trochę bez sensu, no ale :)

Dlaczego bez sensu? Czy coś co jest mniej czytelne, musi być wydajniejsze?

Wątpię - a nawet jeśli, to co z tego? Tworzysz grę, która ma śmigać w 60 FPS? Panowie, nie popadajcie w paranoję. Zapis ? : jest tu jak najbardziej w porządku.

Nie nie nie nie - czytelność jest kwestią gustu, bez sensu jest tylko to, że zapis:

[PHP] pobierz, plaintext 
$var = condition ? true : false;
[PHP] pobierz, plaintext 

który znaczy dokładnie to samo co:

[PHP] pobierz, plaintext 
if (condition) {
  $var = true;
} else {
  $var = false;
}
[PHP] pobierz, plaintext 

może być wolniejszy od tego drugiego. Tak przy okazji - nie wyobrażam sobie zapisania skryptu typu:

[PHP] pobierz, plaintext 
$zmienna_1 = isset($_POST['zmienna_1']) ? $_POST['zmienna_1'] : '';
$zmienna_2 = isset($_POST['zmienna_2']) ? $_POST['zmienna_2'] : '';
$zmienna_3 = isset($_POST['zmienna_3']) ? $_POST['zmienna_3'] : '';
/* ... */
$zmienna_100 = isset($_POST['zmienna_100']) ? $_POST['zmienna_100'] : '';
[PHP] pobierz, plaintext 

W taki sposób:

[PHP] pobierz, plaintext 
if (isset($_POST['zmienna_1'])) {
  $zmienna_1 = $_POST['zmienna_1'];
} else {
  $zmienna_1 = '';
}
if (isset($_POST['zmienna_2'])) {
  $zmienna_2 = $_POST['zmienna_2'];
} else {
  $zmienna_2 = '';
}
if (isset($_POST['zmienna_3'])) {
  $zmienna_3 = $_POST['zmienna_3'];
} else {
  $zmienna_3 = '';
}
/* ... */
if (isset($_POST['zmienna_100'])) {
  $zmienna_100 = $_POST['zmienna_100'];
} else {
  $zmienna_100 = '';
}
[PHP] pobierz, plaintext 

nawet w tej, w sposób oczywisty mniej wydajnej wersji:

[PHP] pobierz, plaintext 
$zmienna_1 = '';
if (isset($_POST['zmienna_1'])) {
  $zmienna_1 = $_POST['zmienna_1'];
}
[PHP] pobierz, plaintext 

Dla mnie to pierwsze jest znacznie bardziej czytelne. Ale jak już napisałem - kwestia gustu.

Zacznijmy od tego, że jak masz taką konstrukcję to jest coś nie tak z Twoimi umiejętnościami. Ale rozumiem, że to tylko na potrzeby przykładu.

Jeszcze tak raz podkreślę: nie szukaj wydajności w takich miejscach - to, że zyskasz 0.00000213 sekundy nic Ci nie da.

W Twojej wersji jak najbardziej zapis skrócony jest sensowniejszy. Kwesta kompromisu pomiędzy czasem wykonania a przejrzystością kodu. Poza tym rozchodzi się o czas rzędu 3E-6 Więc strasznie dużej straty na tym nie ma. Niemniej jednak takowa występuje.

Jednak przy pierwotnym problemie w tym temacie zapis Crozina wydaje mi się najsensowniejszy. Szybszy i jednak bardziej przejrzysty niż zagnieżdżanie ?:

Pozdro

Spoko spoko - nie ja podniosłem kwestię wydajności. Ale to trochę tak jak z ++$i zamiast $i++ - nikt nikomu nie każe przeglądać wszystkich swoich skryptów i zamieniać jedno na drugie. Ale nie zaszkodzi, jeśli to pierwsze wejdzie w krew (i szablony kodu :)).

No dobrze, ważna jest czytelność kodu, a czy poniższy zapis jest nieczytelny?

[PHP] pobierz, plaintext 
public function __get($key)
{
     return (isset($this->$key) ? $this->$key :
                (isset($this->data[$key]) ? $this->data[$key] :
                NULL;
}
[PHP] pobierz, plaintext 

Jeżeli ktoś posiada konkretną wiedzę czy i jeśli tak to kiedy wskazane jest używanie skróconego zapisu za pomocą ternary operator-a będę niezmiernie wdzięczny za wytyczne.

Jeżeli robisz to w sposób, który przedstawiłeś na forum to nie skomentuję...
Co do wydajności - wrzuć sobie w pętlę z 100 tysięcy raz, wyciągnij czasy, podaj czas średni i porównaj - może się mylimy... Ja nie idę w zapartego, że jest tak jak My piszemy i nie podważam za wszelką cenę Twoich teorii.


No i tutaj byś się zdziwił, jest różnica czy używasz ++$i czy $i++
Miłego czytania

wystarczy ze wklepie echo

[PHP] pobierz, plaintext 
$i = 0;
echo $i++; // 0
echo $i; // 1
echo ++$i; // 2
[PHP] pobierz, plaintext 

No i moim zdaniem jest to BARDZO duża różnica i jeżeli ktoś nie widzi tej różnicy lub o tym nie wie, znając życie przyleci na forum i będzie pytał: Dlaczego mi skrypt źle działa?

@fifi209, @kapuch: Chodziło o sytuację gdzie zależy nam tylko na inkrementacji wartości zmiennej, np.:

[PHP] pobierz, plaintext 
for (...; ...; ++$i)
   if () {
     ++$j;
   }
[PHP] pobierz, plaintext 

W tych przypadkach nie ma realnej różnicy.

Szczerze to jestem zdziwiony jak długo się ten wątek ciągnie, więc tam na zakończenie (oby)
1) Mikroptymalizacja z reguły jest pozbawiona sensu w "zadaniach wysokiego poziomu" - to odnośnie pre/postinkrementacji, używania bloków if/else lub ?: itp.
2) Kod powinno się pisać czytelny. Jeżeli jeden zapis jest czytelniejszy od drugiego to można z niego skorzystać. A to kiedy coś jest czytelne... no tyle to już chyba potraficie sami ocenić?

No dobrze, ale są jakieś konkretne wytyczne kiedy używać jednego zapisu, a kiedy drugiego?
Których z zapisów jest bardziej poprawny, czytelny i zalecany w następujących sytuacjach?
Sytuacja 1:

[PHP] pobierz, plaintext 
//1.1
$syshelpers = file_exists($syspath = trim(FRAMEWORKSDIR.'/'.HELPERSDIR, '/')) ? array_slice(scandir($syspath), 2) : array();
//1.2
if (file_exists($syspath = trim(FRAMEWORKSDIR.'/'.HELPERSDIR, '/')))
     $syshelpers = array_slice(scandir($syspath), 2);
else
     $syshelpers = array();
//1.3
$syshelpers = array();
if (file_exists($syspath = trim(FRAMEWORKSDIR.'/'.HELPERSDIR, '/')))
     $syshelpers = array_slice(scandir($syspath), 2);
[PHP] pobierz, plaintext 

Sytuacja 2:

[PHP] pobierz, plaintext 
//2.1
$type = (substr($type, -1) == 'y') ? substr($type, 0, -1).'ies' : $type.'s';
//2.2
if (substr($type, -1) == 'y')
     $type = substr($type, 0, -1).'ies';
else
     $type = $type.'s';
[PHP] pobierz, plaintext 

Sytuacja 3:

[PHP] pobierz, plaintext 
//3.1
return (isset($this->$key) OR isset($this->data[$key])) ? TRUE : FALSE;
//3.2
if (isset($this->$key) OR isset($this->data[$key]))
     return TRUE;
return FALSE;
//3.3
if (isset($this->$key) OR isset($this->data[$key]))
     return TRUE;
else
     return FALSE;
[PHP] pobierz, plaintext 

Sytuacja 4:

[PHP] pobierz, plaintext 
//4.1
return (isset($this->$key) ? $this->$key : (isset($this->data[$key]) ? $this->data[$key] : NULL));
//4.2
return (isset($this->$key) ? $this->$key :
           (isset($this->data[$key]) ? $this->data[$key] :
           NULL));
//4.3
if (isset($this->$key))
     return $this->$key;
elseif (isset($this->data[$key])
     return $this->data[$key];
else
     return NULL;
//4.4
if (isset($this->$key))
     return $this->$key;
else if (isset($this->data[$key])
     return $this->data[$key];
else
     return NULL;
//4.5
if (isset($this->$key))
     return $this->$key;
if (isset($this->data[$key])
     return $this->data[$key];
return NULL;
[PHP] pobierz, plaintext 

Sytuacja 5:

[PHP] pobierz, plaintext 
//5.1
return isset(self::$instance) ? self::$instance : self::$instance = new self;
//5.2
if (isset(self::$instance))
     return self::$instance;
else
     return self::$instance = new self;
//5.3
if (isset(self::$instance))
     return self::$instance;
return self::$instance = new self;
//5.4
if (!isset(self::$instance))
     self::$instance = new self;
return self::$instance;
[PHP] pobierz, plaintext 

Które z nich, a może jakieś inne są najbardziej poprawne?

No ileż można - który zapis wydaje Ci się najbardziej przejrzysty? Wariant pierwszy, drugi lub trzeci - używaj który Tobie najbardziej pasuje. Mnie pasuje czwarty Tobie drugi - używaj sobie drugiego. Nie ma żadnych wytycznych - to tylko forma zapisu!

No ok, to poprostu napisz, które zapisy Ty byś wybrał...

Ja też wole 4. może i wdurgim kod jest krótszy prawie 4 krotnie, ale jeśli musiałbym tam coś zmieniac to rozszyfrowanie tego zajeło by mi wiecej czasu dlatego wole już wiecej linijek ale czytelniej choc slowo czytelniej jest subiektywne i dla kogos innego sytuacja 2 moze byc czytelniejsza.

attimo widzę, że chyba nie wczytałeś się w posta. Jest pięć sytuacji z różnymi możliwościami rozwiązań (kolejne rozwiązania dla poszczególnych sytuacji są wypunktowane w komentarzach).

#1

[PHP] pobierz, plaintext 
$syspath = trim(FRAMEWORKSDIR.'/'.HELPERSDIR, '/');
$syshelpers = file_exists($syspath) ? array_slice(scandir($syspath), 2) : array();
[PHP] pobierz, plaintext 

#2

[PHP] pobierz, plaintext 
$type = substr($type, -1) == 'y' ? substr($type, 0, -1).'ies' : $type.'s';
[PHP] pobierz, plaintext 

#3

[PHP] pobierz, plaintext 
return isset($this->$key) || isset($this->data[$key]);
[PHP] pobierz, plaintext 

#4

[PHP] pobierz, plaintext 
if (isset($this->$key)) {
     return $this->$key;
} elseif (isset($this->data[$key]) {
     return $this->data[$key];
}
 
return NULL;
[PHP] pobierz, plaintext 

#5

[PHP] pobierz, plaintext 
if (!isset(self::$instance)) {
     self::$instance = new self;
}
 
return self::$instance;
[PHP] pobierz, plaintext 

Tylko nie wiem po co to podaję. Naprawdę tak ciężko ocenić co dla siebie samego jest wygodne?