(function(x){
 alert(x*2);
})();

Pozwala Ci to izolować zmienne w funkcji i spać spokojnie. Chciałbym móc zrobić coś takiego w PHP, od wersji 5.3 są domknięcia, więc teoretycznie powinno się dać.
Nie udało mi się jednak znaleźć tak zgrabnego rozwiązania. Jednak po kolei:

$myFunc = function() {
  echo "123";
};
$myFunc();

Jednak ciągle mamy tu zmienną $myFunc – istnieje ryzyko, że właśnie ją komuś nadpisujemy.

function inv($func){
  return $func();
}
inv(function(){ alert "123"; });

Już lepiej. Jednak chciałbym móc przekazać parametr(y) do mojej IIF. Dlatego finalna wersja mogłaby wyglądać tak:

function inv($func){
  $args = array();
  if(func_num_args() >1) {
    $args = func_get_args();
    unset($args[0]);
  }
  return call_user_func_array($func, $args);
}

$x = "global x";
inv(function($x){
  echo "=== inside";
  var_dump($x);
  $x = "local x";
  var_dump($x);
  echo "=== /";
}, $x);
var_dump($x);

Dzięki temu masz miło wyizolowaną zmienną $x i wszyscy są szczęśliwi. Taki mały Snippet of the day.

Tak z zupełnie innej beczki: znalazłem dziś w kodzie zmienną $Darek ;)

Tak czy siak, podzielę się z Wami moimi pomysłami.

Zacznijmy od początków. Przeciwieństwem leniwego ładowania jest ładowanie gorliwe (lub zachłanne), to znaczy ładowanie na zapas wszystkiego co może okazać się potrzebne. Warstwa modelu w cake’u mogła by wyglądać tak (duże uproszeczenie, jedyna możliwa relacja to belongsTo).

Eager Loading

class Model {
	function find(){

		$r = new ReflectionClass($this);
		print "calling ".$r->getName()."::find($conditions)";

		$query = "Select * from `".strtolower($r->getName())."s` ".
					"as `".$r->getName()."`";

		var_dump($query);

		//return query result
	}

	function __construct(){
		$r = new ReflectionClass($this);
		print("creating ".$r->getName()."
");
		if(isset($this->belongsTo) && is_array($this->belongsTo)){
			foreach($this->belongsTo as $related){
					$this->{$related} = new $related();
			}
		}
	}
}

class User extends Model{
	protected $belongsTo = array("Group");
}

class Group extends Model{
}

$user =  new User();

$user->find();
echo "
";
$user->Group->find();

Widzimy, że obiekt Group jest inicjowany długo przed użyciem:

creating User
creating Group
calling User::find()

string 'Select * from `users` as `User`' (length=31)

calling Group::find()

string 'Select * from `groups` as `Group`' (length=33)

Mało tego, ładuje się nawet jeśli nigdy nie wywołamy metody w tym obiekcie (zakomentuj $user->Group->find(); żeby się o tym przekonać).

Lazy Loading

class Model {
	function find(){

		$r = new ReflectionClass($this);
		print "calling ".$r->getName()."::find($conditions)";

		$query = "Select * from `".strtolower($r->getName())."s` ".
					"as `".$r->getName()."`";

		var_dump($query);

		//return query result
	}

	function __construct(){
		$r = new ReflectionClass($this);
		print("creating ".$r->getName()."
");
	}

	function __get($property){
		if(!isset($this->{$property})) {
			$this->{$property} = new $property();
		}
		if(in_array($property, $this->belongsTo)){
			return $this->{$property};
		}else{
			$r = new ReflectionClass($this);
			throw new Exception(
				"$property not related with {$r->getName()}"
			);
		}
	}
}

class User extends Model{
	protected $belongsTo = array("Group");
}

class Group extends Model{
}

$user =  new User();

$user->find();
echo "
";
$user->Group->find();

W tym rozwiązaniu obiekt Group nie zostanie stworzony, dopóki nie będziemy go potrzebować. Wykorzystana jest do tego magiczna metoda __get, która jest wywoływana wtedy, gdy próbujemy się odnieść do atrybutu obiektu, który nie istnieje.

ale pozostaje kwestia wyszukiwania w modelu tak, żeby zwrócił powiązane dane
np.: var_dump($user->find());

array
  0 =>
    array
      'User' =>
        array
          'id' => int 1
          'name' => string 'Franek' (length=6)
      'Group' =>
        array
          'id' => int 1
          'name' => string 'Admin' (length=5)
  1 =>
    array
      'User' =>
        array
          'id' => int 2
          'name' => string 'Janek' (length=5)
      'Group' =>
        array
          'id' => int 10
          'name' => string 'User' (length=4)

Wiemy, że belongsTo oznacza, że User powinien mieć pole (group_id), zatem query powinno wyglądać mniej więcej tak:

Select User.id, User.name, Group.id, Group.name from users as User
Inner Join groups as Group on (User.group_id = Group.id)

W tej chwili cakephp zawiera behavior containable, jednak on polega na załadowanych już modelach.

Zostańmy przy terminologii cake’a i przyjmijmy, że będziemy przekazywać informacje na temat powiązanych elementów w zmiennej $contain

function find($contain=null)

Teraz chciałbym powiedzieć: obiekcie $user zwróć mi wszystkich użytkowników z bazy wraz z informacją w jakich są grupach:

$user =  new User();

$user->find(
	array(
		"belongsTo" => array($user->Group)
	)
);

Zatem zaktualizuję metodę find:

	function find($contain=null){

		$r = new ReflectionClass($this);
		print "calling ".$r->getName()."::find($conditions)";

		$query = "Select * from `".strtolower($r->getName())."s` ".
					"as `".$r->getName()."` \n";

		if(!empty($contain) && is_array($contain["belongsTo"])){
			foreach($contain["belongsTo"] as $belongsToModel){
				$query .= $belongsToModel->getBelongsToJoin($this);
			}
		}

		var_dump($query);

		//return query result
	}

która od teraz zakłada, że model posiada metodę, która potrafi utworzyć odpowiedniego joina:

	function getBelongsToJoin($obj){
		$owner_reflection = new ReflectionObject($this);
		$obj_reflection = new ReflectionObject($obj);
		return "INNER JOIN `".strtolower($owner_reflection->getName())."s`
					as `".$owner_reflection->getName()."`
						ON (`".$owner_reflection->getName()."`.`id` = `".$obj_reflection->getName()."`.`".strtolower($owner_reflection->getName())."_id`)
					";
	}

to jest oczywiście bardzo brzydkie ze względu na refleksje. Metodę getName() można jednak zaimplementować w klasie Model.

Tak czy siak, w tym wypadku nawet w find()’zie uwzględniającym relacje można stosować Lazy Loading

Na koniec całość kodu, z większą ilością relacji i przykładem działania (i małym refactoringiem – skoro już mowa o lazy loading to głupio było ładować piętnaście razy ReflectionClass):

class ModelException extends Exception{}

class Model {

	protected $reflection = null;

	function getName(){
		if(is_null($this->reflection)){
			$this->reflection= new ReflectionClass($this);
		}
		return $this->reflection->getName();
	}

	function getTableName(){
		return strtolower( $this->getName() . "s" );
	}

	function getFKName(){
		return strtolower( $this->getName() . "_id");
	}

	function getBelongsToJoin($obj){
		$owner_reflection = new ReflectionObject($this);
		$obj_reflection = new ReflectionObject($obj);
		return "INNER JOIN `".$this->getTableName()."`
					as `".$this->getName()."`
						ON (`".$this->getName()."`.`id` = `".$obj->getName()."`.`".$this->getFKName()."`)
					";
	}

	function find($contain=null){

		$r = new ReflectionClass($this);
		print "calling ".$r->getName()."::find($conditions)";

		$query = "\nSelect * from `".strtolower($r->getName())."s` ".
					"as `".$r->getName()."` \n";

		if(!empty($contain) && is_array($contain["belongsTo"])){
			foreach($contain["belongsTo"] as $belongsToModel){
				$query .= $belongsToModel->getBelongsToJoin($this);
			}
		}

		var_dump($query);

		//return query result
	}

	function __construct(){
		$r = new ReflectionClass($this);
		print("creating ".$r->getName()."
");
	}

	function __get($property){
		if(!isset($this->{$property})) {
			$this->{$property} = new $property();
		}
		if(in_array($property, $this->belongsTo)){
			return $this->{$property};
		}else{
			$r = new ReflectionClass($this);
			throw new ModelException(
				"$property not related with {$r->getName()}"
			);
		}
	}
}

class User extends Model{
	protected $belongsTo = array("Group", "Unit", "Company");
}

class Group extends Model{
}

class Unit extends Model{}
class Company extends Model{}

$user =  new User();

$user->find(
	array(
		"belongsTo" => array($user->Unit, $user->Company)
	)
);

Gdy definiujesz w PHP każdą klasę osobno może Cię zainteresować magiczna funkcja __autoload()

Załóżmy, że masz pliki MyClass1.php i MyClass2.php z klasami MyClass1 i MyClass2, wtedy zamiast:

include_once("MyClass1.php");
include_once("MyClass2.php");

$obj1 = new MyClass1;
$obj2 = new MyClass2;

Możesz zdefiniować funckję __autoload():

function __autoload($class_name){
	include_once($class_name . ".php");
}

$obj1 = new MyClass1;
$obj2 = new MyClass2;

W wielkich projektach można zaoszczędzić trochę klepania.

Moje podejście obiera się na tzw. elemencie. Element to (wg. manuala CakePHP) “częściowy layout”. Czyli cegiełki, z których możesz stworzyć swoje strony.

app/views/elements/image_preload.thtml:

O co chodzi? Wpisz w google “javascript image preload” to się dowiesz :)
Jak z tego skorzystać? Już śpieszę z wyjaśnieniami:
W pliku Twojego layoutu, na samym końcu (przed </body> ofcoz) dodaj:


renderElement('image_preload', array('images'=>$images_to_preload, 'subdir'=>$images_to_preload_subdir)); ?>



A w metodzie odpowiedniego kontrolera wygeneruj tablicę z nazwami plików, które chcesz załadować do cache przeglądarki i przekaż do layoutu:

$this->set('images_to_preload', $content['Photo']);
$this->set('images_to_preload_subdir', 'photos/');


U mnie akurat model Photo ma pole filename, więc tak napisałem sobie element. Do tego dodałem możliwość przekazania z kontrolera podkatalogu w którym są obrazki w /app/webroot/img (teraz już nie wiem dlaczego, ale jak to pisałem, na pewno było to uzasadnione ;))

Wracajmy teraz szybko do naszego oczka w głowie: /app/controllers/soap_controller.php.
W metodzie _defineTypes dodajmy definicję złożonych typów:

$this->server->wsdl->addComplexType (
'LoginData',
'complexType',
'struct',
'all',
'',
array(
'Login' => array('name' => 'Login',
'type' => 'xsd:string'), //
'Password' => array('name' => 'Password',
'type' => 'xsd:string'), //
)
);
/**
* odpowiedĹş na logowanie
*/
$this->server->wsdl->addComplexType (
'LoginResponse',
'complexType',
'struct',
'all',
'',
array(
'Result' => array('name' => 'Result',
'type' => 'xsd:int'), //
'SID' => array('name' => 'SID',
'type' => 'xsd:string'), //
)
);


A w metodzie _registerMethods() zarejestrujmy metodę SoapController.login:

$this->server->register('SoapController.login',
array('SoapParam' => 'tns:LoginData'),
array('return' => 'tns:LoginResponse') ,
$this->namespace,
$this->namespace . '#login',
'logowanie'
);


Teraz właściwe logowanie:

function login($login_data) {
$login_details['User'] = array('username' => $login_data['Login'],
'password' => $login_data['Password'],
'cookie' => "0");
$result = $this->requestAction('users/login', array('data' => $login_details));
return array('Result' => $result, 'SID' => session_id() );
}


Kilka słów wyjaśnienia: w pierwszej linii tworzymy trochę sztucznie tablicę $login_details, która jest taka jaką oczekuje metoda UsersController::login() (zgodnie z zasadą DRY nie będziemy tworzyć osobnej metody dla logowania przez soap). Wywołujemy akcję users/login przekazując do niej spreparowane dane i zwracamy zgodnie z definicją typu LoginResponse- tablicę z danymi.

To była ta łatwiejsza część. Teraz to nad czym spędziłem kilka intensywnych dni- jak odzyskać sesję??
Od razu sprostowanie: wygląda na to, że sesja “trzyma się” tak długo, jak długo klient się nie rozłączy (testowałem to za pomocą również nuSOAP + php i w okresie trwania skryptu – było ok). Jednak ja potrzebowałem możliwości podania przez klienta id sesji, którą otrzymał podczas logowania. Jak to zrobić?
Po kolei:
Dodajmy typ, który będzie służył do przekazania informacji na temat zalogowanego usera:

$this->server->wsdl->addComplexType (
'UserDetails',
'complexType',
'struct',
'all',
'',
array(
'Id' => array('name' => 'id',
'type' => 'xsd:int'), //
'Username' => array('name' => 'Username',
'type' => 'xsd:string'), //
'Email' => array('name' => 'Email',
'type' => 'xsd:string'), //
'GroupId' => array('name' => 'GroupId',
'type' => 'xsd:string'), //
'Error' => array('name' => 'Error',
'type' => 'xsd:string')
)
);


Zarejestrujmy metodę SoapController.check():

$this->server->register('SoapController.check',
array('data' => 'xsd:string'),
array('return' => 'tns:UserDetails') ,
$this->namespace,
$this->namespace . '#check',
'logowanie'
);


I zdefiniujmy ją:

function check($data="") {
$data = $this->requestAction('/users/soapCheck', array('data' => $data, 'SID'=>$data));
$this->log($data, LOG_DEBUG);

return $return ;
}


Wyjaśnienia: oprócz danych jak przy logowaniu pojawiło się jeszcze pole w tablicy ‘SID’, to tędy przekażemy informację, że chcemy “wymusić” jakieś id sesji.
Teraz metoda UsersController::soapCheck():

function soapCheck($data) {
return $this->othAuth->getData();
}


No i na koniec gdzieś musimy wymusić inne id sesji (no bo nie ma przeglądarki, ani kochanych cookies, które zrobią to za nas). W app/app_controller.php:

if(isset($this->params['SID'])){
session_id($this->params['SID']);
}


I ok… jaaasne. Nie działa, prawda? Dlaczego? A to dlatego, że w momencie kiedy klient SOAP łączy się z naszym ukochanym serwerem SOAP wygląda to tak:
request (soap/index) -> app_controller -> soap_contropper -> check -> request (/users/soapCheck) -> app_controller*->users_controller -> soapCheck ...

miejsce oznaczone gwiazdką oznacza moment, kiedy app_controller dostaje info o tym, że jest jakieś SID… tylko że wtedy to już jest za późno (jak to mówią ślązocy: “po ptokach” :P) $this->requestAction to moment, kiedy ciasteczka już nie są wysyłane i szanowna pani Sesja ma już głęboko w … nosie fakt, że tam jakieś id jest przesyłane.
Nie lękaj się jednak, jest na to rada:
zmień w app_controller poprzednio dodany blok na:

if(isset($this->params['url']['SID'])){
session_id($this->params['url']['SID']);
}


I teraz łącząc się z serwerem do linku /twoja_aplikacja/soap/ doklejaj parametr SID=. W takim wypadku już przy pierwszym request->app_controller id sesji trafia do “świadomości” Sesji i zazwyczaj rozpatruje je pozytywnie.

Nie jest to może najbardziej eleganckie rozwiązanie. Jednak najlepsze na jakie teraz mnie stać ;) Jeśli masz coś fajnieszego- pisz w komentarzach, z chęcią się podszkolę :)

1. Potrzebna nam biblioteka SOAP (jako prawdziwy programiści pozwalamy, żeby najtrudniejsze rzeczy pisali za nas inni). Ja wybrałem NuSOAP. Wrzuć pliki do /app/vendors/nusoap/*.
2. Stwórz kontroler do obsługi Soap. W moim przypadku soap_controller.php


/**
* Soap Serwer
* @package package
*/
vendor('nusoap/nusoap');
class SoapController extends AppController {
var $name = 'Soap';
var $server;
var $namespace;
var $layout = 'blank';
var $components = array('othAuth','Conf');
var $othAuthRestrictions = null;

function hello($name){
return array('return' => 'hello, '.$name);
}
}


3. Do tego stwórz model, który nic nie robi :)

class Soap extends AppModel {
var $name = 'Soap';
var $useTable = false;
}


Teraz objaśnienia:
SoapController::index() – to twój endpoint serwera SOAP. SoapController::_registerMethods() zajmuje się rejestrowaniem metod dostępnych przez serwer. W tym wypadku tylko jednej: SoapController::hello (notacja metod soap to Klasa.metoda).
Metoda hello przyjmuje string jako parametr i zrwaca ‘Hello, ‘+ to co zostało jej przekazane.
Przykładowy klient (poza cake.php):

";
var_dump($var);
echo "

I ładny response:

string(11) "hello, Greg"

Dodatkowo, gdy w przeglądarce wpiszesz ścieżkę do kontrolera Soap zobaczysz ładną dokumentację Twojego serwera. A dodając do ścieżki ?wsdl – dokument wsdl.

żródła:
http://www.scottnichol.com/nusoapprog.htm
http://dietrich.ganx4.com/nusoap/faq.php

Dość częstą praktyką jest definiowanie metody w pliku app/app_controller.php, w klasie AppController po to, aby wykonywać w niej operacje, które zawsze muszą być wykonane przed każdą akcją kontrolera. Jednak czasem zdarza się, że jednocześnie inny programista zdefiniuje metodę beforeFilter() w swoim kontrolerze, wtedy niedoświadczony programista może mieć problemy ze znalezieniem przyczyny “dlaczego mój beforeFilter() w AppController się nie odpala?”.
Powód jest prosty, jeśli dobrze rozumiemy zasady OOP (których w tym blogu przybliżał raczej nie będę). Zatem jeśli chcemy, aby nasza AppController::beforeFilter() odpalała się zawsze, niezależnie od tego, czy w jakim kontrolerze jest zdefiniowana beforeFilter() czy też nie, należy w kontrolerach umieszczać wywołanie metody z klasy AppController. Osiągamy to oczywiście za pomocą parent::beforeFilter().