login  Naam:   Wachtwoord: 
Registreer je!
 Scripts:
Scripts > PHP > Handige scripts > ErrorException implementatie

ErrorException implementatie

Auteur: Richard - 13 oktober 2008 - 23:25 - Gekeurd door: marten - Hits: 2805 - Aantal punten: (0 stemmen)




Nog een crosspost van PHPFreakz.nl:

Ik houd zo onderhand niet meer van de standaardfouten die PHP geeft, die vang ik zelf liever af als exception.

Nu heeft PHP al een mooie ingebouwde ErrorException hiervoor, helaas moet je die wel zelf implementeren in je eigen systeem. Ik heb hier dus een simpele, doch effectieve schil voor gemaakt.

Uitleg staat in het script, vragen/opmerking/complimenten/hatemail mag je zoals gebruikelijk achterlaten als reactie. 

Code:
php code - Bekijk de code zonder highlighting - Klap code in 
  1. <?php
  2. /**
  3.  * Hiermee worden standaard PHP-meldingen omgezet naar Exceptions,
  4.  * zo is het makkelijker af te vangen binnen objectgeorienteerde applicaties
  5.  *
  6.  * Gebruik:
  7.  * <pre>Error_Handler::init()
  8.  *     // in principe hetzelfde als error_reporting()
  9.  *     ->setBitField(E_ALL)
  10.  *     // de zwaarheid van iedere melding
  11.  *     ->setSeverity(array(
  12.  *         E_USER_ERROR        => 100,
  13.  *         E_RECOVERABLE_ERROR => 90,
  14.  *         E_WARNING           => 80,
  15.  *         E_USER_WARNING      => 70,
  16.  *         // etc.
  17.  *     ));</pre>
  18.  */
  19. class Error_Handler {
  20. 	/**
  21. 	 * De zwaarheid per melding
  22. 	 *
  23. 	 * @var array
  24. 	 */
  25. 	protected $_severityPerError = array(
  26. 		E_WARNING           => 0,
  27. 		E_NOTICE            => 0,
  28. 		E_USER_ERROR        => 0,
  29. 		E_USER_WARNING      => 0,
  30. 		E_USER_NOTICE       => 0,
  31. 		E_STRICT            => 0,
  32. 		E_RECOVERABLE_ERROR => 0
  33. 	);
  34. 	/**
  35. 	 * Het bitfield, als een melding hiermee matcht wordt deze als
  36. 	 * Exception gegooid
  37. 	 *
  38. 	 * @var int
  39. 	 */
  40. 	protected $_bitField = 0;
  41.  
  42. 	/**
  43. 	 * Initialiseer de error_handler
  44. 	 *
  45. 	 * Deze maakt ook, indien deze bestaan, de E_DEPRECATED en
  46. 	 * E_USER_DEPRECATED entries aan in {@link $this->_severityPerError}
  47. 	 *
  48. 	 * @return Error_Handler
  49. 	 */
  50. 	static public function init() {
  51. 		// compatibility met nieuwe PHP versies
  52. 		if(defined('E_DEPRECATED') && !isset(self::$_severityPerError[E_DEPRECATED])) {
  53. 			self::$_severityPerError[E_DEPRECATED] = 0;
  54. 		}
  55. 		if(defined('E_USER_DEPRECATED') && !isset(self::$_severityPerError[E_USER_DEPRECATED])) {
  56. 			self::$_severityPerError[E_USER_DEPRECATED] = 0;
  57. 		}
  58.  
  59. 		// retourneer de nieuwe instantie
  60. 		return new self;
  61. 	}
  62.  
  63. 	/**
  64. 	 * Stel het bitfield in waaraan meldingen moeten voldoen om gegooid te worden
  65. 	 *
  66. 	 * In principe hetzelfde als error_reporting($bitfield)
  67. 	 *
  68. 	 * @param int $bitfield
  69. 	 * @return Error_Handler
  70. 	 */
  71. 	public function setBitField($bitfield) {
  72. 		if(!is_int($bitfield)) {
  73. 			throw new ErrorException('Bitfield must be of type integer');
  74. 		}
  75.  
  76. 		$this->_bitField = $bitfield;
  77.  
  78. 		return $this;
  79. 	}
  80.  
  81. 	/**
  82. 	 * Stel de zwaarheid in per melding
  83. 	 *
  84. 	 * @param int|array $error Ofwel een E_***-constante, ofwel een array
  85. 	 * @param int $severity De zwaarheid
  86. 	 * @return Error_Handler
  87. 	 */
  88. 	public function setSeverity($error, $severity = null) {
  89. 		if(($severity === null && !is_array($error)) && !(is_int($error) && !is_int($severity))) {
  90. 			throw new ErrorException('setSeverity() accepts only two integers or an array');
  91. 		}
  92. 		if($severity === null) {
  93. 			foreach($error as $key => $value) {
  94. 				$this->setSeverity($key, $value);
  95. 			}
  96. 		} else {
  97. 			$this->_severityPerError[$error] = $severity;
  98. 		}
  99.  
  100. 		return $this;
  101. 	}
  102.  
  103. 	/**
  104. 	 * De constructor van deze klasse
  105. 	 *
  106. 	 * Stelt de error_handler in
  107. 	 */
  108. 	protected function __construct() {
  109. 		set_error_handler(array($this, 'handleError'));
  110. 	}
  111.  
  112. 	/**
  113. 	 * De handler die wordt aangeroepen bij een melding
  114. 	 *
  115. 	 * @param int $errno
  116. 	 * @param string $errstr
  117. 	 * @param string $errfile
  118. 	 * @param int $errline
  119. 	 * 
  120. 	 * @throws ErrorException
  121. 	 */
  122. 	public function handleError($errno, $errstr, $errfile, $errline) {
  123. 		if($this->_bitField & $errno) {
  124. 			throw new ErrorException($errstr, $this->_severityPerError[$errno], $errno, $errfile, $errline);
  125. 		}
  126. 	}
  127. }
  128.  
  129. // initialiseer de errorhandler
  130. Error_Handler::init()
  131. 	// stel het bitfield in op alleen warnings
  132. 	->setBitfield(E_WARNING)
  133. 	// stel de zwaarheid van E_WARNING in op 10
  134. 	->setSeverity(array(
  135. 		E_WARNING => 10
  136. 	));
  137.  
  138. // een nutteloze variabele om te testen
  139. $text = 'bla';
  140.  
  141. try {
  142. 	// bogus tekst, dit werkt natuurlijk
  143. 	echo 'Aap noot mies?<br />';
  144. 	// een entry poppen van een string? Hier komt de exceptie
  145. 	echo array_pop($text) . '<br />';
  146. } catch(ErrorException $e) {
  147. 	// output, zoals gewoonlijk
  148. 	echo '<code><i>' . $e->getMessage() . '</i> op regel <b>' . $e->getLine()
  149. 	   . '</b> van bestand <b>' . $e->getFile() . '</b></code><br />';
  150. }
Download code! Download code (.txt)

 Stemmen
Niet ingelogd.

 Reacties
Post een reactie
Lees de reacties (1)
© 2002-2024 Sitemasters.be - Regels - Laadtijd: 0.023s