[PHP] pobierz, plaintext 
//wlasciwa klasa w moim nastepnym poscie w tym temacie ;P
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?
 
class Walidacja 
{
 
	/*	 Dozwolone opcje:
    * 	min_znakow - minimalna ilosc znakow
	* 	max_znakow - maksymalna ilosc znakow
	*	 wzor       - wzor wg ktorego ma byc walidowana zmienna
 
		Wywolanie obiektu
		$ob = new Walidacja;
		$ob->waliduj(zmienna, kryterium);
 
		Mozna swobodnie dodawac nowe pola/typy pol do ustawien, np
		kod pocztowy i zaopatrzyc go w atrybut wzor w ktorym bylby
		wzor w postaci wyrazen regularnych, ktory mialby za zadanie
		sprawdzac zmienna czy ma poprawny format.
	*/
 
	public $ustawienia = array(
		"login" 			=> array(
			"min_znakow"		=> 3,
			"max_znakow" 		=> 25	
		),
		"haslo" 			=> array(	
			"min_znakow"		=> 5,
			"max_znakow"		=> 15		
		),	
		"email"				=> array(
			"wzor"				=> "^[_.0-9a-z-]+@([0-9a-z][0-9a-z-]+.)+[a-z]{2,4}$",
		),
		"zabronione"	=> array()
 
	);
 
	private $bledy 			= array();
 
	public function dodaj($typ, $min = null, $max = null, $wzor = null)
	{
		if(!isset($min) and !isset($max) and !isset($wzor)) {
			throw new Exception("Musisz podac dodatkowy atrybut(maksymalna ilosc znakow, minimalna lub wzor");
		} else {
			$typ = (string)$typ;
			if(isset($min)) $this->ustawienia[$typ]["min_znakow"] = (int)$min;
			if(isset($max)) $this->ustawienia[$typ]["max_znakow"] = (int)$max;
			if(isset($wzor)) $this->ustawienia[$typ]["wzor"] = $wzor;
		}
 
	}
 
	public function zabron($zabronione)
	{
		if(!is_array($zabronione)) {
			array_push($this->ustawienia["zabronione"], $zabronione);
		} else {
			foreach($zabronione as $wartosc) 
				array_push($this->ustawienia["zabronione"], $wartosc);
		}	
	}
 
	public function waliduj($zmienna, $typ = null)
	{
 
		if(is_array($zmienna)) {
			throw new Exception("Weryfikowana zmienna nie moze byc tablica. Bo tak.");
		}
 
		$zmienna = trim(strip_tags($zmienna));
 
		foreach($this->ustawienia["zabronione"] as $zabronione) {
			if(preg_match("#".$zabronione."#", $zmienna)) {
				$this->bledy[] = "Formularz zawiera niedozwolone znaki/slowa: ".$zabronione."."; 
				break;
			}	
		}
 
		if(isset($typ)) {
			if(isset($this->ustawienia[$typ])) {
				$ustawienia = $this->ustawienia;
 
				foreach($this->ustawienia[$typ] as $klucz => $wartosc) {
					if($klucz == "min_znakow") { 
						if(strlen($zmienna) < $this->ustawienia[$typ]["min_znakow"])
					$this->bledy[] = ucfirst($typ)." musi miec conajmniej ".$this->ustawienia[$typ]["min_znakow"]." znakow.";
					}
					if($klucz == "max_znakow"){
						if(strlen($zmienna) > $this->ustawienia[$typ]["max_znakow"])
							$this->bledy[] = ucfirst($typ)." moze miec conajwyzej ".$this->ustawienia[$typ]["max_znakow"]." znakow.";		
					}
					if($klucz == "wzor"){
						if(!preg_match("#".$this->ustawienia[$typ]["wzor"]."#", $zmienna))
							$this->bledy[] = ucfirst($typ)." ma niepoprawny format.";		
					}			
 
				}
			}
		}
 
 
		return $zmienna;
	}
 
	public function pokazbledy()
	{
		return $this->bledy;
	}
}
 
try {
 
 
	$obWaliduj = new Walidacja();
	$obWaliduj->dodaj("tresc", 1, 10);
	$obWaliduj->waliduj("hesdsadsaddads", "tresc");
	$obWaliduj->dodaj("tresc", 4, 7);
	$obWaliduj->waliduj("aa", "tresc");
	$bledy = $obWaliduj->pokazbledy();
		foreach($bledy as $blad) {
			echo $blad."<br />";
		}
 
} catch(Exception $e) {
	echo "Blad: ".$e->getMessage();
}	
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
 
namespace Crozin\Validation {
	interface Validatable {
		public function configure(array $params = array());
		public function getOptions();
		public function getOption($key);
 
		public function isValid($subject);
	}
 
	class Validator {
		protected $subjects = array();
		protected $validators = array();
 
		protected $errors = array();
		protected $data = array();
 
		public function isValid() {
			$isValid = true;
 
			foreach ($this->subjects as $key => $subject) {
				$result = $this->validators[$key]->isValid($subject);
 
				if ($result instanceof Response) {
					$isValid = false;
					$this->errors[$key] = $result;
				} else {
					$this->data[$key] = $result;
				}
			}
 
			return $isValid;
		}
 
		public function addSubjects(array $subjects) {
			foreach ($subjects as $key => $subject) {
				$this->addSubject($key, $subject);
			}
		}
 
		public function addSubject($key, $subject) {
			$this->subjects[$key] = $subject; 
		}
 
		public function addValidators(array $validators) {
			foreach ($validators as $key => $validator) {
				$this->addValidator($key, $validator);
			}
		}
 
		public function addValidator($key, Validatable $validator) {
			$this->validators[$key] = $validator; 
		}
 
		public function getData() {
			return $this->data;
		}
 
		public function getErrors() {
			return $this->errors;
		}
	}
 
	class Response {
		protected $msg;
		protected $subject;
		protected $validator;
 
		public function __construct($msg, $subject, Validatable $validator) {
			$this->msg = $msg;
			$this->subject = $subject;
			$this->validator = $validator;
		}
 
		public function getMsg() {
			return $this->msg;
		}
 
		public function getSubject() {
			return $this->subject;
		}
 
		public function getValidator() {
			return $this->validator;
		}
	}
}
 
namespace Crozin\Validation\Validator {
	use \Crozin\Validation\Validatable;
	use \Crozin\Validation\Response;
 
	abstract class Base {
		protected $options = array();
 
		public function __construct(array $options = array()) {
			$this->configure($options);
		}
 
		public function configure(array $options = array()) {
			$this->options = $options;
		}
 
		public function getOptions() {
			return $this->options;
		}
 
		public function getOption($key) {
			return isset($this->options[$key]) ? $this->options[$key] : null; 
		}
	}
 
	class NIP extends Base implements Validatable {
		public function isValid($subject) {
			/* NIP ma nieprawidłowy format (np. podano litery) */
			if (1 == mt_rand(1, 2)) {
				return new Response('format', $subject, $this);
			}
 
			/* NIP ma nieprawidłową sumę kontrolną */
			if (1 == mt_rand(1, 2)) {
				return new Response('control.sum', $subject, $this);
			}
 
			return $subject;
		}
	}
 
	class String extends Base implements Validatable {	
		public function isValid($subject) {
			if ($this->getOption('trim')) {
				$subject = trim($subject);
			}
 
			if (($min = $this->getOption('min')) && strlen($subject) < $min) {
				return new Response('min', $subject, $this);
			}
 
			if (($max = $this->getOption('max')) && strlen($subject) > $max) {
				return new Response('max', $subject, $this);
			}
 
			return $subject;
		}
	}
 
	class Email extends Base implements Validatable {
		public function isValid($subject) {
			/* Nieprawidłowy format */
			if (1 == mt_rand(1, 2)) {
				return new Response('format', $subject, $this);
			}
 
			/* Jeżeli wpisy MX nie są dobre */
			if (1 == mt_rand(1, 2)) {
				return new Response('mx', $subject, $this);
			}
 
			return $subject;
		}
	}
 
	class NumberRange extends Base implements Validatable {
		public function isValid($subject) {
			if ($this->getOption('natural.only') && false == ctype_digit($subject)) {
				return new Response('not.natural', $subject, $this);
			}
 
			if ($subject < $this->getOption('min') || $subject > $this->getOption('max')) {
				return new Response('out.of.range', $subject, $this);
			}
 
			return $subject;
		}
	}
}
 
namespace {
	use \Crozin\Validation\Validator;
	use \Crozin\Validation;
 
	error_reporting(E_ALL | E_STRICT);
 
	$_POST = array(
		'firstname' => ' Krzysiek  ',
		'nickname'  => 'Crozin',
		'age'       => '7',
		'mail'      => 'k...s@gmail.com'
	);
 
	$v = new Validator();
	$v->addSubjects($_POST);
	$v->addValidators(array(
		'firstname' => new Validator\String(array('trim' => true, 'min' => 6)),
		'nickname'  => new Validator\String(),
		'age'       => new Validator\NumberRange(array('natural.only' => true, 'min' => 9, 'max' => 99)),
		'mail'      => new Validator\Email()
	));
 
	if ($v->isValid()) {
		var_dump('Poprawne dane:');
		var_dump($v->getData());
	} else {
		foreach ($v->getErrors() as $error) {
			var_dump(sprintf('%s - %s - %s - %s', get_class($error->getValidator()), $error->getSubject(), $error->getMsg(), print_r($error->getValidator()->getOptions(), 1)));
		}
	}
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class a
{
   public $c = 1;
}
class b extends a
{
function bla()
{
echo $this->c; 
}
 
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class a
{
public $aa=1;
}
 
class b
{
function __construct()
{
$this->ob = new a;
echo $this->ob->aa;
}
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class News_Model extends MySqlDb { }
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class Controller extends View { }
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class Controller { 
 
  protected $view;
 
  public function __construct() {
 
      $this -> view = new View();
 
  }
 
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class Auto { }
 
class Fiat extends Auto { } // jako tako ma sens bo kazdy pojazd robi to samo tylko jeden moze miec wiecej ficzerow niz drugi
 
class Bmw extends Auto { } // ok
 
class Motor extends Auto { } // nie bardzo pasuje
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class News_Model extends MySqlDb { }
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class Controller extends View { }
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class Auto { }
 
class Fiat extends Auto { } // jako tako ma sens bo kazdy pojazd robi to samo tylko jeden moze miec wiecej ficzerow niz drugi
 
class Bmw extends Auto { } // ok
 
class Motor extends Auto { } // nie bardzo pasuje
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
abstract class Pojazd {} // Może się poruszać, przyśpieszać, hamować
abstract class PojazdKołowy extends Pojazd {} // To co Pojazd + Ma koła, może skręcać
class Rower extends PojazdKołowy {} // to co PojazdKołowy + Ma łańcuch
class Smaochód extends PojazdKołowy {} // to co PojazdKołowy + Ma silnik, zbiornik paliwa, nadpisuje "przyśpieszać" (by spalało paliwo), może tankować
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class Silnik {
  public $moc;
  public $spalanie;
}
 
class Samochód {
  public $silnik;
  public $paliwo;
 
  public function możeJechać($km) {
    return $this->paliwo > $this->slinik->spalanie * $km;
  }
 
  public function jedź($km) {
     $this->paliwo -= $this->slinik->spalanie * $km;
  }
}
 
 
$silnik = new Silnik();
$silnik->moc = 75;
$silnik->spalanie = 0.5;
 
$samochód = new Samochód();
$samochód->silnik = $silnik;
$samochód->paliwo = 50;
 
while ($samochód->możeJechać(50)) {
  echo 'Jadę 50 km';
  $samochód->jedź(50);
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class controller extends acl { }
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class news_Model extends model { }
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
protected $validators = array();
....
$result = $this->validators[$key]->isValid($subject);
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
Stanowi bazę dla wszystkich walidatorów TUTAJ ZDEFINIOWANYCH. Po prostu żebyśmy nie musieli pisać obsługi
 	 * konfiguracji dla każdego z walidatorów.
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
if( $x->isValide() )
{
  //zapis do bazy lub cokolwiek
}
else
{
  //informacja o błędach
} 
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
$result = $....->isValid($subject);
 
if (true == $result) {
  $this->data[..] = $...->getData();
} else {
  $this->errors[...] = $...->getError();
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
 
# Jeżeli metoda Validator::addValidator() ma tak zapisane parametery: $key, $validator, wtedy:
 
$v->addValidator('firstname', new PDO()));
 
# Zadziała... tzn. kod się uruchomi a Ty dostaniesz błąd, że nie można wykonać metody isValid na tym obiekcie.
# Jeżeli zaś metoda AddValidator() ma tak zapisane parametry: $key, Validatable $validator
 
$v->addValidator('firstname', new PDO()));
 
# To wywali Ci dużo przyjaźniejszy błąd: obiekt z drugiego parametru musi implementować interfejs Validatable - a nei robi tego
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
$obEmail = new Email(array("pattern"=>"#^[_.0-9a-z-]+@([0-9a-z][0-9a-z-]+.)+[a-z]{2,4}$#", "maxlength"=>20));
[PHP] pobierz, plaintext