Drukowana wersja tematu

Napisany przez: hawk 10.02.2005, 17:23:52

Problem stary jak świat: system wymaga włączenia sporej liczby plików i zarządzanie tym jest upierdliwe. Do tego nie należy włączać więcej kodu niż potrzeba, a najlepiej zrobić jakieś lazy load.

Oczywiście, technik jest wiele:

1) require_once rozsiane po plikach, najlepiej poprzedzone jakąś stałą, np. require_once ROOT_DIR . '/foo/Foo.class.php';

2) Prado: deklarujemy namespacy - np. za pomocą funkcji using(), co dodaje nam ścieżki do include_path, a potem niech php znajdzie klasę.

3) Autoloader + mapa (nazwa klasy => ścieżka do pliku); autoloader wczytuje mapę i na jej podstawie jest w stanie znaleźć każdą klasę

Są jeszcze jakieś inteligentne sposoby? Dobry mechanizm powinien być odporny na "przemeblowanie" struktury plików (np. chcemy połączyć kilka klas w jeden plik).

BTW, włączanie plików bez klas (tylko funkcje i kod) jest gorsze, bo nie ma tego czegoś, czego można szukać po plikach... kolejna zaleta OOP?

Napisany przez: DeyV 10.02.2005, 21:46:51

Aby sprawę jeszcze bardziej skomplikować - warto pamietać o tym - że require_once i inlude_once jest w rzeczywistości bardzo wolne = każde wywołanie tych funkcji, nawet jeśli tym razem NIE MUSIAŁA ona ładować tego pliku, bo już był załadowany wcześniej, trwa niemal tyle samo, co require()
proste porównanie:
http://www.phpinsider.com/smarty-forum/viewtopic.php?t=4323
I choć, jak ktoś to zauwazył w tym wątku, fizyczny zysk czasu jest niewielki, to jednak procentowo - różnica jest ogromna.

Napisany przez: Imperior 11.02.2005, 18:39:48

Myślę, że moje rozwiązanie pomoże Ci, jeśli wpadniesz na jakiś dobry pomysł, to daj znać:
(nawiasem mówiąc każda klasa przekłada się na lokalizację w ten sposób:
Projekt_Podgrupa_Costam -> /packages/projekt/podgrupa/projekt_podgrupa_costam.php
zdecydowałem się na to, aby każdy plik miał pełną nazwę klasy, a instalator tworzył pakiety klas.)
Plik poza_drzewkiem/packages/noname/noname_package.php

[PHP] pobierz, plaintext 
<?php
http://www.php.net/define('NN_SEP', DIRECTORY_SEPARATOR);
http://www.php.net/define('NN_LIB', http://www.php.net/dirname(http://www.php.net/dirname(__FILE__)).NN_SEP);
http://www.php.net/define('NN_PRIVATE', http://www.php.net/dirname(NN_LIB).NN_SEP);
 
function __autoload($sName) {
	if (!(CORE :: Import($sName) || CORE :: ImportEx($sName))) {
		http://www.php.net/echo 'Kaboooom! Reason? '.$sName.' not found!!!';
	}
}
 
class CORE {
	public http://www.php.net/static function Import($sName, $sFind = null, $bSearch = true) {
		if (!http://www.php.net/isset($sFind)) {
			$sFind = $sName;
		}
		if ($bSearch && (class_exists($sFind, false) || interface_exists($sFind, false))) {
			return true;
		}
		$sName = http://www.php.net/strtolower($sName);
		$aArr = http://www.php.net/explode('_', $sName);
		http://www.php.net/array_pop($aArr);
		$sPath = NN_LIB.http://www.php.net/implode(NN_SEP, $aArr).NN_SEP.$sName.'.php';
		if (http://www.php.net/is_readable($sPath)) {
			include_once ($sPath);
			if ($bSearch && !(class_exists($sFind, false) || interface_exists($sFind, false)) ) {
				return false;
			}
			return true;
		}
		return false;
	}
 
	public http://www.php.net/static function ImportEx($sName) {
		$aArr = http://www.php.net/explode('_', $sName);
		http://www.php.net/array_pop($aArr);
		http://www.php.net/array_push($aArr, 'package');
		if (CORE :: Import(http://www.php.net/implode('_', $aArr), $sName) || CORE :: Import($sName)) {
			return true;
		}
		return false;
	}
}
?>
[PHP] pobierz, plaintext 

Napisany przez: hawk 18.02.2005, 14:39:33

@Imperior:

Dwie słabe strony tu widzę:

1) Wszystko musi siedzieć w 2 miejscach: NN_LIB i NN_PRIVATE, co utrudnia model działania typu "user ściąga pakiet, wrzuca gdzie mu się podoba i chce żeby to działało".

2) Nie da się tego połączyć z zewnętrznymi bibliotekami, tzn takimi, gdzie nie ty decydujesz o nazwach klas.

Za to podobają mi się dwie inne rzeczy:

1) Importowanie całych "pakietów".

2) Nazwa_Klasy niejako emuluje pakiety, których php nie ma (nie możesz zrobić $foo = new com.example.Foo).

A mi się coraz bardziej podoba mapa:

[PHP] pobierz, plaintext 
<?php
$map = http://www.php.net/array(
  'MojaKlasa' => MY_DIR . 'foo/MojaKlasa.class.php',
  'MojaInnaKlasa' => MY_DIR . 'bar/KilkaKlas.inc.php',
  'MojaInnaKlasa2' => MY_DIR . 'bar/KilkaKlas.inc.php',
  'Smarty' => SMARTY_DIR . 'Smarty.class.php',
}
?>
[PHP] pobierz, plaintext 

Napisany przez: bela_666 18.02.2005, 15:03:36

Ja mysle, zeby rozwiazac to na podobnej zasadzie jak w javie. Mianowicie :

Mamy metode import, ta zaś wczytuje plik/pliki jakie chcemy. Czyli robimy:

[PHP] pobierz, plaintext 
<?php
import('pl.bela.foo.bar.Bar');
import('pl.bela.foo.*');
?>
[PHP] pobierz, plaintext 

Napisany przez: Imperior 18.02.2005, 20:17:07

Napisany przez: hawk 21.02.2005, 14:43:27

@bela_666: Takie rozwiązanie na pewno pasuje do javy, ale czy pasuje do php? Wszystko rozbija się o wydajność. Trzeba te importy przeczytać, pozamieniać na slashe, znaleźć katalogi, wczytać pliki... Owszem, mamy classpath (tzn. include_path ), ale w php jest to kosztowna (IMHO, nie robiłem testów) opcja, bo szuka po dysku przy każdym requeście. A przecież nie pozbędziemy się bibliotek, które nie stosują się do naszego standardu (smarty, adodb, ...). Czyli classpath się rozrasta.

Do tego, w php opłaca się wczytywać tylko te pliki, które są niezbędne. W javie nie ma tego problemu, bo wczytujesz raz i masz spokój. W php starasz się zminimalizować ilość operacji dyskowych na jedno żądanie.

W javie importy i w ogóle pakiety są potrzebne, bo 2 klasy w różnych pakietach mogą mieć tą samą nazwę i nie jest to problem. W php taka sytuacja jest niedozwolona, więc i pakiety są niepotrzebne (tak naprawdę jest to zabronione właśnie dlatego, że nie ma pakietów, ale skutek jest ten sam).

W javie z importami jest jeden problem: w pewnym momencie robi się ich zbyt dużo i upraszczamy sobie życie pisząc import java.util.*. W php jest to nie do przyjęcia - za dużo niepotrzebnie włączanego kodu. Więc nie muszę się martwić o unikalność com.example.hawk, bo to i tak nic mi nie daje.

@Imperior: sens regexpów zależy od tego, czy będą one szybsze niż wymienienie wszystkich klas. Czyli od wydajności.

Podsumowując, idealnie chciałbym mieć:
- nie muszę w swoich plikach php pisać require_once, przypominać sobie gdzie są potrzebne klasy, oraz upewniać się że nie pominąłem potrzebnego interfejsu
- mogę obsługiwać zewnętrzne (nie moje) biblioteki tak samo (tzn też bez pamiętania o require_once smarty)
- mogę w trakcie developmentu zmienić strukturę moich plików z klasami, przenieść do innych katalogów, itd. bez poprawiania mojej aplikacji
- mogę zmienić coś w n-tej dystrybucji pakietu bez obawy, że kod użytkowników nie znajdzie mojej klasy
- włączane są tylko te klasy, które są aktualnie potrzebne, i narzut czasy wykonania jest minimalny

Napisany przez: hawk 25.02.2005, 09:23:01

@serafin: Możesz napisać więcej? Mi się zawsze wydawało że php nie pozwala na kropki w nazwie klasy. Tak bardzo mi się wydawało, że nigdy nie sprawdziłem. I czy to oznacza, że pełna nazwa klasy rzeczywiście brzmi System.Console.Out? Żeby autoloader mógł znaleźć klasę.

Bo problem z brakiem namespaces jest taki, że jak napiszemy $foo = new System.Console.Out, to php nie wie, że ma szukać klasy Out w System.Console, tylko szuka System.Console.Out.

Napisany przez: Imperior 25.02.2005, 09:55:57

Napisany przez: Vengeance 25.02.2005, 11:42:46

A co Wam się stanie gdy zamiast System.Out będzie System_Out ?
Czy warto stosować te wszystkie parsery/tokenizery czy co tam jeszcze (opóźniające czas wykonywania) aby wygrać "walke" z kropką ?

Napisany przez: hawk 25.02.2005, 12:06:36

Nic się nie stanie, poza utratą estetyki . Chociaż kwestia "kropka czy kreska" nie jest tutaj podstawowa. Problem jest raczej w tym, że autoloader będzie szukał klasy System_Out, a nie klasy Out w pakiecie System. Czyli na braku pakietów. I na tym, że na pewno znajdą się biblioteki, gdzie kreska jest używana do czegoś innego, co może wprowadzić system w błąd.

Napisany przez: Vengeance 25.02.2005, 12:31:22

ale to jest php a nie java

Co do autoloadera... co za problem zrobić jakiś explode po znaku _
i odpowiednio sprawdzić?

Napisany przez: hawk 25.02.2005, 12:48:42

Co za problem? Sprawdzanie po zrobieniu explode jest kosztowne. Odwołanie do dysku, przemnożone przez ileś tam włączanych klas. A ja zakładałem sobie idealnie, że autoloader, jako "jądro jądra", musi być super szybki.

Żeby nie było że się czepiam: to nie jest zła metoda, na razie nie zakodowałem samemu nic mądrego (stąd ten wątek). Zawsze są zady i walety, ja tylko wymieniam słabe strony.

Napisany przez: Seth 25.02.2005, 12:50:43

Troche to stary kod ale moze sie przyda:

[PHP] pobierz, plaintext 
<?php
http://www.php.net/define( 'INCLUDE_PATH', 'include/' );
 
/**
 * Use this function to include classes in given namespace pattern
 *
 * @param $nsPattern string
 * @return true if succed, false otherwise
 */
function Import( $nsPattern )
{
  // Filter pattern namespace
  if ( http://www.php.net/preg_match( '/^[a-z0-9_]+(.[a-z0-9_]+){0,}(.*)?$/i', $nsPattern ) )
  {
	$nsPattern = http://www.php.net/str_replace( '.', '/', $nsPattern );
 
	if ( http://www.php.net/preg_match( '/^(.*)/*$/', $nsPattern, $match ) )
	{
	  $patch = INCLUDE_PATH.$match[1];
 
	  if ( $handle = http://www.php.net/opendir( $patch ) )
	  {
		while ( false !== ( $file = http://www.php.net/readdir( $handle ) ) )
		{
		  $i = 0;
 
		  if ( $file != '.' && $file != '..' && http://www.php.net/preg_match( '/^(.*).class.php$/', $file, $match ) )
		  {
			$filePath = $patch.&#092;"/\".$file;
 
			if ( http://www.php.net/file_exists( $filePath ) && http://www.php.net/is_file( $filePath ) && !class_exists( $match[1] ) )
			{
			  require_once( $filePath );
 
			  $i++;
			}
		  }
		}
 
		http://www.php.net/closedir($handle);
	  }
 
	  return ( $i ? 1 : 0 );
	}
	else
	{
	  $className = http://www.php.net/substr( http://www.php.net/strrchr( $nsPattern, '/'), 1 );
	  $filePath = INCLUDE_PATH.$nsPattern.&#092;".class.php\";
 
	  if ( http://www.php.net/file_exists( $filePath ) && http://www.php.net/is_file( $filePath ) && !class_exists( $className ) )
	  {
		require_once( $filePath );
 
		return 1;
	  }
 
	  return 0;
	}
  }
 
  // Wrong pattern
  return 0;
}
?>
[PHP] pobierz, plaintext 

Napisany przez: bela_666 25.02.2005, 12:55:30

Seth, a czy te pregi nie spowalniają bardzo przy dużej ilości plików ?

Napisany przez: Seth 25.02.2005, 13:07:03

Jakies spowolnienie napewno jest ale za to mozna latwo zaincludowac kilka klas

Napisany przez: bela_666 26.02.2005, 00:02:23

Napisany przez: Nievinny 26.02.2005, 09:35:42

Jeśli mogę wtrącić trzy grosze, ja myślę, że można przejechać po katalogach czymś takim:

[PHP] pobierz, plaintext 
<?php
 
$Dir = new RecursiveIteratorIterator( new RecursiveDirectoryIterator( ROOT_PATH ), true );
	foreach( $Dir as $File ) {
		if( $File->getFilename() === $sFile ) {
			try {
				CORE::loadClass( $File->getPathname() );
			}
			catch( CoreExceptions $Error ) {
				http://www.php.net/print Debuger::errorDisplay( $Error );
				http://www.php.net/exit;
			}
			break;
		}
	}
 
?>
[PHP] pobierz, plaintext 

• nazwy klas musza byc takie same ja nazwy plikow (bez rozszerzenia) lub odwrotnie
• Może przy dużej ilości katalogów spowoli trochę, ale można dodać funkcje ładowania kilku klas i odrzucić katalogi

Napisany przez: hawk 26.02.2005, 09:55:15

@bela_666: pokaż pokaż pokaż

Napisany przez: Vengeance 26.02.2005, 11:55:48

Nievinny: jakbyś zrobił cache jakiś to ok. Teraz uważam, że to jest najgorsze z najgorszych rozwiązań

Napisany przez: bela_666 26.02.2005, 12:21:14

@bela_666: pokaż pokaż pokaż

[PHP] pobierz, plaintext 
<?php
http://www.php.net/error_reporting(E_ALL|E_STRICT);
function get_microtime() {
	list($usec, $sec) = http://www.php.net/explode(&#092;" \",microtime());
	return ((float)$usec + (float)$sec);
}
 
http://www.php.net/global $fileContext;
$fileContext = http://www.php.net/array();
$start = get_microtime();
iterateDir('.'/*dirname(__FILE__)*/);
 
function iterateDir($path) {
	$di = new DirectoryIterator($path);
	foreach ($di as $k => $v) {
		// get extension
		$ext = http://www.php.net/end(http://www.php.net/explode('.', $v->getPathname()));
		// is svn dir
		$name = $v->getFilename();
		$first = http://www.php.net/substr($name, 0, 1);
		$first == '.' ? $dupa = false : $dupa = true;
 
		// if is dir and not svn dir, iterate this dir;]
		if($v->isDir() && $dupa) {
			iterateDir($v->getPath() . '/' . $v->getFilename());
		}
		// print filename with path, with php extenstion
		if($dupa && $v->isFile() && $ext == 'php' && $v->getFilename() != 'tokenizer.php' && $v->getFilename() != 'test.php' && $v->getFilename() != 'config.php' && $v->getFilename() != 'dupa.php') {
			$GLOBALS['fileContext'][] = http://www.php.net/array($v->getPathname(), token_get_all(http://www.php.net/file_get_contents($v->getPathname())));
			//print $v->getPathname() . \"<br />n\";
		}
	}
 
}
 
//dump($fileContext);
$classes = http://www.php.net/array();
$key = 0;
foreach($fileContext as $file) {
	http://www.php.net/static $i;
	foreach ($file as $c) {
		if(http://www.php.net/is_array($c)) {
			$a = false;
			foreach ($c as $k => $v) {
				if(http://www.php.net/is_array($v)) {
					if($v[0] == T_CLASS || $v[0] == T_INTERFACE) {
						$a = true;
					} elseif ($a && $v[0] == T_STRING) {
						$classes[] = http://www.php.net/array($v[1], http://www.php.net/substr($file[0], 2));
						$a = false;
					}
				}
				else
				{
					//print(\"$v<br/>n\");
				}
			}
		}
 
	}
 
}
 
//dump($classes);
 
$phpCode  = '<?php function __autoload($name) {' . &#092;"n\";
$phpCode .= 'static $map = array(' . &#092;"n\";
foreach ($classes as $k => $v) {
	$phpCode .= ''' . $v[0] . '' => '' . $v[1] . '','. &#092;"n\";
}
$phpCode .= ');' . &#092;"n\";
$phpCode .= 'require_once($map[$name]);' . &#092;"n}n\";
$phpCode .= '?>';
file_put_contents('autoload.php', $phpCode);
//dump($fileContext);
function dump($dump) {
	print('<pre>');
	var_dump($dump);
	print('</pre>');
}
print ($end = get_microtime() - $start . '<br />');
?>
[PHP] pobierz, plaintext 

Napisany przez: Vengeance 26.02.2005, 12:36:56

Połączyłem kody: bela_666, Nievinny oraz Imperiora i osiągnołem taki efekt:

[PHP] pobierz, plaintext 
<?php
      public function getClassesMap($sDirName)
      {
         $oRecursiveDirectory = new RecursiveIteratorIterator( new RecursiveDirectoryIterator( $sDirName ), true );
         foreach ($oRecursiveDirectory as $oFile)
         {
            if(!http://www.php.net/is_file($oFile->getPathname()))
               continue;
            $aTokenAll = token_get_all(http://www.php.net/file_get_contents($oFile->getPathname()));
            $bIsClass = false;
            foreach ($aTokenAll as $iToken)
            {
               if (!http://www.php.net/is_string($iToken))
               {
                  list($iTokenID, $sTokenValue) = $iToken;
                  switch ($iTokenID)
                  {
                     case T_CLASS:
                        $bIsClass = true;
                        break;
                     case T_INTERFACE:
                        $bIsClass = true;
                        break;
                     case T_STRING:
                        if ($bIsClass)
                        {
                           $aClassesMap[$sTokenValue] = $oFile->getPathname();
                           $bIsClass = false;
                        }
                        break;
                     case T_WHITESPACE:
                        break;
                     default:
                        $bIsClass = false;
                        break;
                  }
               }
            }
         }
         return $aClassesMap;
      }
?>
[PHP] pobierz, plaintext 

Napisany przez: Vengeance 26.02.2005, 12:41:48

Linia nr 9: zmieniasz ją na:

Napisany przez: Nievinny 26.02.2005, 17:03:09

@Vengeance -> Czy twoim zdaniem ładowanie z mapy powinno być zaimplementowane od razu w __autoload() czy dać jakąś funkcję pośrednią?

OK, a ja myślę, że można to jeszcze przerobić i jeszcze jedno: kiedy należy a kiedy nie robić mapę plików?

I czy pozwolisz wykorzystam to w swoim CORE?

Zobaczcie coś takiego i oceńcie

[PHP] pobierz, plaintext 
<?php
 
http://www.php.net/define( 'IN_CORE', true );
 
// ---- Definicja stałych
http://www.php.net/define( 'ROOT_PATH', './' );
http://www.php.net/define( 'PHPEX', '.php' );
 
// ---- Załadowanie systemów
include_once( ROOT_PATH . 'lib/debuger/Debuger' . PHPEX );
include_once( ROOT_PATH . 'lib/CORE' . PHPEX );
 
// ---- Mapa plików
$aMap = CORE::getClassesMap( ROOT_PATH );
// ---- Funkcja autoładowania
function __autoload( $sFile ) {
	http://www.php.net/global $aMap;
	$bLoad = false;
	foreach( $aMap as $sName => $sValue ) {
		if( $sName === $sFile ) {
			try {
				CORE::loadClass( $sValue, $sFile );
			}
			catch( CoreExceptions $Error ) {
				http://www.php.net/print Debuger::errorDisplay( $Error );
				http://www.php.net/exit;
			}
			$bLoad = true;
			break;
		}
	}
	if( $bLoad === false ) {
		http://www.php.net/print Debuger::errorLiteDisplay( 'Nie można odnaleźć podanej klasy' );
		http://www.php.net/exit;
	}	
}
 
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
 
function __autoload( $sFile ) {
	http://www.php.net/global $aMap;
	if( http://www.php.net/isset($aMap[$sFile] ) ) {
		try {
			CORE::loadClass( $aMap[$sFile], $sFile );
		}
		catch( CoreExceptions $Error ) {
			http://www.php.net/print Debuger::errorDisplay( $Error );
			http://www.php.net/exit;
		}
 
	}
	else {
		http://www.php.net/print Debuger::errorLiteDisplay( 'Nie można odnaleźć podanej klasy' );
		http://www.php.net/exit;
	}	
}
 
?>
[PHP] pobierz, plaintext 

Napisany przez: Vengeance 26.02.2005, 17:35:25

Nievinny: chodzi oto, aby mape generować tylko RAZ!! Potem jak coś dodasz/zmienisz dopiero robisz ją ponownie. W moim przypadku robienie mapy zabiera 95% czasu wykonywnia skryptu! Dlatego tak ważnym jest aby wynik był objęty jakimś cache. A czy zrobisz w __autoload() czy w czymkolwiek innym to już nie jest takie ważne

Napisany przez: Nievinny 26.02.2005, 17:42:59

Nievinny: chodzi oto, aby mape generować tylko RAZ!! Potem jak coś dodasz/zmienisz dopiero robisz ją ponownie. W moim przypadku robienie mapy zabiera 95% czasu wykonywnia skryptu! Dlatego tak ważnym jest aby wynik był objęty jakimś cache. A czy zrobisz w __autoload() czy w czymkolwiek innym to już nie jest takie ważne

Napisany przez: Vengeance 26.02.2005, 18:15:03

A po co foreach? Jeszcze opozniac ? To $map[$className] jest takie zle? W sumie to i tak kazdy robi jak mu wygodniej ;]

Napisany przez: hawk 26.02.2005, 18:42:06

@Vengeance et al: No, bardzo ładny kod . Ja bym dodał parametryzację/konfigurację generatora mapy. Coś takiego jak ma phpdocumentor - jakie katalogi ma przeglądać, jakie pliki ma czytać. Wtedy można sobie zignorować .svn i nie trzeba tego zakodowywać na stałe w kodzie.

A potem tylko zrzucić mapę do jakiegoś pliku php i voila!

I na koniec coś takiego:

[PHP] pobierz, plaintext 
<?php
function __autoload($sClass) {
  ClassLoader::load($sClass);
}
 
class ClassLoader {
  private http://www.php.net/static $aMap;
 
  public http://www.php.net/static function addMap($aMap) {
	self::$aMap = self::$aMap == null ? $aMap : http://www.php.net/array_merge(self::$aMap, $aMap);
  }
 
  public http://www.php.net/static function load($sClass) {
	if (http://www.php.net/array_key_exists($sClass, self::$aMap)) {
	  require self::$aMap[$sClass];
	}
  }
}
?>
[PHP] pobierz, plaintext 

Napisany przez: Vengeance 26.02.2005, 19:07:38

Ok userzy forum.php.pl "wymyslili" juz idee "routera" (a raczej po prostu to nazwali ladnie). Teraz czas nazwac to co tu razem stworzyliśmy

Napisany przez: Nievinny 27.02.2005, 12:32:23

Nazwa: Autoload Class System...

może być, a klasa niezła, tylko, że robi zrzuty przy każdym wywołaniu skryptu a nie ciągnie z cache

Pozwolę sobie jeszcze dopisać, cos o systemie cache:
1) Jest absolutnie niezbędny:

• Czas gen bez cache: 0.0617 sec
• Z cache: 0.0111 sec
• Czyli o 0.0516 sec szybciej
• Czyli ok 5,5 raza szybciej

Napisany przez: chmolu 4.03.2005, 10:29:10

Ja to rozwiązałem podobnie, jak w nowym Mojavi:

[PHP] pobierz, plaintext 
<?php
  function __autoload($class_name)
  {
	  $filename = ConfigManager::getConfig('autoload', 'autoload', $class_name);
	  if (!http://www.php.net/empty($filename))
	  {
		  /* include a file with the class definition */
		  require_once $filename;
	  }  
	  else 
	  {
		  /* unknown class */
		  throw new Exception(http://www.php.net/sprintf('Autoloading of class \"%s\" failed', $class_name));
	  }
  }
?>
[PHP] pobierz, plaintext 

Napisany przez: Nievinny 4.03.2005, 10:52:36

A ja generujesz listę klas? Tu masz od razu generator

Napisany przez: chmolu 4.03.2005, 16:34:52

Lista klas jest w pliku konfiguracyjnym autoload.ini, który wygląda tak:

Napisany przez: hawk 4.03.2005, 17:26:32

@chmolu:
1) Z tego co pamietam, w __autoload nie mozna rzucac wlasnych wyjatkow, bo i tak nie beda dzialac. Czyzby bug w Mojavi?

2) Pliki ini sa w tym przypadku zdecydowanie gorsze od tablic php. W pliku ini nie mozna zrobic czegos takiego:

[PHP] pobierz, plaintext 
<?php
$map = http://www.php.net/array(
  'FooClass' => FOO_DIR . '/Foo.class.php',
);
?>
[PHP] pobierz, plaintext 

Napisany przez: chmolu 4.03.2005, 17:49:43

Napisany przez: Nievinny 4.03.2005, 18:05:53

W sumie, skrypt po raz pierwszy zaczyna działanie więc generuje mapę, która jest potem cachowana. Gdy odpalimy skrypt po raz drugi odczyta mapę z cache (zserializowany ciąg + <?php die(); ?> ), usunie te ostatnie i przyśpieszenie jest widoczne
to sprowadza się ogólnie do:

[PHP] pobierz, plaintext 
<?php
 
if( !CORE::addMap( $Cache->loadCacheArray( 'aMap' ) ) ) {
	$aMap = CORE::getMap( './' );
	CORE::addMap( $aMap );
	$cache->saveCacheArray( 'aMap', $aMap );
}
// 'aMap' - uchwyt do pliku cache .php w ./cache/arrays/
 
?>
[PHP] pobierz, plaintext 

Napisany przez: Imperior 5.03.2005, 11:12:31

Napisany przez: hawk 7.03.2005, 03:36:42

@chmolu: Faktycznie, obsługa plików ini jest bardzo prosta. Co ciekawe, na początku próbowałem właśnie podejścia z "%APP_DIR%/...". Pliki ini wyglądają lepiej, prościej się je edytuje, trudniej popełnić błąd lub wrzucić niedozwolony kod. Z drugiej strony, trzeba wygenerować z nich pliki php, co samo w sobie jest banalne, ale wymaga sprawdzenia daty modyfikacji, czyli dodatkowego kroku. Wpływ na wydajność jest minimalny i to już chyba kwestia gustu.

Napisany przez: Bora 7.03.2005, 15:06:38

Pliki ini są wczytywane szybciej niż php gdyż mają specjalny prostszy parser.
Porównajcie soebie a zobaczycie że czasami nawet cechowanie w php trwa dłużej.

Napisany przez: Vengeance 7.03.2005, 16:07:14

A czy są szybsze od zserializowanej tablicy, zapisanej w pliku ?

Napisany przez: Imperior 7.03.2005, 17:09:23

A czy są szybsze od zserializowanej tablicy, zapisanej w pliku ?

Napisany przez: hawk 7.03.2005, 17:19:21

@Bora: Pliki ini moze i sa wczytywane szybciej, ale zamiana %APP_DIR% na odpowiednia sciezke niestety zepsuje tutaj wydajnosc.

Napisany przez: orson 7.03.2005, 22:59:24

witam ...

a moze w ini zrobic 2 sekcje ...

[PHP] pobierz, plaintext 
<?php
$array['path']['app_dir'].$array['path']['class']
?>
[PHP] pobierz, plaintext 

Napisany przez: hawk 8.03.2005, 00:10:53

A w jaki sposob z gory okreslisz, ktora sciezke masz dokleic do konkretnej klasy? Nie zrobisz tego, chyba ze narzucisz sobie jakies bardzo scisle reguly, a tego wole uniknac.

Napisany przez: Nievinny 8.03.2005, 08:01:25

A ja mam jeszcze pytanie dot. __autoload(). Czy jeśli wywołam w niej statyczną metodę która w razie niepowodzenia wywala wyjątek, to trzeb go obsłużyć w __autoload() czy przejdzie poziom wyżej?
Przykład:

[PHP] pobierz, plaintext 
<?php
 
function __autoload( $sClassName ) {
Application::loadClass( $sClassName );
}
 
//czy
 
function __autoload( $sClassName ) {
try {
Application::loadClass( $sClassName );
}
catch( NotFoundClassException $e ) {
//coscos
}
}
 
?>
[PHP] pobierz, plaintext 

Napisany przez: orson 8.03.2005, 20:18:36

[PHP] pobierz, plaintext 
<?php
 
http://www.php.net/print $iniFile['path']['mainAppPath'].$iniFile['clases']['dbclass'];
http://www.php.net/print $iniFile['path']['mainAppPath'].$iniFile['clases']['session'];
//defaultem
http://www.php.net/print $iniFile['path']['mainAppPath'].$iniFile['path']['default'].$iniFile['clases']['dbclass'];
 
?>
[PHP] pobierz, plaintext 

Napisany przez: hawk 9.03.2005, 03:16:17

@Orson: nie o to mi chodzi. Masz np. (a raczej użytkownik systemu ma) Smarty, kawałek WACT i w ogóle przynajmniej kilka bibliotek, których używa. Przecież nie będzie tak, że jeden super framework robi wszystko najlepiej, więc autoloader nie powinien być ograniczony do tego, co sami sobie wymyślimy, tylko po prostu działać tak jak chce użytkownik.

Nie powiesz teraz użytkownikowi, że ma to wszystko umieścić w innym katalogu. Będzie miał Smarty w jakimś niestandardowym miejscu, będzie chciał użyć razem z super-autoloaderem i będzie oczekiwał, że autoloader załaduje mu Smarty - od tego przecież jest.

I co wtedy? Skąd autoloader ma wiedzieć, że Smarty akurat nie jest pod mainAppPath?

PS

Napisany przez: orson 9.03.2005, 07:31:00

witam ...

hmm ... no to w pliku ini w sekcji clases podajesz

Napisany przez: dr_bonzo 9.03.2005, 10:25:30

@Nievinny: wyrzuc wyjatek w tej metodzie i sprawdz. Wyjatek wedruje w gore do ekranu (error) dopuki go nie zlapiesz gdzies po drodze.

Napisany przez: Nievinny 9.03.2005, 17:20:55

Owszem wywala wyjątek, ale nie obsługuje go w zwykły sposób, a skrypt wychwytuje wyjątek "po drodze", tylko wywala fatal errora.

@dr_bonzo: To co mówisz byłoby dobre, gdyby funkcję wywoływać w ten sposób:

[PHP] pobierz, plaintext 
<?php
 
__autoload( $zmienna );
 
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
 
//$zmienna = 'Debug';
function __autoload( $zmienna ) {
try {
CORE::zaladuj( $zmienna )
} catch( Exception $e ) {
http://www.php.net/print Debug::display( $e );
}
}
 
?>
[PHP] pobierz, plaintext 

Napisany przez: chmolu 12.03.2005, 23:12:26

Rozwiązanie z generowaniem mapy przez skanowanie katalogów wydaje się najlepsze. Jednak sposób Vengeance'a nie jest zbyt efektywny. Wymaga wczytania zawartości każdego pliku z osobna i sprawdzania, czy zawiera on jakieś klasy. Może jest to bardziej elastyczne, gdy mamy po kilka klas w jednym pliku, ale ja to zrobiłem inaczej.

U mnie każda klasa jest w osobnym pliku. Nazwa pliku zawierającego definicję klasy lub interfejsu kończy się na .class.php lub interface.php. I tylko takie pliki są ładowany do mapy.

Wycinki kodu z mojego frameworka:

[PHP] pobierz, plaintext 
<?
  /**
   * Checks whether the specified path exists.
   * If the directory is not found, it'll try to create one.
   *
   * @param  string $dirname 
   * @return void
   */
  function ensure_directory_exists($dirname)
  {
	  $dirname = http://www.php.net/substr($dirname, http://www.php.net/strlen(APP_DIR));
 
	  $sub_dirs = http://www.php.net/explode('/', $dirname);
	  $path = '';
	  foreach ($sub_dirs as $dir)
	  {
		  $path .= $dir . '/';
		  if (!http://www.php.net/file_exists($path))
		  {
			  if (!@http://www.php.net/mkdir($path, 0777))
			  {
				  throw new DaeronException('Could not create a directory \"' . $path . '\"');
			  }   
		  }
	  }
  }  
 
  /**
   * Writes the supplied content to a file.
   *
   * @param  string $filename Name of a file to write to.
   * @param  mixed  $content  Data to write to a file.
   * @return void
   */  
  function file_write($filename, $content)
  {
	  ensure_directory_exists(http://www.php.net/dirname($filename));
	  $fp = @http://www.php.net/fopen($filename, 'w');
	  if($fp)
	  {
		  @http://www.php.net/fputs($fp, $content, http://www.php.net/strlen($content));
	  }
	  @http://www.php.net/fclose($fp);	  
  }  
 
  class Autoloader
  {
	  /**
	   * Map of class names and their localization. 
	   *
	   * @var array
	   * @static 
	   */
	  private http://www.php.net/static $map = null;
 
	  /**
	   * Loads specified class.
	   *
	   * @param  string $class_name
	   * @return void 
	   */	  
	  public http://www.php.net/static function load($class_name)
	  {
		  $cached_map = APP_DIR . '/var/cache/autoload.php';
		  if (!http://www.php.net/is_readable($cached_map))
		  {
			  self::generateMap();
		  }
 
		  if (!http://www.php.net/isset(self::$map)) require_once $cached_map;
 
		  $class_name = http://www.php.net/strtolower($class_name);
		  if (!http://www.php.net/isset(self::$map[$class_name]))
		  {
			  throw new Exception('Unknown class ' . $class_name);
		  }
 
		  require_once self::$map[$class_name];
	  }
 
	  /**
	   * 
	   * 
	   *	 
	   */
	  private http://www.php.net/static function generateMap()
	  {
		  self::$map = http://www.php.net/array();
 
		  $cached_map = APP_DIR . '/var/cache/autoload.php';
 
		  self::scan(DAERON_DIR);
		  self::scan(APP_DIR);
 
		  $compiled = &#092;"<?phpn\";
		  $compiled .= 'self::$map = ' . http://www.php.net/var_export(self::$map, true) . &#092;"n?>\";
 
		  file_write($cached_map, $compiled);		   
	  }	  
 
	  /**
	   * 
	   * 
	   *	 
	   */
	  private static function scan($dir)
	  {
		  $match = array();
		 
		  $rd = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir), true);
		  foreach ($rd as $file)
		  {
			  if(!is_file($file->getPathname())) continue;
 
			  if (preg_match('/([a-z0-9_]+).(class|interface).php$/i', $file->getPathName(), $match))
			  {
				  self::$map[strtolower($match[1])] = $file->getPathName();	
			  }
		  }		 
	  }
  }
   
  function __autoload($class_name)
  {
	  Autoloader::load($class_name);	
  }
?>
[PHP] pobierz, plaintext 

Napisany przez: Vengeance 13.03.2005, 01:10:23

chmolu: Zauważ, że to Ty trzymasz każdą klasę w innym pliku!

A jak byś chciał dodać do frameworka np. AdoDB, Smarty czy inne rzeczy? One nie stosują twojego nazewnictwa.

Po to właśnie ten mój* skrypt przeszukuje wszystkie pliki wczytując je!

Skoro twoje nazewnictwo jest tak ustandaryzowane to w jakim celu w ogóle tworzyć mape ? przecież wystarczy zrobić

require $className . '.class.php'; hehe

* przypominam, iż nie czuje się właścicielem skryptu posklejałem kod z wielu wypowiedzi innych osób i wrzuciłem

Napisany przez: chmolu 13.03.2005, 09:44:36

@Vengeance: to prawda, nie każdy musi trzymać każdą klasę w innym pliku. Dla mnie takie rozwiązanie jest najwygodniejsze.

Napisany przez: bela_666 13.03.2005, 10:44:30

@chmolu a jak zmienisz ścieżke do smarty ?

Napisany przez: chmolu 13.03.2005, 12:43:09

Nie używam Smarty więc nie ma żadnego problemu

// btw: poprawiłem troszkę ten kod

Napisany przez: Vengeance 13.03.2005, 13:43:28

@chmolu: ty nie. Ale z tego co wynika z twoich wypowiedzi to co piszesz
to framework. Pewnie kiedys ktos inny z niego bedzie korzystac i moze chciec takze korzystac ze smarty

Napisany przez: chmolu 13.03.2005, 13:55:45

Zapewniam cię, że nie będzie to żaden problem
Ale mam nadzieję, że zamiast Smarty ludzie będą używali systemu wbudowanego w mój framework (wzorowany na WACT/ASP/JSP).
Jak skończę, to zarzucę tu kod do oceny.

Napisany przez: Ociu 4.05.2005, 18:16:29

Pozwole sobie odkopać temat

Zastanawiam się czy nie użyć pliku xml ładowania klas. Coś na wzór:

[XML] pobierz, plaintext 
<Classes>
 
<dirname>
<class name='jakas tam nazwa'>file.php</class>
<class name='jakas tam nazwa2'>file2.php</class>
</dirname>
 
<dirname2>
<class name='jakas tam nazwa3'>file3.php</class>
<class name='jakas tam nazwa4'>file3.php</class>
</dirname2>
 
</Classes>
[XML] pobierz, plaintext 

Napisany przez: davidD 5.05.2005, 00:09:50

Tylko właściwie... po co XML do zwykłego przypisania nazwy pliku do nazwy klasy? IMO jest to lekkie komplikowanie sobie całej sprawy - no chyba, że chcemy przechowywać jakieś dodatkowe informacje.

Mnie osobiście podoba się pomysł z iteratorem, szukającym klas po wszystkich plikach o określonym wzorcu, w podanej ścieżce (ścieżkach). Można z tego zrobić ładną tablicę, zserializować ją i do pliku... Co prawda trzeba się troszkę pobawić samym pisaniem tego generatora mapy, ale za to później, przy zmianie położenia/nazw plików zaoszczędzi się duużo czasu.

Napisany przez: matid 5.05.2005, 06:37:45

Ja to widzę tak:
1. Crowler, szuka po określonych folderach w poszukiwaniu plików php zawierających klasy. Będzie miał możliwość wyszukiwania z filtrowaniem nazw plików, nazwach klas itp. Być może po dodaniu opcji filtracji czas generowania mapy się zwiększy nieco, ale na jakoże jest to czynność wykonywana rzadko, można sobie na to pozwolić.
2. Dodatkowy plik XML z klasami zewnętrznymi. W tym pliku będą zapisane w postaci XML dodatkowe klasy, które autoloader ma obsługiwać. Plik byłby parsowany i razem z wynikami crowlera zapisywany w pliku php w postaci tablicy.

Napisany przez: Ociu 5.05.2005, 07:22:02

Napisany przez: chmolu 5.05.2005, 08:24:02

IMO pliki XML w tym wypadku są niepotrzebne. Szybciej i wygodniej będzie to zrobić przy pomocy plików ini

Napisany przez: Nievinny 5.05.2005, 17:06:02

XML to przeładowanie, a nam zależy na czasie, nie? Chociaż wszystko da się zrobić ;P

Napisany przez: matid 5.05.2005, 17:55:53

Napisany przez: bigZbig 10.05.2005, 09:28:27

@matid -> zauwazylem u Ciebie duze przywiazanie do technologi xml. Wiesz mnie sie zawsze wydawalo, ze ten jezyk zostal powolany do zycia po to, aby zapewnic przenosnosc danych pomiedzy roznymi platformami. Nie wiem czy w tym przypadku zapewnienie tej cechy jest pozadane. Uwazam ze próbujesz robic cos na sile utrudniajac sobie zywot.

Napisany przez: Nievinny 10.05.2005, 16:01:11

@matid -> ale tą mapę musisz za każdym uruchomnienie skryptu załadować i to będzie się dziać często...

Napisany przez: matid 10.05.2005, 17:36:31

Napisany przez: Nievinny 10.05.2005, 18:24:33

Czyli trzymasz tylko katalogi do parsowania? To nie ma sensu, ponieważ powinno się parsować wszystkie katalogi i uzyskać pełną mapę klas.

Napisany przez: Ociu 10.05.2005, 19:40:08

Napisany przez: matid 10.05.2005, 20:34:10

Napisany przez: Vengeance 10.05.2005, 21:26:35

" trwa to ok. 0,4 s"

lol :] Mój kod (a ogolnie ten co podałem powyżej gdzieś), który rekurencyjnie schodzi katalogami w dół i zapisuje znalezione klasy już teraz wykonuje się czasem więcej niż 20 sekund :]
Oczywiście robione jest to tylko raz, przy pierwszym uruchomieniu.

Napisany przez: matid 10.05.2005, 21:46:19

Napisany przez: Ociu 11.05.2005, 09:08:31

Czepiasz się szczegółów, liczba była podana dla przykładu.

Napisany przez: Vengeance 11.05.2005, 20:45:37

To nie było czepianie. Chodziło mi o sposób w jaki @matid osiągnął tak dobry jak dla mnie wynik. U mnie już powoli php robi time out przy generowaniu :] (WinXP, 950 MHz, 256mb RAM)

Napisany przez: matid 11.05.2005, 21:21:56

Dla zainteresowanych - moja klasa Autoloader: http://matid.emmatrade.pl/files/Autoloader.class.phps

I jeszcze raz moje testy:
Sprzęt: Pentium 4 2,4 GHz, 1024 MB RAM, dysk twardy 7200 RPM (system plików: ReiserFS)
System: Ubuntu Linux 5.04 Hoary Hedgehog

Dane testowe:
Rozmiar: 913.6 KB
Liczba plików: 120
Liczba klas: 90

Czas generowania mapy po raz pierwszy po włączeniu komputera: 0.872271060944s
Czas generowania mapy po raz kolejny (część plików mogła być w buforze dysków): 0.427920103073

Napisany przez: hawk 12.05.2005, 09:45:30

Skoro temat zrobił się popularny i każdy chce mieć swój autoloader oparty o mapy (co uważam za słuszne), to warto załatwić jedną prostą rzecz. Kompatybilność. Taka mapa to na tyle prosta struktura, że pewnie wszędzie wygląda tak samo:

[PHP] pobierz, plaintext 
<?php
$map=http://www.php.net/array(
  'nazwaklasy' => 'ścieżkadoklasy',
);
?>
[PHP] pobierz, plaintext 

Napisany przez: bigZbig 12.05.2005, 09:49:20

@hawk -> Amen

Napisany przez: dr_bonzo 26.05.2005, 15:15:11

...mam i ja.

Stworzylem swojego autoloadera:
- w konfigu podaje katalogi do rekursywnego przejrzenia
- podaje rozszerzenia plikow ktore maja byc tokenizowane

- mapa jest tworzona w std. formacie: nazwa_klasy => sciezka_do_pliku
- i zapisywana w formacie .ini (moze dorobie wybor ini | php)

I co najwazniejsze -- cachuje wyniki tokenizowania plikow (to nie to samo co 'mapa') -- tokenizowane sa tylko te co zostaly zmodyfikowane (okreslane przez filemtime()), co daje znaczna oszczednosc czasu. Zapisuje tablice:

[PHP] pobierz, plaintext 
<?php
 
http://www.php.net/array (
[ 'nazwa_pliku' ] ->
(
    [ 'classes' ] ->
    (
        [ 0 ] -> 'klasa_1';
        [ 1] - > itd...
    )
    [ 'modification_time' ] = 111123423423423; // czas modyfikacji
    { ['valid' ] = TRUE }
)
)
?>
[PHP] pobierz, plaintext 

Napisany przez: Vengeance 26.05.2005, 18:37:05

Z twojego opisu wynika mi, że za każdym uruchomieniem klasy następuje rekurencyjne przejrzenie katalogów. Jeśli tak jest, to jest to tragiczne rozwiązanie :]

Po co te wszystkie "czasy edycji plikow" itp. Na co ci oszczednosc czasowa przy generowaniu mapy, skoro zalozeniem glownym jest ze robisz to tylko raz! Ewentualnie potem gdy cos zmieniasz w strukturze ponawiasz proces generowania.

Twoje "Jak to wyglada w praktyce" wg mnie powinno ograniczac sie tylko do:
1. przejrzenie rekurencyjne wskazanych katalogów
2. tokenizacja każdego pliku celem wyłapania zawartych w nim klas
3. zapisanie wszystkich powiązań klasa=>plik do .ini czy tam .php

A sam główny skrypt powinien tylko ów .ini lub .php wczytywać, zaś gdy go nie ma powinien uruchamiać generowanie ów pliku :]

Taka moja wersja

Napisany przez: dr_bonzo 26.05.2005, 19:12:28

Napisany przez: hawk 27.05.2005, 20:47:33

Ciekawe rozwiązanie. Faktem jest, że mi by się nie chciało . Zwłaszcza że ja raczej na początku mam rozplanowane klasy, a potem głównie edytuję zawartość nie ruszając struktury.

Co do plików ini... rezultat ten sam. Dla ciekawości, sprawdzałeś, czy są szybsze od zwykłego php? Chociaż wada jest taka, że ja bym w pliku php bardzo chętnie umieszczał mapę wykorzystując jakąś zmienną - główny katalog projektu. Po to, aby ktoś, kto tego używa, nie musiał generować dla siebie mapy tylko dlatego, że u niego pliki php są w innym miejscu na dysku.

Napisany przez: dr_bonzo 5.06.2005, 02:20:39

W koncu. Kod przepisany od nowa, lecz jeszcze nie dopieszczony:
http://northslope.lap.pl/dev/Autoloader/0.2-dev/

a tu zrodla do pobrania:
http://northslope.lap.pl/dev/Autoloader/autoloader-0.2-dev.tar.gz

Napisany przez: Imperior 5.06.2005, 13:02:34

dr_bonzo: http://wiki.php.pl/index.php/RecursiveDirectoryIterator
Czyż nie łatwiej?

Napisany przez: hawk 5.06.2005, 13:23:14

Fajny kod. Nawet zdążyłem już użyć .

Kilka uwag:
- nie można podać extension np. "class.php", co jest bardzo przydatne, bo pozwala pominąć unit testy ("test.php"). Musiałbyś zmienić metodę isFileExtensionOnTheList tak, aby po prostu sprawdzała, czy nazwa pliku kończy się jednym z podanych wzorców
- przy pierwszym wywołaniu dostaję warning, że cache jeszcze nie istnieje. Potem jest OK.
- RecursiveDirectoryIterator uprościłby sprawę
- przydatną funkcją byłoby parsowanie tagów phpdoc (jeżeli są), aby pomijać klasy "wewnętrzne", czyli takie, które wykorzystywane są tylko w obrębie danego pliku i nie ma potrzeby wystawiać ich na zewnątrz. Ja takich mini-klas używam, i brakuje mi możliwości zrobienia prywatnej klasy wewnętrznej jak w Javie...

Napisany przez: dr_bonzo 5.06.2005, 14:00:34

Napisany przez: hawk 12.06.2005, 22:16:47

A co powiecie na taką implementację?

[PHP] pobierz, plaintext 
<?php
$i = new RecursiveIteratorIterator(new RecursiveDirectoryIterator(PHIEND_HANDLE_DIR));
$i = new KeyFilter($i, '.class.php$');
$w = new PhiendClassMapWriter('./handle_map.php');
$w->setTargetDir('e:/Web Files/lib/phiend2/phiend.handle', 'PHIEND_HANDLE_DIR');
 
$generator = new ClassMapGenerator();
$generator->addIterator($i);
$generator->setCreator(new BasicClassMapCreator());
$generator->addFilter(new SortClassMapFilter());
$generator->setWriter($w);
 
$generator->run();
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
 
/*
 * File generated by phiend.autoload
 */
 
http://www.php.net/define('PHIEND_HANDLE_DIR', 'e:/Web Files/lib/phiend2/phiend.handle');
 
$aMap = http://www.php.net/array(
	'IHandle' => PHIEND_HANDLE_DIR . '/IHandle.class.php',
	'BasicHandle' => PHIEND_HANDLE_DIR . '/BasicHandle.class.php',
// (ciach)
	'SerializedHandle' => PHIEND_HANDLE_DIR . '/SerializedHandle.class.php',
);
 
Autoloader::addMap($aMap);
 
?>
[PHP] pobierz, plaintext 

Napisany przez: cagrET 13.06.2005, 13:24:34

hawk: widzę, że używasz "notacji węgierskiej", ciekawi mnie czy może czytałeś ten artykuł: http://www.joelonsoftware.com/articles/Wrong.html > I’m Hungary . Joel pisze tam o tym, że w zły sposób używa się notacji węgierskiej, nie w taki jakim intencją autora tej notacji było.

Napisany przez: hawk 13.06.2005, 20:10:13

Nie, nie czytałem do tej pory. Przedrostki określające typ stosuję tylko w php, bo tak jest mi wygodniej. W językach ze ścisłą typizacją są mi niepotrzebne.

Napisany przez: matid 13.06.2005, 20:30:28

Napisany przez: dr_bonzo 13.06.2005, 21:03:51

cagrET: link do swietnego serwisu.

Napisany przez: hawk 13.06.2005, 21:51:34

@dr_bonzo i matid:
Niestety, phpDocumentor nie ma, AFAIK, takiego znacznika. Szkoda. Chociaż nic nie stoi na przeszkodzie taki sobie stworzyć. Precedens jest - w Javie wiele narzędzi posiada swoje własne znaczniki javadoc. Może @no-autoload?

Napisany przez: matid 13.06.2005, 22:12:12

Napisany przez: hawk 16.06.2005, 12:17:19

@matid: Pomysł wręcz genialny w swojej prostocie. Popieram. Jeżeli mamy wybrać najlepszą nazwę, to ja proponuję

Napisany przez: matid 16.06.2005, 15:48:55

No rzeczywiście, @scope będzie lepsze.
Spróbuję to jakoś zaimplementować, zobaczymy, co z tego wyjdzie

Napisany przez: hawk 16.06.2005, 18:31:01

@serafin:

1) Nikt ci nie broni tworzyć takiej mapy ręcznie. Gratuluję odwagi. I nadmiaru wolnego czasu.

2) Bezsensu. Zamiast napisac prosty skrypt do wyświetlania stron wy tworzycie 50 klas, jakieś wzorce, MVC, biblioteki. Przecież każdy wie, że najlepiej jest wrzucić wszystko do jednego pliku, a całe to OOP to jedna wielka ściema.

Pokaż swój autoloader, a wtedy możemy porozmawiać, co jest lepsze, a co jest bez sensu.

Napisany przez: hawk 16.06.2005, 20:42:41

Napisany przez: matid 16.06.2005, 22:08:29

[PHP] pobierz, plaintext 
<?php
 
/*
* File generated by OpenForce Autoloader
*/
 
	$aMap = http://www.php.net/array(
		'GLOBAL' => http://www.php.net/array(
			'IteratorFilter' => '/var/www/matid/Current/Autoloader/lib/IteratorFilter.class.php',
			'iClassMapGenerator' => '/var/www/matid/Current/Autoloader/lib/autoloader/interfaces/ClassMapGenerator.interface.php',
			'iClassMapEntry' => '/var/www/matid/Current/Autoloader/lib/autoloader/interfaces/ClassMapEntry.interface.php',
			'iClassMapWriter' => '/var/www/matid/Current/Autoloader/lib/autoloader/interfaces/ClassMapWriter.interface.php',
			'iClassMapCreator' => '/var/www/matid/Current/Autoloader/lib/autoloader/interfaces/ClassMapCreator.interface.php',
			'ClassMapGenerator' => '/var/www/matid/Current/Autoloader/lib/autoloader/ClassMapGenerator.class.php',
			'OFClassMapWriter' => '/var/www/matid/Current/Autoloader/lib/autoloader/OFClassMapWriter.class.php',
			'ClassMapEntry' => '/var/www/matid/Current/Autoloader/lib/autoloader/ClassMapEntry.class.php',
			'ClassMapCreator' => '/var/www/matid/Current/Autoloader/lib/autoloader/ClassMapCreator.class.php',
			'ClassMapWriter' => '/var/www/matid/Current/Autoloader/lib/autoloader/ClassMapWriter.class.php',
			'ClassNotFoundException' => '/var/www/matid/Current/Autoloader/lib/exceptions/ClassNotFoundException.class.php',
			'Autoloader' => '/var/www/matid/Current/Autoloader/lib/Autoloader.class.php',
			'Test2' => '/var/www/matid/Current/Autoloader/test/1/2.php',
			'Test3' => '/var/www/matid/Current/Autoloader/test/3.php',
		),
		'/var/www/matid/Current/Autoloader/test/1' => http://www.php.net/array(
			'Test1' => '/var/www/matid/Current/Autoloader/test/1/1.php',
		),
	);
 
Autoloader::addMap( $aMap );
 
?>
[PHP] pobierz, plaintext 

Napisany przez: bela_666 16.06.2005, 22:12:29

Napisany przez: Imperior 17.06.2005, 07:20:58

Napisany przez: matid 17.06.2005, 07:42:50

Chyba jednak skorzystam z opcji 1, ponieważ zasięgów nie chcę olewać, a tworzenie instancji przez proxy wyklucza takie przypadki jak dziedziczenie, implementowanie interfaców, itp.

Napisany przez: hawk 17.06.2005, 08:44:59

@serafin: Trochę konsekwencji. Bardzo się starasz, żeby nie odpowiadać na moje pytania i nie podejmować merytorycznej dyskusji. Zamiast tego widzę, że bardzo lubisz młotki i wymyśloną przez siebie klasę String, bo już drugi post o tym piszesz, co nijak się ma do tematu. Możemy i tak...

@matid: IMHO nie da się przeskoczyć problemu zadeklarowanej już wcześniej "pustej" klasy. Bo za drugim razem po prostu nie uruchomi się autoloader. A tworzenie każdej klasy za pomocą specjalnej metody też jest możliwe, ale to już nie to samo.

Ale zastanawia mnie, w jaki sposób jesteś w stanie stwierdzić, czy pozwolić na utworzenie obiektu? Odpala się autoloader, klasa ma zasięg "directory". W jaki sposób stwierdzasz, czy wolno w tym miejscu utworzyć obiekt? Bo mi nic nie przychodzi do głowy .

Napisany przez: matid 17.06.2005, 10:31:38

Korzystam z http://pl.php.net/debug_backtrace
Nie sprawdzałem, na ile jest to wydajne, ale działa
Innego pomysłu na razie nie mam.

Napisany przez: Imperior 17.06.2005, 15:12:25

Napisany przez: matid 17.06.2005, 15:41:10

[PHP] pobierz, plaintext 
<?php
	class Test1 extends Test2
	{
	}
?>
[PHP] pobierz, plaintext 

Napisany przez: bela_666 17.06.2005, 20:35:56

Fajna bajeczka : http://groups.google.pl/groups?q=proxy&hl=pl&lr=lang_pl&group=pl.comp.objects&c2coff=1&client=firefox-a&rls=org.mozilla:pl-PL%3a%6ffficial&selm=d2107t%24otc%241%40news.onet.pl&rnum=1

Napisany przez: Imperior 17.06.2005, 23:03:25

Napisany przez: squid 8.08.2005, 12:56:24

Jeszcze nie przeczytalem calego tematu wiec sory jesli odpowiedz juz padla ale czy nie mysleliscie o tym zeby wszystkie interfejsy trzymac w jednym lub kilku plikach pogrupowanych kategorie? Albo trzymac interfejs w pliku z klasa?
Moze to i troche malo eleganckie ale szkoda zapuszczac cala maszyne dla znalezienia i odczytania kilku linijek kodu a sa jeszcze klasy bez interfejsow

Napisany przez: hawk 8.08.2005, 21:39:27

Tak naprawdę to wszystkie interfejsy powinno się wywalić przed oficjalnym wypuszczeniem kodu. Przecież są do niczego niepotrzebne... pomijając oczywiście type hinty i inne bzdety, które też w związku z tym powinno się wywalić. I pomijając kilka wrednych sytuacji, w których jednak nie da się wywalić, i dlatego pewnie automatyczny wywalacz interfejsów jeszcze nie powstał .

Napisany przez: Vengeance 8.08.2005, 22:56:24

Wywalić interfejsy? A niby z jakiej racji?
Przecież po to są by szuko móc dojść co klasa musi miec itd w przyszłości...

Napisany przez: NuLL 8.08.2005, 23:02:05

@Hawk - napisać parser plików który będzie usuwał wszystko od słowa implements do napotkania słowa extends lub nawiasu klamrowego

Joking

Wg. mnie częśc interfejsów jest potrzebna. Jak chocby dla jakiegoś sterownika. Nóż, widelec ktoś będzie miał ochote napisać własny - od tego mam interfejs

Napisany przez: matid 9.08.2005, 07:36:32

Jeśli kod jest wydany na zasadach OpenSource to mimo wszystko nie wyrzucałbym interface'ów. Jak ktoś inny będzie chciał sobie dostosować ten kod, itd. to będzie miał ułatwione zadanie.

A co do oprogramowania z zamkniętym źródłem - na etapie pisania aplikacji - interface to bardzo przydatna rzecz, w release'ach to tylko zbędne przeciążenie aplikacji.

Napisany przez: hawk 9.08.2005, 14:25:03

Ale ja mówię o dwóch wersjach kodu: debug i release. Debug = mamy wszystkie komentarze, interfejsy, tak jak napisaliśmy. Release = wyrzucamy interfejsy, usuwamy komentarze, pakujemy po kilka klas do jednego pliku.

Też z tego powodu, że - jak wykazało profilowanie - autoloadowanie jest strasznie wolne.

Napisany przez: chmolu 9.08.2005, 14:59:17

No jakoś mi się nie widzi usuwanie w kodzie $obj instanceof interfejs oraz zmienianie deklaracji funkcji, w których używam typehintingu.
Wcale nie uważam, że interfejsy są zbędne. Autoładowanie może i jest wolne, ale z włączonym akceleratorem różnica jest niewielka. Wiem, że nie każdy ma dostęp do akceleratora, ale dalej uważam, że usuwanie interfejsów z kodu to bezsens.

Napisany przez: squid 9.08.2005, 15:12:26

Napisany przez: NuLL 17.01.2006, 11:49:38

Macie może jakiś pomysł co zrobić z autoloaderem kiedy jest w nim 300 plikow ? Wiem ze to troche duzo ale tyle sie nazbieralo kolejnych klas, wyjatkow oraz interfejsow. I nie wiem co z tym zrobic ?

Ja wpadłem na pomysl aby zaladowac tylko najpotrzebniejsze mapy : request, db oraz kilka innych. Natomiast inne mapy mozna by ladowac np rozbijajac nazwe klasy z niej wyciagac dwa pierwsze czlony zalozmy i czyli nazwa pakietu i wtedy zaladowac mape do ktorej nalezy ta konkretna klasa. Co w Wy na to ?

Chetnie poslucham innych pomyslow.

Napisany przez: bigZbig 17.01.2006, 12:18:57

Mozna zastosowac cos w rodzaju przestrzeni nazw. Wszystko zależy od tego jaki sie przyjelo sposob nazewnictwa. Ja wszystkie klasy z danego pakietu poprzedzam nazwa danego pakietu. W ten sposob moglbym latwo podzielic automape na kilka mniejszych czesci. Oczywiscie metoda ta nie nadaje sie do cudzych klas, ktore stosuja odmienna polityke nazewnictwa. Poza tym, na dobra sprawe jest to jedynie polowiczne rozwiazanie gdyz czesto np. na 20 klas z danego pakietu potrzebnych jest zaledwie 5.

Pozostaje rowniez problem odroznienia w nazwie klasy tego co jest przedrostkiem.

Jesli - mojPrzedrostek_wygladaTak.class.php - to nie ma problemu
Niestety - mojPrzedrostekWygladaTak.class.php - a to juz jest problem

Napisany przez: NuLL 17.01.2006, 12:23:08

Ja cos takiego robie tzn mam ezcCacheStorageFileArray i rozbijam to po wielkosci znakow pomijajac pierwszy czlon pisany z malej litery i laduje mape to dla ezcCache.

Co do polowicznosci sie zgadzam m.in dlatego ostatnio twoje wiecej malych map

Napisany przez: bela_666 17.01.2006, 12:57:03

A po co rozbijac? Ja mam kilkaset linijek i smiga.
Poza tym zobacz do phienda 2, tam masz w kazdym komponencie osobną mape

Napisany przez: squid 17.01.2006, 13:12:04

co nazywacie mapa? Czy jest to skojarzona z klasa sciezka dostepu (dla kazdej klasy)?

Napisany przez: NuLL 17.01.2006, 13:18:13

Napisany przez: Ociu 17.01.2006, 14:28:28

[PHP] pobierz, plaintext 
<?php
$map = http://www.php.net/array (
# przyklad: 'nazwa_klasy' => 'sciezka_do_pliku.php'
'Request' => './framework/request.class.php',
'Response' => './fremework/response.class.php'
);
 
Autoloader::addMap($map);
?>
[PHP] pobierz, plaintext 

Napisany przez: bela_666 17.01.2006, 19:16:03

NuLL, pytanie moje brzmi, czy każdy komponent może pracować oddzielnie? Tzn robisz ctrl c, v, wrzucasz do innego katalogu i działa.
Btw. co Ty masz w tych komponenach?

Napisany przez: NuLL 17.01.2006, 20:06:44

bela_666 - moze, nie wszystkiego bo czesc jest zalezna od Db dla przykladu.

Co mam ? Db, Cache, Configuration, Template, Debug, Image itp itd. - Cala aplikacja krotko mowiac.

Napisany przez: hawk 24.01.2006, 08:54:37

@NULL: IMHO rozwiązaniem problemu ze zbyt dużą liczbą wpisów jest sklejenie tego we większe pliki. Autoloadowanie tego wszystkiego zajmuje jednak sporo czasu. Ideałem jest dla mnie rozwiązanie, gdy po ustaleniu, jakie komponenty są nam potrzebne, robimy z tego wersję release pakując automatycznie do jednego pliku i tak dystrybuujemy. Lokalnie mamy wersję dev z rozbiciem na małe pliki, a dzięki autoloaderowi cała operacja jest przezroczysta - mamy tylko inną mapę. Natomiast plików specyficznych dla konkretnego żądania, np. klas akcji, nie warto pakować do mapy, bo by się zbyt duża zrobiła.

Napisany przez: squid 14.02.2006, 13:34:38

[PHP] pobierz, plaintext 
<?php
function __autoload ( $className )
{
	$classDir = './class/';
	$separator = '_';
 
	$path2Class = http://www.php.net/str_replace ( $separator, '/', $className );
 
	require_once $classDir . $path2Class . '.class.php';
}
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
// moze byc zaladowane duzo wczesniej np. przez kontroler
require_once './autoload.lib.php';
 
class a
{
	public function __construct ()
	{
		http://www.php.net/echo "<p>Zaraz zaladuje nowa klase </p>";
		new katalog_b ();
	}
}
 
new a();
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
class katalog_b
{
	public function __construct ()
	{
		http://www.php.net/echo "jestem w klasie b </ br>";
	}
}
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
 
function __autoload ( $className )
{
	$classDir = './classes/';
	$classSuffix = '.class.php';
 
	$interfaceDir = './interfaces/';
	$interfaceSuffix = '.php';
 
	$exceptionDir = './exceptions/';
	$exceptionSuffix = '.php';
 
	$separator = '_';
 
	if ( $className[0] == 'i' )
	{ // interfejs
		$file = $interfaceDir . http://www.php.net/str_replace ( $separator, '/', $className ) . $interfaceSuffix;
	}
	else if ( $className[0] == 'e' )
	{ // wyjatek
		$file = $exceptionDir . http://www.php.net/str_replace ( $separator, '/', $className ) . $exceptionSuffix;
	}
	else 
	{ // klasa
		$file = $classDir . http://www.php.net/str_replace ( $separator, '/', $className ) . $classSuffix;
	}
 
	if ( !http://www.php.net/file_exists(  $file) )
	{
		throw new eClassNotFound();
	}
 
	require $file;
}
?>
[PHP] pobierz, plaintext 

Napisany przez: eMartio 31.03.2006, 19:40:31

Napisany przez: matid 31.03.2006, 20:25:42

Napisany przez: bela_666 31.03.2006, 20:51:29

Napisany przez: NuLL 27.05.2006, 16:52:38

Czy ktos moze wykonywal testy po jakims ciezkim obciazeniem aplikacji pracujacej na autoloaderze i bez niego ? Chetnie bym posluchal jakis opinii. Wiem ze jest to dosc wolne ale czy az tak Zastanawia mnie tak kwiestia jakoze zalozmy Panowie z ez.no postanowili w eZ Components jechac na autoloadzie napewno zdajac sobie sprawe z problemu wydajnosci

Co sadzicie o tym ? Pisac z __autoload() czy bez ?

Napisany przez: Ludvik 27.05.2006, 21:44:26

Ja osobiście wszystko mam przygotowane pod autoloadera. Co z wydajnością? Przy cache mapy klas i włączonym xdebugu załadowanie wszystkich klas i systemu zajmuje ok. 35ms, a samo nawiązanie połączenia przez PDO z PostgreSQL na localhoście ok. 230, więc strata wydajności nie jest duża. Z tych 35ms połowa to require_once. Myślę, że nie jest to zbyt duża strata wydajności w porównaniu do ułatwienia pisania kodu.

Na poważnych serwerach kod zenda jest i tak trzymany w pamięci, więc straty są jeszcze mniejsze.

Napisany przez: squid 27.05.2006, 22:19:50

przy dobrym projekcie autoloadera mozna ominac f-cje *_once mozna podniesc wydajnosc tak ze autoloadowanie bedzie praktycznie niezauwazalne

Napisany przez: NuLL 28.05.2006, 15:16:33

@Ludvik - dzieki za wiesci - o cos takiego mi chodzilo Teraz tylko czekac na otwarty autoloader od eZ components i po bolu.

Napisany przez: Vengeance 10.06.2006, 17:38:21

To ciekawe co mówicie, bo w mojej aplikacji autoload() zajmował 98% czasu wykonywania (tak, tak... i to już z cache mapy w pliku!). Wróciłem do require_once. Zresztą takie rozwiązanie jest dużo czytelniejsze przy późniejszej analizie kodu. Wiadomo gdzie co jest trzymane

Napisany przez: squid 10.06.2006, 19:07:47

Cytat(Vengeance @ 10.06.2006, 18:38 )

To ciekawe co mówicie, bo w mojej aplikacji autoload() zajmował 98% czasu wykonywania (tak, tak... i to już z cache mapy w pliku!). Wróciłem do require_once. Zresztą takie rozwiązanie jest dużo czytelniejsze przy późniejszej analizie kodu. Wiadomo gdzie co jest trzymane

Napisany przez: bigZbig 12.06.2006, 08:04:11

Ja tez uzywam autoloadera, ale nie tworze jednej globalnej tablicy, a juz napewno nie generuje jej automatycznie. Staram się tworzyć pakiety. Kazdy pakiet ma swoj plik inicjalizacyjny, w ktorym jest m.in. mapa klas. Jesli dolaczam dany moduł (pakiet) do aplikacji poprzez includowanie jego pliku inicjalizujacego to juz mechanizm zawarty w tym pliku zajmuje się dołączeniem mapy klas danego pakietu do ogolnej mapy klas całej aplikacji na ktorej operuje funkcja __autoload. Dla wygody testowania zaimplementowalem tez mozliwosc ominiecia autoloadera. Tracę tym może nieznacznie na wydajności, ale znacznie zyskuję na wygodzie. Poniższy przykład ilustruje to o czym pisałem:

[PHP] pobierz, plaintext 
<?php
/**
 * @author hawk
 */
class bigAutoloader {
  private http://www.php.net/static $aMap = http://www.php.net/array();
 
  public http://www.php.net/static function load($sName) {
	if (http://www.php.net/array_key_exists($sName, self::$aMap)) {
	  include self::$aMap[$sName];
	}
	if (!class_exists($sName) && !interface_exists($sName)) {
	  http://www.php.net/eval("class $sName { 
			  public function __construct() { 
				throw new ClassNotFoundException('$sName not found'); 
			  }
			}");
	}
  }
 
  public http://www.php.net/static function addMap($aMap) {
	self::$aMap = http://www.php.net/array_merge(self::$aMap, $aMap);
  }
}
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
/**
 * bigLang inicjalizator
 */
if (!http://www.php.net/defined('BIGLANG_DIR')) http://www.php.net/define('BIGLANG_DIR',http://www.php.net/dirname(__FILE__));
$aClassesMap = http://www.php.net/array(
  'bigLang' => BIGLANG_DIR.'/bigLang.abstract.php',
  'bigLangManager' => BIGLANG_DIR.'/bigLangManager.class.php',
);
 
if (class_exists('bigAutoloader')) {
	bigAutoloader::addMap($aClassesMap);
} else {
  foreach($aClassesMap as $sClassName) {
	include_once($sClassName);
  }
}
 
?>
[PHP] pobierz, plaintext 

Napisany przez: Vengeance 12.06.2006, 13:46:28

Jakie argumenty by tu nie padały, i tak nic nie zmieni mojego "self experience" gdzie Zend pokazywał 98% dla samego autoloadu.

Ja nie twierdze, że ta metoda jest cool, albo że jest do dupy. Mówię tylko, że z początku stosowałem ją ale zrezygnowałem.

Jednym z argumentów przeciw jest choćby czytelność kodu (z mojego punktu widzenia).

Że już nie wspomne o np. umiejetnośći podpowiadania składni w edytorach :] Które bardzo mocno wspierają się na include i require w kodzie... a autoload powoduje oduczenie ich umiejętności poprawnego podpowiadania.

Napisany przez: bigZbig 13.06.2006, 06:52:15

Argument o czytelności kodu do mnie nie przemawia bo wszystkie pliki dolanczam (dokladam do mapy klas) w scisle okreslonych miejscach. W plikach poszczegolnych klas nie ma miejsca na dolanczanie zaleznosci jak np. definicje wyjatkow. Od tego mam plik inicjalizujacy dany pakiet i jest to wygodne. W zasadzie przy takim podejsciu to nie ma znaczenia czy uzyjesz autoloadera, czy bezposrednio require.

Wada tego rozwiazania jest oczywiscie to, ze chcac uzyc tylko jednej klasy z calego pakietu musisz sie upewnic czy do jej dzialania nie jest wymagana obecnosc jakiegos innego pliku.

Co do edytorow i podpowiadania skladni - argument wart przemyslenia. Tak swoja droga jakiego edytora uzywasz?

Napisany przez: NuLL 13.06.2006, 16:36:42

Napisany przez: orson 13.06.2006, 17:37:21

witam

eclipse przechowuje informacje o wszystkich klasach w cache ... więc w nim nie ma problemu z używaniem metod z obiektów nie włączonych jawnie do kodu ...

używam autoloadera z mapą i uważam że jest to bardzo wydajne i wygodne rozwiązanie ... jak mi się uda to włączę xdebuga na jakimś serwerze u mnie w pracy i zrobię testy i profilowanie na żywej aplikacji (ale to po długim weekendzie dopiero)

pozdrawiam

Napisany przez: eai 5.08.2006, 16:28:49

Ja generuje sobie mapę przy instalacji aplikacji. Zapisuje w pliku tekstowym z zakodowanym serialize();

Mapa wyglada tak:

Napisany przez: squid 5.08.2006, 16:44:16

"bigZbig dla kaydego pakietu musisy kopiowac inicjaliyator cyz autoloade

Napisany przez: mtod 8.08.2006, 16:21:45

Przepraszam, ale nie doczytałem tego wątku od deski do deski - limit czasu.
Kiedyś pisałem i niedawno też opisałem taką klasę autoloadera. http://metoda.wordpress.com/2006/07/20/autoloader-dla-php5/. Wszelkie sugestie/komentarze wezmę chętnie pod uwagę =)

Napisany przez: lukir 8.08.2006, 23:27:40

Mógłby ktoś z was podsumować wszystkie te rozważania jakimś zgrabnym kodem autoloader'a? Taki najbardziej wydajny i uniwersalny?


@mtod: Fajna ta klasa, ale możnaby dla większej elastyczności dodać możliwość ładowania również nowych klas...

Napisany przez: mtod 9.08.2006, 11:57:53

@lukir: nie rozumiem, jak to: "nowych"?

Napisany przez: lukir 12.08.2006, 10:24:01

@mtod: na podanej przez Ciebie stronce jest napisane coś takiego:

Napisany przez: Ludvik 12.08.2006, 10:30:55

Wtedy ten autoloader straci na wydajności. Każdorazowe sprawdzanie całego drzewa katalogów jest czynnością zajmującą masę czasu. W moim systemie odświeżenie cache jest równe skasowaniu jednego pliku, więc nie wiem czy to takie męczące.

Napisany przez: squid 12.08.2006, 11:09:43

wracajac do wydajnosci __autoload() to wspomniane wczesniej 90% czasu wykonania to jaka bzdura. Ponizej przedstawiam Wam wynik szybkiego profilowania mojej przykladowej aplikacji programem PECL APD

[PHP] pobierz, plaintext 
<?php
new JakasKlasa();
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
include 'JakasKlasa.php';
new jakasKlasa();
?>
[PHP] pobierz, plaintext 

Napisany przez: Denver 18.08.2006, 22:52:45

Ja, wykorzystując ujednolicone nazewnictwo klas, korzystam z autoloadera w taki sposób:

[PHP] pobierz, plaintext 
<?php
function __autoload ($strClass)
{
	if ($strClass == 'Actions')
	{
		require_once ('./modules/class.Actions.php');
	}
	elseif (http://www.php.net/preg_match ('/Admin$/', $strClass))
	{
		require_once ('./modules/admin/lib/class.'.$strClass.'.php');
	}
	elseif (http://www.php.net/preg_match ('/Exception$/', $strClass))
	{
		require_once ('./lib/exceptions/class.'.$strClass.'.php');
	}
	else
	{
		require_once ('./modules/lib/class.'.$strClass.'.php');
	}
}
?>
[PHP] pobierz, plaintext 

Napisany przez: LBO 16.01.2007, 20:23:45

Bardzo przydatne przy pisaniu autoloadera mogą być funkcje http://pl.php.net/get_declared_classes i http://pl.php.net/get_declared_interfaces. Niestety wiążą się z tym pewne problemy:

• W przeciwieństwie rozwiązań tutaj przedstawionych, powyższe funkcje muszą załadować plik i zarejestrować klasę, czyli przy dużym projekcie autoloader mógłby się wysypać w związku z ograniczeniami wielkości pamięci.
• Strukturalny kod zawarty w pliku zostaje wykonany przy załadowaniu np.

  [PHP] pobierz, plaintext 
  <?php
  http://www.php.net/exit()
  ?>
  [PHP] pobierz, plaintext 

Napisany przez: dr_bonzo 16.01.2007, 21:57:56

Napisany przez: LBO 16.01.2007, 22:06:02

Ten exit() to tylko przykład, nie mający zastosowania w prawdziwych aplikacjach. Zastąp to sobie czymkolwiek zechcesz. Chodzi o sam fakt, że model obiektowy php dopuszcza do takiego czegoś.

Napisany przez: NuLL 17.01.2007, 15:13:32

Napisany przez: athabus 17.01.2007, 16:08:59

Ja napisałem sobie prosty autoloader - szczerze mówiąc jest tak prosty, że aż boli, ale nie wiem czego jeszcze mógłbym oczekiwać od tej klasy

Składają się na niego 2 klasy.

->Klasa główna korzysta z mapy plików (serializowana tablica klasa=>plik). Użyłem singletona dlatego mapa jest odczytywana tylko raz na początku skryptu. Jeśli plik znajduje się w mapie to wiadomo - odczyt jest banalnie prosty. Jeśli natomiast plik jest nowy/zmieniła się jego lokalizacja itp, to autoloader sam go wyszukuje. W tym celu autoloader ma scieżki, w których ma szukać oraz dodatkowo głębokość katalogów na jakiem ja szukać czyli np.

$autoloader->addLocalization('sciezka', 5) oznacz ze ma szukac w katalogu 'sciezka' oraz rekurencyjnie do 5 katalogów niżej. Po pierwszym odnalezieniu pliku sciezka jest zapisywana do mapy i przy następnych wywołaniach przeszukiwania katalogów nie jest już potrzebne.

->klasa pomocnicza wykonuje operacje przeszukiwania katalogów itp.


Oczywiście autoloader może mieć wskazanych kilka lokalizacji, w których ma szukać plików itd.

Rozwiązania nigdy nie testowałem pod względem wydajności (piszę amatorsko więc nie zakładam, abym kiedyś popełił serwis o dużym obciążeniu), ale na logikę to rozwiązanie jest bardzo szybkie i nie powoduje zbędnych obciążeń.

Jedno ograniczenie, to sposób wyszukiwania -> każda klasa musi być w osobnym pliku.

To rozwiązania wydaje mi się najlepsze i na pewno jest bardzo wygodne.

Napisany przez: bigZbig 17.01.2007, 16:52:03

Problem z mapą obrazków jest tylko taki, że za każdym razem trzeba ją całą załadować nawet jeśli żadnej nie użyjemy. Było już tutaj o tym, że można taką mapę podzielić na mniejsze zbiory, ale jest z tym troszkę zachodu. Lepszym rozwiązaniem jest sposób zastosowany w Zend Frameworku kiedy to nazwa klasy wskazuje na jej lokalizację w systemie. Wady tego podejścia są zasadniczo dwie. Po pierwsze dla każdej klasy trzeba wykonać parsowanie nazwy na ścieżkę, ale to pikuś, a po drugie jest to rozwiązanie mało elastyczne, które sprawdzi się tylko dla klas o odpowiedniej nazwie.

Napisany przez: athabus 17.01.2007, 17:18:00

W zf jest to bardzo fajnie rozwiązane - tu się zgodzę w 100%, ale bynajmniej nie z powodu wydajności, a z powodu przejżystości. Nie wiem jak u was, ale dla mnie to jest bardzo intuicyjne rozwiązanie jeśli chodzi o użytkowanie. Już sie nie zastanawiam czy tworzyć obiekt zend_db_table czy zend_table_db. Zamierzam w przyszłości przerobić swój zestaw klas na taką strukturę.

Ale wracając do mapy, to szczerze wątpię czy może ona stanowić realne obciążenie dla aplikacji (oczywiście zakładając, że nie składa się ona z tysięcy plików). Obecnie piszę mały projekcik w których korzystam właśnie z ZF + +/- 40 klas (przy includowaniu klas ZF korzystam z mechanizmu dostarczonego przez ZF i nie zapisuje scieżek do plików). Mapa zwiera zatem 40 scieżek. Myślę, że odczyt plus deserializacja to jest chwila.
Pytanie co by było gdybym includował wszystkie klasy ZF poprzez mój mechanizm (czyli 383 pliki)... Na to pytanie nie potrafię jednak odpowiedzieć bo nie wiem jak kosztowna jest deserializacja.

Napisany przez: J4r0d 18.01.2007, 00:50:57

Przeczytałem cały wątek (trochę czasu to zajęło) i mam kilka pytań dla bardziej wtajemniczonych:

1. Zastanawiam się po co korzystać z autoloadera? Tylko po to, żeby nie trzeba było ręcznie dołączać plików z klasami?
Załóżmy, że mamy klasę A i klasę B. Klasa B dziedziczy po klasie A. Czy nie lepiej już w pliku z klasą B dodać require_once('klasa A')? Po co do tego wykorzystywać autoloader?

2. Rozumiem, że po wygenerowaniu mapy zapisujecie ją do pliku. Jak serializacja wpływa na wydajność? Czy warto jeszcze kodować jakimś algorytmem zserializowane wartości?

3. Dlaczego tak bardzo zależy Wam na uniwersalności. Przecież tworząc sobie framework czy coś innego, mamy pewien zarys jak to ma wyglądać. Jeśli będę korzystał ze swojego frameworka i jakiś innych bibliotek, to swoje klasy mogę ładować swoim autoloaderem a klasy innych bibliotek innym sposobem czyli najlepiej ręcznie (?)

4. Jaki macie sposób nazywania klas? Ja stosuję Nazwaprojektu_Nazwaklasy.class.php, np.
Cube_Mysql.class.php
Cube_Config.class.php
Cube_ConfigException.class.php
Cube_Exception.class.php

5. Czy ktoś z Was oprócz @squid'a testował jak ma się sprawa z wydajnością? Zastanawiam się czy warto go pisać, ale jeśli spróbuję to na pewno wykorzystam mapy i cache.

Napisany przez: dr_bonzo 18.01.2007, 01:06:33

Napisany przez: J4r0d 18.01.2007, 01:16:20

Cytat(dr_bonzo @ 18.01.2007, 01:06:33 )

Cytat(dr_bonzo @ 18.01.2007, 01:06:33 )

Napisany przez: dr_bonzo 18.01.2007, 09:09:06

Napisany przez: cadavre 18.01.2007, 16:52:08

Ja nazywam klasy nazwa_klasy.class.php - to chyba najlepsze rozwiązanie. Klasy narzędziowe trzymam w jednym folderze i ładuję je autoloaderem, który tylko sprawdza czy dany plik istnieje (j.w.) - jeśli tak - ładuje go; nie - błąd. Co do ładowania klas z modułami etc. chyba zastanowię się nad metodą, którą opisał athabus - brzmi ona ciekawie.

Napisany przez: DjKermit 22.01.2007, 12:26:38

Witam.
Ja wykombinowałem coś takiego:
Klasa:

[PHP] pobierz, plaintext 
<?php
class ClassLoader {
 
	/**
	 * Class file name sufix
	 *
	 * @var string
	 */
	private $file_sufix = '.class.php';
 
	/**
	 * Class map cache file name
	 *
	 * @var string
	 */
	private $cache_file_name = 'class_map_cache.ini.php';
 
	/**
	 * Path to cache file
	 *
	 * @var string
	 */
	private $cache_file_path = CONFIG_PATH;
 
	/**
	 * Root path of the project
	 *
	 * @var string
	 */
	private $base_path = BASE_PATH;
 
	/**
	 * Path to class files & packages
	 *
	 * @var string
	 */
	private $class_path = CLASS_PATH;
 
	/**
	 * All files paths from readed dir
	 *
	 * @var array
	 */
	private $readed_dir;
 
	/**
	 * Class map content
	 *
	 * @var array
	 */
	private $class_map;
 
	/**
	 * ClassLoader class instance
	 * 
	 * @var ClassLoader
	 */
	private http://www.php.net/static $instance;
 
 
 
 
	/**
	 * Constructor
	 * 
	 * @access private
	 */
	private function __construct() {
		$this->getClassMap();
	}
 
	/**
	 * Gets singleton instance of ClassLoader class
	 *
	 * @return ClassLoader
	 * @access public
	 */
	public http://www.php.net/static function getInstance() {
		if (http://www.php.net/is_null(self::$instance)) {
			self::$instance = new self;
		}//end if
		return self::$instance;
	}
 
 
 
 
	/**
	 * Loads single class or all class package 
	 *
	 * @param string $class_name - name of class to load
	 * @access public
	 */
	public function load($class_name) {
		$class_name = http://www.php.net/str_replace('.', DIRECTORY_SEPARATOR, $class_name);
		if (http://www.php.net/strstr($class_name, '*')) {	// load all class package
			$package_path = http://www.php.net/str_replace('*','', $class_name);
			$classes_arr = $this->getDirContents($this->class_path . $package_path);
			$this->loadClass($classes_arr);
		}else{	// load single class
			$path = $this->class_path . $class_name . $this->file_sufix;
			$this->loadClass(http://www.php.net/array($class_name => $path));
		}//end if
	}
 
 
	/**
	 * Serches for requested class in entire project and loads automaticly if found
	 *
	 * @param string $class_name
	 * @access public
	 */
	public function autoLoad($class_name) {
		if (http://www.php.net/array_key_exists($class_name, $this->class_map) && http://www.php.net/file_exists($this->class_map[$class_name])) {
			require_once($this->class_map[$class_name]);
		}else{
			$this->generateClassMap();
			if (http://www.php.net/array_key_exists($class_name, $this->class_map) && http://www.php.net/file_exists($this->class_map[$class_name])) {
				require_once($this->class_map[$class_name]);
			}else{
				throw new Exception('Class AutoLoad failed, file '. $class_name . $this->file_sufix .' not found');
			}//end if
		}//end if
	}
 
 
	/**
	 * Loads class
	 *
	 * @param array $path
	 * @access private
	 */
	private function loadClass($path) {
		foreach($path as $key => $val) {
			if (http://www.php.net/file_exists($val)) {
				require_once($val);
			}else{
				throw new Exception('Load class failed, file '. $key . $this->file_sufix .' not found');
			}//end if
		}//end foreach
	}
 
 
	/**
	 * Reads class map from cache
	 *
	 * @access private
	 */
	private function getClassMap() {
		if (http://www.php.net/file_exists($this->cache_file_path . $this->cache_file_name)) {
			$this->class_map = http://www.php.net/parse_ini_file($this->cache_file_path . $this->cache_file_name);
		}else{
			if (!http://www.php.net/is_dir($this->cache_file_path)) http://www.php.net/mkdir($this->cache_file_path);
		}//end if
		if (http://www.php.net/empty($this->class_map)) $this->generateClassMap();
	}
 
 
	/**
	 * Generates new class map
	 *
	 * @access private
	 */
	private function generateClassMap() {
		$this->getDirContents($this->base_path);
		$this->class_map = $this->readed_dir;
		$this->saveClassMap();
	}
 
 
 
	/**
	 * Saves class map into a cache file
	 *
	 * @access private
	 */
	private function saveClassMap() {
		$str = ";<?php die('Configuration file, all data confidential'); ?>rnrn";
		foreach($this->class_map as $key => $val) {
			$str .= $key .' = '. $val . "rn";
		}//end foreach
		file_put_contents($this->cache_file_path . $this->cache_file_name, $str);
	}
 
 
	/**
	 * Gets specified directory contents recursively
	 *
	 * @param string $path
	 * @return array
	 * @access private
	 */
	private function getDirContents($path) {
		$this->readed_dir = http://www.php.net/array();
		$this->readDir($path);
		return $this->readed_dir;
	}
 
 
	/**
	 * Reads specified directory & if file name contains "class" substring adds path to $readed_dir array
	 *
	 * @param string $path
	 * @access private
	 */
	private function http://www.php.net/readdir($path) {
		if ($handle = http://www.php.net/opendir($path)) {
			while (($file = http://www.php.net/readdir($handle)) !== false) { 
				if (http://www.php.net/is_file($path . $file) && http://www.php.net/strstr($file, 'class') && !http://www.php.net/strstr($file, 'ClassLoader')) {
					$this->readed_dir[http://www.php.net/str_replace('.class.php', '', $file)] = $path . $file;
				}else if (http://www.php.net/is_dir($path . $file) && $file != '.' && $file != '..') {
					$this->readDir($path . $file . DIRECTORY_SEPARATOR);
				}//end if
			}//end while
			http://www.php.net/closedir($handle);
		}//end if
	}
 
}
 
 
 
/**
 * Class auto loader
 * 
 * @param string $class_name
 */
function __autoload($class_name) {
	$cloader = ClassLoader::getInstance();
	$cloader->autoLoad($class_name);
}
 
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
/** Base path */
http://www.php.net/define('BASE_PATH', http://www.php.net/dirname(__FILE__) .'/');
/** Path to config files */
http://www.php.net/define('CONFIG_PATH', BASE_PATH . 'config/');
/** Path to class and interface files */
http://www.php.net/define('CLASS_PATH', BASE_PATH .'classes/');
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
require_once('config.php');
require_once(CLASS_PATH .'core/ClassLoader.class.php');
$c_loader = ClassLoader::getInstance();
$c_loader->load('core.JakasKlasa'); // ładuje wskazaną klasę w "paczce" core
$c_loader->load('core.*'); // ładuje całą "paczkę" core
$c_loader->autoLoad('Smarty'); // odszukuje w całym projekcie wskazanej klasy i ładuje jeśli znajdzie
?>
[PHP] pobierz, plaintext 

Napisany przez: hwao 23.01.2007, 18:14:47

Bardzo ładna klasa, mi się podoba - jakbym stosował autoload to bym mógł ją spokojnie użyć.

Paser ini jest szybszy od serialize to też dodatkowy plus.

[PHP] pobierz, plaintext 
<?php
if (http://www.php.net/strstr($class_name, '*')) {	// load all class package
			$package_path = http://www.php.net/str_replace('*','', $class_name);
			$classes_arr = $this->getDirContents($this->class_path . $package_path);
?>
[PHP] pobierz, plaintext 

Napisany przez: DjKermit 23.01.2007, 18:28:59

Dzięki bardzo.

Cytat(hwao @ 23.01.2007, 18:14:47 )

Napisany przez: Turgon 23.01.2007, 18:32:35

Hmm... Klasa ciekawa i sporo wyjaśnia Dzięki. ale ja mam odmienny problem. Jak się ma sprawa z autoloadem interfejsów? Jak nie ma jest uruchamiana funkcja autoload?

Napisany przez: bigZbig 24.01.2007, 16:19:57

Ja nazywam swoje klasy zgodnie z konwencją przyjętą w Zend Frameworku. Oczywiście zamiast prefixu Zend daje swój. DjKermit - narzucając obowiązek nadawania klasom sufixu class.php ograniczasz swojego autoloadera jedynie do klas swojego autorstwa i klas, które zawarte są w plikach o nazwach stosujących tę konwencję. Gdzieś na początku tego tematu jest przykład bardziej uniwersalnego skanera.

Dlaczego serializujecie swoje mapy albo tez parsujecie do postaci pliku ini? Nie lepiej zapisywać je od razu jako tablicę i na dzień dobry tę tablicę includować?

Napisany przez: Turgon 25.01.2007, 15:51:37

bigZbig: Podobno szybsze jest Ale zastanowię się nad tabliczką .

Napisany przez: DjKermit 25.01.2007, 17:52:44