Pero cuando deseas mostrar los comentarios de cierta página, Facebook solo te da el número de los comentarios de primer nivel, es decir, no te suma las respuestas ni los demás comentarios anidados. Por lo tanto, si tienes 30 comentarios y cada uno tiene 5 respuestas, Facebook te dice que tu página tiene 30 comentarios en lugar de 150.

¿Cómo solucionar esto? Afortunadamente Facebook te da cierto acceso a su BD por medio de una API, y usando su propio lenguaje FQL puedes acceder a consultas un poco más complejas. Yo admito que aunque me gusta programar y tengo años dedicándome a eso, nunca me ha gustado usar SQL y nunca he sido bueno, así que sencillamente no tenía idea de cómo crear una query que me regresara todos los comentarios por lo que me dediqué a buscarlo en Google, y fue así como encontré una solución en StackOverflow.

select time from comment where
object_id in
(
   	select comments_fbid from link_stat where url ='http://example.com'
)
or object_id in
(
	select post_fbid from comment where object_id in
	(
		select comments_fbid from link_stat where url ='http://example.com'
	)
)

No tengo idea de cómo explicar esta consulta xD pero funciona, lo que sí sé es que FQL no permite el uso de la función COUNT() así solo indicamos un campo (time) para poder indexar los resultados. Cuando se ejecuta la query, esta nos regresa un documento XML fácilmente manipulable por medio de la clase SimpleXMLElement en PHP, al que solo tenemos que contarle los hijos para saber cuantos comentarios hay.

<?php
function fb_comments_count($url){
	// URL del web service
	$api = "https://api.facebook.com/method/fql.query?query=";
	// Consulta FQL que regresará un documento XML
	$fql = "select time from comment where object_id in (select comments_fbid from link_stat where url ='$url') or object_id in (select post_fbid from comment where object_id in (select comments_fbid from link_stat where url ='$url'))";
	// Convertimos en objeto el documento XML
	$xml = new SimpleXMLElement($api.$fql, null, true);
	// Regresamos el tamaño del objeto (número de hijos)
	return (count($xml));
}
?>

Para llamarlo, solo tenemos que enviar como parámetro la URL de la página deseada.

<?php echo fb_comments_count("http://example.com/post/1234") ?>

Espero que les sirva. Y gracias a Tom, el autor de esta solución.

• Cómo modificar documentos XML con PHP
• Cómo acceder a los datos de XML en PHP
• Twitter vs Facebook
• Clase para manejar base de datos MySQL en PHP
• Método de Gauss en PHP
• Manejo de errores en PHP
• Pilas en PHP

Total que busqué un algoritmo o método ya hecho para solo copiar y pegar pues me dada flojera programarlo, pero como no encontré nada útil pues terminé programándolo yo. Y por eso dejo aquí el código del método:

public final class Matriz {
	/**
	 * Multiplica dos matrices
	 * @param int[][] A
	 * @param int[][] B
	 * @return int[][] producto
	 */
	private static int[][] producto(int A[][], int B[][]){
		int suma = 0;
		int result[][] = new int[A.length][B.length];
		for(int i = 0; i < A.length; i++){
			for(int j = 0; j < B.length; j++){
				suma = 0;
				for(int k = 0; k < B.length; k++){
					suma += A[i][k] * B[k][j];
				}
				result[i][j] = suma;
			}
		}
		return result;
	}
}

El método es estático pues está dentro de una clase final (no instanciable ni extendible). De modo que para hacer una multiplicación solo basta con:

// Se asume que matrizA y matrizB ya están declaradas y son
// diferente a <null>

int matrizProducto[][] = Matriz.producto(matrizA, matrizB);

Espero que a más de uno le sirvan así como les sirvieron tambien los scripts para resolver matrices con el método de Gauss en PHP.

• Clase para manejar base de datos MySQL en PHP
• Método de Gauss en PHP
• Cómo modificar documentos XML con PHP
• Cómo acceder a los datos de XML en PHP
• Manejo de errores en PHP
• Pilas en PHP
• Variables de servidor de PHP

• No hay artículos relacionados

El patrón Modelo-Vista-Controlador nos puede ser de gran utilidad ya que separa la lógica (controladores) de scripts que acceden y relacionan las tablas de un base de datos (modelos) y de la interfaz gráfica (vistas). Pero en ocasiones no necesitamos de tantas capas de abstracción y decidimos programar todo revuelto. Aún así, utilizar una clase para los accesos a la base de datos nos es de gran ayuda para aquello de la organización del código.

La clase que a continuación propongo utiliza un patrón llamado Singleton. Este patrón obliga a instanciar unicamente una vez la clase para evitar 2 o más conexiones simultáneas. La clase contiene métodos para ejecutar sentencias SQL, cargar resultados en forma de objetos, ver el número de consultas totales etc.

<?php

class DataBase {

	private $conexion;
	private $resource;
	private $sql;
	public static $queries;
	private static $_singleton;

	public static function getInstance(){
		if (is_null (self::$_singleton)) {
			self::$_singleton = new DataBase();
		}
		return self::$_singleton;
	}

	private function __construct(){
		$this->conexion = @mysql_connect('localhost', 'db_user', 'db_password'));
		mysql_select_db('database_name', $this->conexion);
		$this->queries = 0;
		$this->resource = null;
	}

	public function execute(){
		if(!($this->resource = mysql_query($this->sql, $this->conexion))){
			return null;
		}
		$this->queries++;
		return $this->resource;
	}

	public function alter(){
		if(!($this->resource = mysql_query($this->sql, $this->conexion))){
			return false;
		}
		return true;
	}

	public function loadObjectList(){
		if (!($cur = $this->execute())){
			return null;
		}
		$array = array();
		while ($row = @mysql_fetch_object($cur)){
			$array[] = $row;
		}
		return $array;
	}

	public function setQuery($sql){
		if(empty($sql)){
			return false;
		}
		$this->sql = $sql;
		return true;
	}

	public function freeResults(){
		@mysql_free_result($this->resource);
		return true;
	}

	public function loadObject(){
		if ($cur = $this->execute()){
			if ($object = mysql_fetch_object($cur)){
				@mysql_free_result($cur);
				return $object;
			}
			else {
				return null;
			}
		}
		else {
			return false;
		}
	}

	function __destruct(){
		@mysql_free_result($this->resource);
		@mysql_close($this->conexion);
	}
}
?>

Si notamos, el constructor es privado. ¿Por qué? para asegurarnos de que la clase se instancie desde dentro de sí misma. Es decir, al ejecutar el método DataBase::getInstance() llamamos al constructor y creamos una única instancia de DataBase. Si volvemos a ejecutar ese método y la clase ya ha sido instanciada antes, entonces nos devolverá la instancia. Eso es el objetivo del patrón Singleton.

Veamos entonces como hacer una conexión, ejecutar una consulta y mostrar los resultados. Se asume que los parámetros de conexión como el host, el nombre de usuario y demás se especifican directamente en la clase.

// Hacemos la conexión
$db = DataBase::getInstance();

// Supongamos que tenemos una tabla de usuarios
// Hacemos la consulta:
$db->setQuery('SELECT `id`,`nombre`,`grupo` FROM `usuarios`');

// La ejecutamos y al mismo tiempo obtenemos un arreglo de objetos
// con los campos especificados en la consulta como propiedades.
$usuarios = $db->loadObjectList();

// Los imprimimos directamente en pantalla...
foreach($usuarios as $usuario){
	echo 'ID: '.$usuario->id;
	echo 'Nombre: '.$usuario->nombre;
	echo 'Grupo: '.$usuario->grupo;
	echo '<br />';
}

Y ahí tienen un pequeñísimo ejemplo de uso. Algunos métodos como el DataBase::loadObject o DataBase::loadObjectList fueron tomados de la API de Joomla. En fin, espero que les sea de utilidad.

• Método de Gauss en PHP
• Cómo modificar documentos XML con PHP
• Cómo acceder a los datos de XML en PHP
• Manejo de errores en PHP
• Pilas en PHP
• Variables de servidor de PHP
• Cómo obtener todos los comentarios y replies de Facebook con FQL

Crearemos primero una interfaz sencilla, para conocer primero el numero de filas y columnas, y después los valores de la matriz. Ojo, si es un sistema común, se sobreentiende que el número de filas es menor por uno al número de columnas. De manera que la matriz siempre debe quedar del orden (n,n+1).

Código de la interfaz inicial XHTML:

<form action="gauss.php" method="post">
<fieldset>
	<legend>Orden de la matriz</legend>
	<table>
		<tr>
			<td><p>Numero de filas</p></td>
			<td><p><input name="Matriz[filas]" /></p></td>
		</tr>
		<tr>
			<td><p>Numero de columnas</p></td>
			<td><p><input name="Matriz[columnas]" /></p></td>
		</tr>
		<tr>
			<td colspan="2">
				<p><input type="submit" value=" Crear matriz "></p>
			</td>
		</tr>
</fieldset>
</form>

Una vez establecido el orden de la matriz, continuamos leyendo los valores la misma. Para esto, cacharemos los valores en un archivo PHP y crearemos dinamicamente una tabla con campos de texto para introducir los valores de la matriz. El archivo se llama en este caso gauss.php.

<?php
$filas = $_POST['Matriz']['filas'];
$columnas = $_POST['Matriz']['columnas'];
?>

<form action="gaussiana.php" method="post">
	<table>
	<?php for($i = 1; $i <= $filas; $i++ ) { ?>
		<tr>
		<?php for($j = 1; $j <= $columnas; $j++ ) { ?>
		    <td>
			<input type="text" name="A[<?php echo $i ?>][<?php echo $j ?>]"/>
		    </td>
		<?php } ?>
		</tr>
	<?php } ?>
		<tr>
			<td colspan="<?php echo $columnas ?>">
				<p><input type="submit" class="submit" value=" Resolver matriz"
					></p>
			</td>
		</tr>
	</table>
	<input type="hidden" name="filas" value="<?php echo $filas ?>"/>
	<input type="hidden" name="columnas" value="<?php echo $columnas ?>"/>
</form>

Desde el form del archivo anterior llamamos a otro archivo que se llama gaussiana.php, ahi llegarán todos los valores de la matriz. Desde ahí mismo también instanciaremos nuestra clase que será la que resuelva la matriz.

En este archivo debe haber una inclusión al archivo donde vayamos a poner la clase -en caso de tenerla aparte- de manera que, minimamente, gaussiana.php debe contener:

<?php

	$A = $_POST['A'];
	$filas = $_POST['filas'];
	$columnas = $_POST['columnas'];

	$method = new Gauss();
	$method->setRows( $filas );
	$method->setCols( $columnas );
	$method->setMatrix( $A );
	$method->getGaussSolution();

?>

Ahora sí, viene lo bueno: la clase que resuelve la matriz. Tiene 3 propiedades, 3 métodos set, el método de solución y un método de impresión:

class Gauss {

	private $filas;
	private $columnas;
	private $matriz;

	/**
	 * Establece el número de filas de la matriz
	 * @param int filas
	 * @return void
	 */
	public function setRows( $filas ){
		$this->filas = $filas;
	}

	/**
	 * Establece el número de columnas de la matriz
	 * @param int columnas
	 * @return void
	 */
	public function setCols( $columnas ){
		$this->columnas = $columnas;
	}

	/**
	 * Establece la matriz a la que se aplicará el método de solución
	 * @param array matriz
	 * @return void
	 */
	public function setMatrix( $matriz ){
		$this->matriz = $matriz;
	}

	/**
	 * Obtiene la solución de la matriz por el método de Gauss
	 * @param void
	 * @return void
	 */
	public function getGaussSolution(){
		$this->mostrarMatriz();
		for($x = 1; $x <= $this->filas; $x++){
			$pivote = $this->matriz[$x][$x];
			for($i = $x; $i <= $this->filas; $i++ ){
				for($j = $x; $j <= $this->columnas; $j++ ){
					if($i == $x) {
						$this->matriz[$i][$j] /= $pivote;
						continue;
					} elseif( $j == $x && $i != $x ){
						$aux = $this->matriz[$i][$j] * (-1);
					}
					$this->matriz[$i][$j] =
						$this->matriz[$x][$j] * $aux
							+ $this->matriz[$i][$j];
				}
				$this->mostrarMatriz();
			}
		}
		for($x = 4; $x > 0; $x--){
			$pivote = $this->matriz[$x][$x];
			for($i = $x-1; $i > 0; $i-- ){
				for($j = $x; $j <= $this->columnas; $j++ ){
					if( $j == $x ){
						$aux = $this->matriz[$i][$j] * (-1);
					}
					$this->matriz[$i][$j] =
						$this->matriz[$x][$j] * $aux
							+ $this->matriz[$i][$j];
				}
				$this->mostrarMatriz();
			}
		}
	}

	/**
	 * Imprime la matriz en una tabla
	 * @param void
	 * @return void
	 */
	private function mostrarMatriz(){
		echo '<table>';
		for($i = 1; $i <= $this->filas; $i++ ){
			echo '<tr>';
			for($j = 1; $j <= $this->columnas; $j++ ){
				echo '<td>';
				echo '<p>'.$this->matriz[$i][$j].'</p>';
				echo '</td>';
			}
			echo '</tr>';
		}
		echo '</table>';
	}
}

Es todo… parece que no pero, estoy seguro que a más de uno le va a servir… así como a mi.

• Clase para manejar base de datos MySQL en PHP
• Cómo modificar documentos XML con PHP
• Cómo acceder a los datos de XML en PHP
• Manejo de errores en PHP
• Pilas en PHP
• Variables de servidor de PHP
• Cómo obtener todos los comentarios y replies de Facebook con FQL

Cómo agregar elementos, hijos y atributos

Hasta PHP 5.1.3 la extensión SimpleXMLElement no tenía forma de agregar elementos a un documento XML. Sólo era posible modificar los valores de elementos o atributos pero para agregar nuevos era necesario exportar el objeto SimpleXMLElement a DOM, hacer los cambios y exportar de nuevo a SimpleXMLElement, lo cual era una tarea complicada. Pero la versión 5.1.3 introdujo dos nuevos métodos que nos dan el poder de modificar el documento XML. Me refiero a los métodos:

SimpleXMLElement::addChild();
SimpleXMLElement::addAttribute();

El nombre lo dice todo, con el primero agregamos un elemento hijo al elemento en el que nos encontramos y con el segundo agregamos un atributo. addChild() acepta tres parámetros, el primero indica el nombre del nuevo elemento, el segundo es opcional e indica el valor del elemento, y el tercero también es opcional e indica el namespace al cual pertenece el elemento. addAttribute() recibe dos, el nombre del atributo y su valor.

Pongamos un ejemplo para ilustrar su uso. Recordemos el ejemplo de la vez pasada donde usamos un archivo XML cuyo contenido son libros con sus respectivos datos y pasemos a crear el objeto SimpleXMLElement.

$library = new SimpleXMLElement('library.xml', null, true);

Ahora supongamos que queremos agregar un nuevo libro llamado The finished mistery cuyo autor es J. F. Rutherford, el ISBN es 0812550706 y la editorial es Watchtower Society.

$book = $library->addChild('book');
$book->addAttribute('isbn', '0812550706');
$book->addChild('title', "The finished mistery");
$book->addChild('author', 'J. F. Rutherford');
$book->addChild('publisher', 'Watchtower Society');

Con eso es suficiente para modificar el contenido XML. En la primera línea estamos agregando un nuevo hijo llamado book al elemento raíz que es library, como SimpleXMLElement siempre nos regresa un objeto del mismo tipo, entonces a la variable $book también podemos aplicarle el metodo addChild() para crearle hijos, (que vendrían siendo los nietos de $library). Es como una especie de recursividad, donde podemos ir creando elementos en varios niveles, paras obtener hijos, nietos, bisnietos etc.

Ahora bien, hasta este punto no podemos ver cómo ha quedado nuestro documento XML. Lo siguiente será mostrarlo en el navegador. Para ello, debemos enviar una cabecera para indicar al navegador que el contenido a mostrar no es simple texto ni HTML, sino XML y después hacer la impresión del mismo.

header('Content-type: text/xml');
echo $library->asXML();

¿Para que sirve el método asXML()? regresa el contenido XML del objeto como una cadena, pero solo si lo llamamos sin argumentos. La otra opción, que sin duda es la qué podria darnos mas usabilidad es llamarlo con un parametro que contendría una ruta a un archivo, el cual se escribirá con el contenido XML del objeto. El método asXML($string) regresará un valor de tipo boolean dependiendo del resultado de la operación.

¿Cómo escribir entonces un archivo XML? Supongamos que, una vez agregado el nuevo libro a nuestro archivo de libros queremos guardar los cambios. Lo único que habría que hacer es:

$library->asXML('library.xml');

Y listo, si escribimos el nombre de un archivo que no existe, se crea automaticamente y si ya existe se sobrescribe.

¿Cómo eliminar ahora elementos y atributos de un documento XML?

SimpleXMLElement, no provee ningun metodo para hacerlo, sin embargo sí hay una forma de eliminar hijos. Supongamos que quiero eliminar el libro que acabo de agregar. Como es el elemento book número 6, solo hay que destruir el objeto que pertenece a ese hijo:

$library->book[5] = null;

El cinco es porque los elementos empiezan a contarse desde cero. Sin embargo, hay un inconveniente; esto solo eliminara a los hijos del elemento book y a sus respectivos atributos, pero los atributos que haya al nivel de book permaneceran ahi. Por lo que el atributo isbn seguirá existiendo. Si lo igualamos a null, solo conseguiremos vaciar su valor pero dejando intacto al atributo.

Para remover efectivamente hijos y atributos, debemos exportar el objeto SimpleXMLElement a DOM, donde las funcionalidades de PHP5 para manipular los datos se hacen más poderosas. Hablaré de ello después…

Espero que este microtutorial sea de utilidad para quien necesite manipular datos XML con PHP 5.

• Cómo acceder a los datos de XML en PHP
• Cómo obtener todos los comentarios y replies de Facebook con FQL
• Clase para manejar base de datos MySQL en PHP
• Método de Gauss en PHP
• Manejo de errores en PHP
• Pilas en PHP
• Variables de servidor de PHP

Lo primero de lo que hay que asegurarnos es de que el XML que vamos a parsear es válido. Esto significa que debe estar bien formado (un sólo elemento raíz, etiquetas abiertas y cerradas correctamente, anidaciones válidas, etc) y debe obedecer a un DTD. Después de segurarnos de esto, lo que sigue es trabajar sobre PHP5.

¿Por qué PHP5? por dos razones, una, nos da una orientación a objetos más eficiente que a versión 4 y, dos, nos provee de la extensión SimpleXMLElement que es con la trabajaremos el XML. ¿A caso PHP4 no tiene extensiones que hagan lo mismo? No lo sé, ni me interesa. PHP5 es mejor.

Bien, empecemos. Supongamos que tenemos un archivo XML llamado library.xml con el siguiente contenido:

<?xml version="1.0" ?>
<library>
	<book isbn="0345342968">
		<title>Fahrenheit 451</title>
		<author>R. Bradbury</author>
		<publisher>Del Rey</publisher>
	</book>
	<book isbn="0048231398">
		<title>The Silmarillion</title>
		<author>J.R.R. Tolkien</author>
		<publisher>G. Allen & Unwin</publisher>
	</book>
	<book isbn="0451524934">
		<title>1984</title>
		<author>G. Orwell</author>
		<publisher>Signet</publisher>
	</book>
	<book isbn="031219126X">
		<title>Frankenstein</title>
		<author>M. Shelley</author>
		<publisher>Bedford</publisher>
	</book>
	<book isbn="0312863551">
		<title>The Moon Is a Harsh Mistress</title>
		<author>R. A. Heinlein</author>
		<publisher>Orb</publisher>
	</book>
</library>

Y supongamos que lo que queremos hacer es una tabla con todos los libros y sus respectivos datos:

Para lograrlo debemos hacer una instancia de la clase SimpleXMLElement. El constructor recibe 5 parámetros aunque solo nos interesan 2 (el primero y el tercero). El primero es donde indicamos la dirección URL del archivo XML o la cadena XML en cuestión. El segundo argumento no tiene aplicación práctica para este ejemplo y el tercero es solo para informar al constructor que (en este caso particular) el primer parámetro es una ruta a un archivo y no una cadena XML.

// Carga un archivo XML
$library = new SimpleXMLElement('library.xml', null, true);

Aquí viene lo interesante, el acceso a los hijos y atributos. He aquí por qué SimpleXMLElement hace magia; convierte a todos los nodos del árbol XML en atributos de clase y los atributos del XML mismo los convierte en variables a las que podemos acceder como arreglos asociativos.

Si hasta aquí todo va claro, entonces ya tenemos las bases para manipular de forma sencilla el archivo de la biblioteca para mostrar los libros en una tabla. Y nos debería quedar algo así:

echo '<table>';
echo '<tr>';
echo   '<th>Title</th>
        <th>Author</th>
        <th>Publisher</th>
        <th>ISBN</th>';
echo '</tr>';
foreach( $library->book as $book ) {
	echo '<tr>';
	echo '<td>' . $book->title . '</td>';
	echo '<td>' . $book->author . '</td>';
	echo '<td>' . $book->publisher . '</td>';
	echo '<td>' . $book['isbn'] . '</td>';
	echo '</tr>';
}
echo '</table>';

El problema ahora sería, ¿qué pasa si no conocemos todos los nombres de los elementos ni los atributos? SimpleXMLElement tiene la solución. Los métodos SimpleXMLElement::children() y SimpleXMLElement::attributes() así como el método recien introducido en PHP5.1.3 SimpleXMLElement::getName() nos ayudarán en gran medida.

Como bien se sobreentiende, el método children() regresa los nodos hijos de elemento actual. El método attributes() regresa los atributos del elemento actual y el método getName() el nombre del elemento actual. Todos se pueden aplicar recurrentemente dependiendo del nivel de anidación de los elementos. Es decir, si estamos en el elemento $x, y llamamos a $x->children() obtendremos a los hijos de $x, y si a uno de esos hijos le aplicamos el children() obtendremos los nietos de $x, y así sucesivamente.

De modo que, para concluir, el plugin que hice solo lee el feed, saco el nodo hijo <item> del elemento raíz que es <channel> llamándolo así:

$item = $apod->channel->item[0];

La posición cero indica que es el primer item del documento, es decir, el elemento con el cual se ha actualizado el feed. Y con ese elemento trabajo para obtener los demás datos. Por ejemplo, si la descripción es un elemento hijo de cada item, la obtengo así:

$descripcion = $apod->channel->item[0]->description;

Hasta aquí llega el microtutorial de hoy que ha servido para ver cómo parsear una cadena de XML para leerla nada más. La próxima semana escribiré cómo modificar documentos XML.

Fuente de inspiración: El manual para certificación de Zend PHP.

• Cómo modificar documentos XML con PHP
• Cómo obtener todos los comentarios y replies de Facebook con FQL
• Clase para manejar base de datos MySQL en PHP
• Método de Gauss en PHP
• Manejo de errores en PHP
• Pilas en PHP
• Variables de servidor de PHP

Por ejemplo un error de léxico podría ser al escribir mal alguna sentencia de control:

$x = 1;
whle ( $x < 10 ) {
	echo $x;
	$x++;
}

El error en whle detendrá la ejecución.

Un ejemplo de error sintáctico sería cuando nos falta algo o le pusimos algo de más a nuestro código, algo de lo que el parser se quejaría.

while ( $x < 10 ) {
	echo $x
	$x++;
}

La falta del punto-y-coma provocará un error fatal.

Por último, un error de semántica se da cuando algo en el código no tiene lógica. Por ejemplo:

$x = 10;
while ( $x == 'hola' ) {
	echo $x;
	$x++;
}

No se puede comparar un entero con un string.

A veces movemos y movemos el código y sin querer dejamos “huecos” y “cosas repetidas” y al probar nuestra aplicación o simple página nos damos cuenta de que tenemos muchos errores. Si estamos en fase de desarrollo entonces esto nos va muy bien porque así podemos estar arreglando todo mientras vamos descubriendo los errores. Pero y ¿si el “trabajo” no era para nosotros sino para agluien mas?

La solución es usar la directiva de reporte de errores de PHP. Con ellas, y como desarrolladores de un sistema creado en PHP tenemos la habilidad de decidir si el usuario final puede o no ver los errores. Algunas configuraciones de los errores anteriormente mencionado se hacen en el archivo de configuración php.ini. Algunas de las funciones mas importantes son: error_reporting, display_errors y log_errors.

La función error_reporting() recibe un entero como parámetro y retorna otro entero. Los valores que recibe vienen dados en constantes predefinidas de PHP y el valor retornado es el antiguo nivel de reporte.

Por ejemplo, cuando estamos desarrollando es bueno conocer todos los errores. A veces usamos una variable sin definirla primero (PHP no se queja de ellos, pero aunque no lo creas eso produce un error de tipo E-NOTICE). Todos estos tipos de errores que por defecto no se muestran porque PHP4 y PHP5 vienen preconfigurados así:

	error_reporting( E_ALL & ~E_NOTICE );

Lo que significa que va a reportar todos menos noticias. Puedes configurarlo para que aparezcan las noticias simplemente llamando a error_repoting y mandandole como parámetro E-ALL.

	error_reporting( E_ALL );

En el registro de funciones y gestión de errores de php.net encontramos una explicación más amplia de todos los posibles valores. Ahora bien, ¿cómo ocultamos todos los errores? Simplemente poniendo un cero como parámetro:

	error_reporting( 0 );

En ambientes de producción, no es recomendable que el cliente pueda ver los errores o bugs que probablemente van a aparecer. Para ocultarlos y llevar un registro de ellos podemos establecer el reporte de errores a cero y además podemos configurar nuestro php.ini para que guarde un registro de errores al que podemos acceder más tarde y arreglarlos sin que el usuario final se dé cuenta. En el php.ini solo encenderiamos la directiva log_errors, para que qude así:

	log_errors = on;

En fín, son muchas las posibilidades, aquí solo muestro las más fáciles y comunes. Después haré un microtutorial para el manejo de excepciones en PHP, claro, orientado a objetos.

• Clase para manejar base de datos MySQL en PHP
• Método de Gauss en PHP
• Cómo modificar documentos XML con PHP
• Cómo acceder a los datos de XML en PHP
• Pilas en PHP
• Variables de servidor de PHP
• Cómo obtener todos los comentarios y replies de Facebook con FQL

Lo primero que hay que saber es que una pila -tanto en PHP como en Java y cualquier lenguaje- no es más que un arreglo de elementos que funciona mediante la filosofía LIFO. Entonces para usar una pila en PHP primero hay que tener un arreglo creado.

Podemos crearlo e inicializarlo o simplemente crearlo con la funcion array de esta manera.

$arreglo1 = array();
$arreglo2 = array( $dato1 , $dato 2 , $dato3 );

Bien, ya que tenemos un array las funciones que PHP nos da para manipular la pila son array_push() y array_pop() que sirven para insertar un elemento y retirar un elemento del arreglo respectivamente. Un ejemplo típico de uso de una pila es verificar si una palabra dada es palíndromo. Palíndromo es aquella palabra que leída de derecha a izquierda es igual que de izquierda a derecha.

Para hacer esto necesitamos tomar la palabra que queremos verificar. Luego hay que meter cada caracter a un arreglo y posteriormente sacar cada caracter en orden inverso a como se metieron y concatenarlo a otra cadena. Una vez vaciado el arreglo comparamos la palabra original y la cadena que creamos al vaciar el arreglo, si son iguales, la palabra es un palíndromo.

Esta sería la función PHP que comprueba si una palabra es palíndromo o no.

function es_palindromo( $word ) {
	$cadena = "";
	$pila = array();

	for ( $i = 0; $i< count( $word ); $i++ ) {
		array_push( $pila , substr($word,$i,$i+1) );
	}
	while ( count( $pila ) > 0 ) {
		$cadena .= array_pop( $pila );
	}
	return ( $word == $cadena );
}

Como se ve, array_push( $pila , $dato ) unicamente inserta en el arreglo o pila especificado el elemento dado, y es de tipo entero ya que regresa el número de elementos que contiene la pila (aunque en este caso no es necesario saberlo). array_pop( $pila ) extrae de la pila que se especifica el último elemento y lo regresa. Nótese que en el ciclo while la condición es que mientras el tamaño de la pila sea mayor a cero. Esto bien podría ser así: while (count($pila)) y ya, la diferencia es que esto consume más tiempo de ejecución ya que es más lento verificar que un elemento exista a hacer una comparación.

Ok, aqui termino, el código no lo chequé, creo que debe funcionar porque no le veo ningún error de parsing, pero equivocarse en algún código es lo más común de nosotros los programadores ademas Boltzmann lo tiene más que comprobado. Si hay errores o dudas sobre cómo implementarlo, dejen comentarios.

• Clase para manejar base de datos MySQL en PHP
• Método de Gauss en PHP
• Cómo modificar documentos XML con PHP
• Cómo acceder a los datos de XML en PHP
• Manejo de errores en PHP
• Variables de servidor de PHP
• Cómo obtener todos los comentarios y replies de Facebook con FQL

¿Qué funciones de PHP podemos usar? Nos enfocaremos en una serie de variables que juntas pueden darnos acceso a información sobre nuestro servidor y sobre el cliente. La información de estas variables es atribuida por el servidor y en ningún caso nos es posible modificar sus valores directamente mediante el script. Para hacerlo es necesario influir directamente sobre la propiedad que definen.

La variable que examinaremos es $_SERVER[] que es una matriz que contiene información tal como cabeceras, rutas y ubicaciones de scripts. Las entradas de esta matriz son creadas por el servidor web.

Estas son algunos elementos de la matriz, solo destacaremos los más importantes:

$_SERVER['PHP_SELF']
// El nombre de archivo del script ejecutándose actualmente
$_SERVER['SERVER_ADDR']
//La dirección IP del servidor bajo la cual está siendo ejecutado el script actual.
$_SERVER['QUERY_STRING']
// La cadena de consulta, si existe, mediante la cual se accedió a la página.
$_SERVER['HTTP_REFERER']
// La dirección de la página que refirió al navegador a la página actual.
$_SERVER['HTTP_USER_AGENT']
// Esta es una cadena que denota el navegador que está accediendo a la página.
$_SERVER['REMOTE_ADDR']
// La dirección IP desde donde el usuario está observado la página actual.
$_SERVER['SCRIPT_NAME']
// Contiene la ruta del script actual, útil para páginas que necesitan apuntar a ellas mismas.
$_SERVER['REQUEST_URI']
// El URI que fue dado para acceder a esta página; por ejemplo, '/index.php?id=1'.


Todas las anteriores son cadenas, puedes ver muchas más en la clase HttpRequest y un ejemplo de uso en el archivo de pruebas de la misma clase. Repito, estas son solo las variables de servidor, aún quedan las variables de petición, las de sesiones, las de entorno, etc.

La clase HttpRequest, la consigues en EsLoMas.

• Clase para manejar base de datos MySQL en PHP
• Método de Gauss en PHP
• Cómo modificar documentos XML con PHP
• Cómo acceder a los datos de XML en PHP
• Manejo de errores en PHP
• Pilas en PHP
• Cómo obtener todos los comentarios y replies de Facebook con FQL