PHP 5.1 and spl_autoload_register

PHP 5.1 y spl_autoload_register

2008-03-31 06:03:00 +0000

Since PHP 5.1 we have spl_autoload_register (since PHP 5.0 we are able to define __autoload function);

Since PHP 5, if you define a function called __autoload, it will be called each time that you try to access a class that doesn’t exist. When calling a static method as well as instantiating a new object of that class.

This allows us to load code implicitly and forget about including dependencies everytime and allowing us to have a lazy loading very lightweight without having to load stuff that we are not interested in.

The only problem with this LazyLoading is that it forces us to use classes.

To group useful functions that we usually use, we can always define a util class with a set of static methods. For example, I usually use a function that I call print_r_pre, that does the same as print_r, but so it can display fine in a web browser (using htmlspecialchars). That’s it, you can create an util class with that function as a static method:

class util {
    static function print_r_pre($v) {
        echo '<pre>' . htmlspecialchars(print_r($v, true)) . '</pre>';
    }
}

I’d put this, for example, in a file called util.php, in a folder created to use __autoloadfeature. For example: /core/classes/util.php.

And later I would put this in a file that I should manually include (supposing that this file is inside /core/):

function __autoload($class) {
    if (!file_exists($file = dirname(__FILE__) . '/classes/' . $class . '.php')) return;
    require_once($file);
}

Summarizing:

If you are using PHP 5 and you want to avoid tons of require_once. __autoloadsolutions are for you.

Desde PHP 5.1 disponemos de spl_autoload_register (desde PHP 5.0 podemos definir la función __autoload).

En PHP 5 si se define una función __autoload, ésta se llamará cada vez que se intente acceder a una clase que no exista. Tanto para llamar a un método estático como para la instanciación de un nuevo objeto de dicha clase.

Esto nos permite cargar código implícitamente y olvidarnos de incluir dependencias continuamente y permitiéndonos tener un lazy loading muy lightweight sin tener que cargar cosas que no nos interesan.

La única pega que se le puede ver a este LazyLoading es que nos obliga a a usar clases.

Para agrupar funciones útiles que usemos comúnmente se puede define una clase “util” con una serie de métodos estáticos. Por ejemplo, yo suelo usar muy amenudo una función que llamo print_r_pre que se encarga de hacer lo mismo que un print_r, pero para que se vea correctamente en la web (usando <pre> y htmlspecialchars). Pues bien, me podría hacer una clase “util” con dicha función como método estático:

class util {  
	static function print_r_pre($v) {  
		echo '<pre>' . htmlspecialchars(print_r($v, true)) . '</pre>';  
	}  
}

Lo metería, por ejemplo, en un fichero llamado util.php en una carpeta creada para usar con la característica __autoload. Por ejemplo: /core/classes/util.php

Y luego en un fichero que sí que debería cargar cada vez algo tipo esto (suponiendo que el fichero que inclue este código esté en /core/):

function __autoload($class) {  
	if (!file_exists($file = dirname(__FILE__) . '/classes/' . $class . '.php')) return;  
	require_once($file);  
}  

Conclusión:

Si estás usando PHP 5 y quieres ahorrarte multitud de requiere_once. Las soluciones __autoload son para ti.