Como se mencionó anteriormente, PEAR administra la base del código de la aplicación PEAR de acuerdo con ciertas categorías. Su código PEAR se puede organizar en directorios apropiados y otras personas pueden recuperar y compartir fácilmente sus resultados. PEAR no es sólo un repositorio de código, también es un estándar. El uso de este estándar para escribir su código PHP mejorará la legibilidad y reutilización de su programa y reducirá la posibilidad de errores. PEAR construye un marco para usted al proporcionar dos clases que implementan funciones como destructores y detección de errores. Puede usar estas funciones mediante herencia.
Las reglas de codificación de PEAR incluyen reglas de sangría, estructuras de control, llamadas a funciones, definiciones de funciones, comentarios, código incluido, etiquetas PHP, bloques de comentarios de encabezados de archivos, etiquetas CVS, muestras de URL y denominación constante. Aquí hay una breve introducción:
Reglas de sangría:
PEAR requiere 4 espacios para sangrar el código y no se utiliza TAB. Si usa VIM, coloque las siguientes configuraciones en su ~/.vimrc: establezca expandtab
establecer ancho de desplazamiento = 4
establecer tabulación = 4
Si usa Emacs/XEmacs, debe configurar el modo de pestañas de sangría en cero.
Pero si te gusta usar (X)Emacs para editar archivos PHP como yo, te recomiendo encarecidamente que instales PHP-MODE para que cuando escribas código PEAR, ajuste automáticamente tu estilo de sangría. Por supuesto, hay muchos PHP. MODE Muy buena característica, puede descargar la última versión de PHP-MODE desde la lista de recursos.
Estructura de control:
Las estructuras de control mencionadas aquí incluyen: interruptor if for while, etc. Para las estructuras de control, debe haber un espacio después de la palabra clave (como if for ..) y luego los paréntesis de control, para que no se confunda con llamadas a funciones. Además, debe intentar usar llaves {}. lo más completo posible incluso si es sintácticamente opcional. Esto evitará confusiones lógicas o errores cuando necesite agregar nuevas líneas de código en el futuro. Aquí hay un ejemplo: if ((condición1) && (condición2)) {
Declaración 1;
}esleif ((Condición 3) || (Condición 4)) {
Declaración 2;
}demás {
Declaración 3;
}
Llamada de función:
Para llamadas a funciones, no debe haber espacio entre el nombre de la función y el corchete de apertura ( (), para parámetros de función, debe haber la misma separación de espacios entre la coma delimitadora y el siguiente parámetro, y no debe haber espacio entre el último parámetro y el corchete de cierre. A continuación se muestra una llamada de función estándar $resultado = foo($param1, $param2, $param3);
Escritura irregular:
$resultado=foo ($param1,$param2,$param3);
$resultado=foo( $param1,$param2, $param3 );
Además, si desea asignar el resultado de retorno de la función, debe haber un espacio entre el signo igual y la variable asignada. Al mismo tiempo, si se trata de una serie de declaraciones de asignación relacionadas, agregue los espacios apropiados para alinear. ellos, así: $resultado1 = $foo($param1, $param2, $param3);
$var2 = $foo($param3);
$var3 = $foo($param4, $param5);
Definición de función:
La definición de la función sigue la convención de "una llave verdadera": function connect(&$dsn, $persistent = false){
si (is_array($dsn)) {
$dsninfo = &&dsn;
} demás {
$dsninfo = DB::parseDSN($dsn);
}
si (!$dsninfo || !$dsninfo['phptype']) {
devolver $this->raiseError();
}
devolver verdadero;
}
Como se muestra arriba, los parámetros opcionales deben estar al final de la lista de parámetros y siempre intentar devolver valores de función significativos.
Respecto a los comentarios:
Para la documentación en línea de clases, debería poder convertirse mediante PHPDoc, al igual que JavaDoc. PHPDoc también es una aplicación PEAR. Para obtener una introducción más detallada, puede visitar http://www.phpdoc.de/ para verla. Además de la documentación en línea de las clases, se recomienda que utilice comentarios que no sean de documentación para explicar su código. Cuando ve un fragmento de código, piensa: Oh, no creo que sea necesario describirlo cuidadosamente en la documentación. . Entonces será mejor que le des un comentario simple a este código para evitar que olvides cómo funciona. Para formularios de comentarios, /* */ de C y // de C++ son buenos. Sin embargo, no utilice el método de comentario # de Perl o Shell.
Contiene código:
Siempre que necesite incluir un archivo de clase incondicionalmente, debe usar require_once; cuando necesite incluir un archivo de clase condicionalmente, debe usar include_once, esto garantiza que el archivo que desea incluir solo se incluirá una vez, y estas 2 Ambas declaraciones; comparte la misma lista de archivos, por lo que no tiene que preocuparse de que los dos se confundan. Una vez que require_once incluye un archivo, include_once no volverá a incluir el mismo archivo y viceversa.
Marcado de código PHP:
Defina su código PHP en todo momento, en lugar de simplemente usarlo. Esto garantiza la compatibilidad con PEAR y facilita la portabilidad entre plataformas.
Declaración de comentario en el encabezado del archivo:
Para todos los archivos de código PHP que deben incluirse en la versión principal de PEAR, debe agregar la siguiente declaración de comentario al principio del archivo: /* vim: set expandtab tabstop=4 shiftwidth=4: */
// +----------------------------------------------- --- -----------------------+
// | PHP versión 4.0 |
// +----------------------------------------------- --- -----------------------+
// | Copyright (c) 1997, 1998, 1999, 2000, 2001 El Grupo PHP |
// +----------------------------------------------- --- -----------------------+
// | Este archivo fuente está sujeto a la versión 2.0 de la licencia PHP, |
// | que se incluye con este paquete en el archivo LICENCIA y es |
// | disponible en a través de la red mundial en |
// | http://www.php.net/license/2_02.txt .
// | Si no recibió una copia de la licencia PHP y no puede |
// | obtenerlo a través de la red mundial, por favor envíe una nota a |
// | [email protected] para que podamos enviarle una copia inmediatamente |
// +----------------------------------------------- --- -----------------------+
// | Autores: Autor original |
// | Tu nombre |
// +----------------------------------------------- --- -----------------------+
//
// $Identificación$
Para archivos que no están en el código base central de PEAR, se recomienda que también tenga un bloque de comentarios similar como este al principio del archivo, indicando derechos de autor, licencia, autor, etc. Al mismo tiempo, agregue MODELINE de VIM en la primera línea, para que el estilo del código de PEAR se pueda mantener en VIM.
Marcado CVS:
Como se muestra arriba, agregue la etiqueta CVS ID a cada archivo. Si el archivo que edita o modifica no tiene esta etiqueta, agréguela o reemplácela con una expresión similar en el archivo original (como "Última modificación", etc. )
Muestra de URL:
Puede seguir RFC 2606 y utilizar " www.example.com " como todos los ejemplos de URL.
Denominación constante:
Las constantes deben escribirse en mayúsculas cuando sea posible y, para que sea más fácil de entender, utilice guiones bajos para separar cada palabra. Al mismo tiempo, debe anteponer el nombre del paquete o el nombre de la clase donde se encuentra la constante. Por ejemplo, las constantes de la clase Bug deberían comenzar con Bug_. Las anteriores son las reglas de codificación de PEAR. Para obtener reglas de codificación detalladas, consulte la descripción del archivo CODING_STANDDARD en PEAR. Para comprender mejor estas reglas de codificación, también puede consultar el código del módulo principal PEAR existente.
Comience con PERA
Usar PEAR es muy simple, sólo necesitas definir tu propio programa PEAR así: require_once "PEAR.php";
clase tu_nombre_clase extiende PEAR{
Tu definición de clase...
}
Por supuesto, debe cumplir con las reglas de codificación PEAR mencionadas anteriormente y luego podrá implementar lo que desee hacer dentro de su clase. A continuación, analicémoslo. De hecho, PEAR nos proporciona 2 clases predefinidas: PEAR: esta es la clase base de PEAR, y todas las extensiones de PEAR deben heredarla y derivar de ella. PEAR_Error: clase base de manejo de errores de PEAR, puede optar por derivar su propia clase de manejo de errores.
En términos generales, no debe crear una instancia de PEAR directamente, sino derivar una nueva clase usted mismo y luego crear una instancia de esta nueva clase. Como clase base, PEAR nos proporciona algunas funciones útiles, las más importantes son los destructores y
los destructores de manejo de errores.
PHP admite constructores, pero no admite destructores. Sin embargo, PHP proporciona la función Register_shutdown_function(), que puede volver a llamar la función registrada antes de que finalice el script. Por lo tanto, PEAR aprovecha esta característica para proporcionar simulación del destructor. Si tiene una subclase de PEAR llamada mypear, entonces en la clase mypear puede definir una función. El nombre de la función es un guión bajo más el nombre de su clase, _mypear(). Sin embargo, este destructor es diferente del destructor en C++. No se ejecutará cuando se elimine el objeto, sino cuando finalice el script. Después de todo, esto es solo una simulación. Dado que se utiliza Register_shutdown_function(), la información impresa no se devolverá al navegador en su destructor. Además, en su constructor, debe llamar al constructor de su clase principal, porque PHP no llamará automáticamente al constructor de la clase principal y el destructor debe estar registrado en el constructor de PEAR. Podemos echar un vistazo. PERA Código fuente: función PERA() {
si (method_exists($esto, "_".get_class($esto))) {
global $_PEAR_destructor_object_list;
$_PEAR_destructor_object_list[] = &this;
}
si ($this->_debug) {
printf("Constructor PEAR llamado, clase=%sn",
get_class($esto));
}
.....
función _PEAR_call_destructors() {
global $_PEAR_destructor_object_list;
if (is_array($_PEAR_destructor_object_list) && tamaño de($_PEAR_destructor_object_list)) {
restablecer($_PEAR_destructor_object_list);
mientras (lista($k, $objref) = cada($_PEAR_destructor_object_list)) {
$destructor = "_".get_class($objref);
si (method_exists($objref, $destructor)) {
$objref->$destructor();
}
}
//Borrar la lista de objetos registrados,
//Evitar llamadas repetidas
$_PEAR_destructor_object_list = matriz();
}}
....
Register_shutdown_function("_PEAR_call_destructors");
El código anterior muestra cómo PEAR implementa el destructor. En la función del componente, verificará si hay un destructor en la clase actual. Si es así, la referencia de la clase actual se colocará en una lista global, en _ En PEAR_call_destructors. , verifique si cada elemento en la lista global tiene un destructor correspondiente; si es así, llámelo y finalmente borre la lista global.
En la última línea de código en PEAR.php, llame a Register_shutdown_function("_PEAR_call_destructors") para registrar _PEAR_call_destructors, de modo que cuando se ejecute el script, PHP vuelva a llamar a esta función. Usando el destructor, puede realizar algunos trabajos de "cuidado posterior" necesarios antes de salir después de procesar la solicitud del usuario. Los ejemplos típicos son que puede cerrar archivos abiertos, desconectarse de la base de datos y almacenar ciertos datos en el disco, etc.
Manejo de errores
PEAR le permite manejar errores de muchas maneras. No solo devuelve un código de error o información de error, sino que también puede devolver un objeto PEAR_Error o un nuevo objeto de error derivado de PEAR_Error.
El objeto de error en PEAR no limita el formulario de salida específico. Puede simplemente capturar el error sin devolver demasiada información al usuario, o puede devolver una función especial de manejo de errores al mismo tiempo, incluso si genera información de error. , también puede Está obligado a utilizar el formato HTML. Puede generar formato XML, CSV u otros formatos definidos por usted mismo. Solo necesita derivar una nueva clase de PEAR_Error y luego crear y "lanzar" esta nueva clase. momento apropiado.
Manejo de errores simple:
En PEAR, el manejo de errores más simple es "arrojar" el error. Simplemente crea y devuelve un objeto PEAR_Error. Aquí hay un ejemplo simple: function myconnect($host = "localhost", $port = 1080){
$fp = fsockopen($host, $puerto, $errno, $errstr);
si (!is_resource($fp)) {
devolver nuevo PEAR_Error($errstr, $errno);
}
devolver $fp;
}
$calcetín = miconexión();
si (PERA::isError($calcetín)) {
imprimir "error de conexión: ".$sock->getMessage()."n"
}
Como se muestra en el código anterior, después de ejecutar un fragmento de código que puede producir un error, debe usar isError de PEAR para detectar si hay un error, y puede usar getMessage de PEAR_Error para obtener el último mensaje de error.
y riseError
en lugares clave.
Después de PHP4.0.5, PEAR tiene 2 funciones más:
setErrorHandling($modo, $opciones = nulo)
riseError($mensaje = nulo, $código = nulo, $modo = nulo,$opciones = nulo, $información de usuario = nulo)
El primero puede establecer el modo de manejo de errores predeterminado de PEAR, y el segundo es una función contenedora que devuelve un objeto PEAR_Error. Es ligeramente diferente de crear y devolver directamente un objeto PEAR_Error. Si se omiten parámetros como $mode y $options. Cree este objeto PEAR_Error usando valores predeterminados, que puede personalizar usando setErrorHandling().
PERA_Error
PEAR_Error es una clase base del objeto de error de PEAR. A diferencia de PEAR, en términos generales, puede crear directamente una instancia de PEAR_Error. El método de creación es: $error = new PEAR_Error($message, $code, $mode, $options, $. userinfo);
$message es su mensaje de error, $code es el número de error del error y los últimos tres parámetros están estrechamente relacionados:
$mode: es el modo de manejo de errores, que pueden ser las siguientes constantes:
PEAR_ERROR_RETURN: solo devuelve el objeto de error (modo predeterminado)
PEAR_ERROR_PRINT: imprime este mensaje de error en la función de compilación, pero el programa actual continuará ejecutándose.
PEAR_ERROR_TRIGGER: Utilice trigger_error() de PHP para provocar un error. Si ha configurado una función de manejo de errores o ha establecido el nivel de manejo de errores de PHP en E_USER_ERROR, el programa actual finalizará.
PEAR_ERROR_DIE: Imprime el error y sale, el programa finaliza.
PEAR_ERROR_CALLBACK: utilice una función o método de devolución de llamada para manejar el error actual y el programa finaliza.
$options: este parámetro solo funciona cuando $mode es PEAR_ERROR_TRIGGER y PEAR_ERROR_CALLBACK. Si es PEAR_ERROR_TRIGGER, $options debe ser una de las tres constantes E_USER_NOTICE, E_USER_WARNING o E_USER_ERROR, que es consistente con el valor de trigger_error en PHP. Si $mode es PEAR_ERROR_CALLBACK, $options puede ser una cadena que contiene el nombre de la función a llamar, o una matriz de 2 elementos, respectivamente una variable de objeto y una cadena (que indica el método a llamar).
$userinfo: almacena información adicional del usuario. Puede colocar información de depuración relevante aquí.
Hay algunos métodos comúnmente utilizados en PEAR_Error, que no se describen en la documentación de PHP. Se enumeran aquí:
int getMode: Devuelve el modo de manejo de errores actual, entero.
string getMessage: devuelve el mensaje de error completo actual, string.
getCallback mixto: devuelve la información de devolución de llamada actual, que puede ser el nombre de la función a la que se devuelve la llamada o una matriz de (objetos, métodos).
int getCode: devuelve un código de error entero.
string getType: devuelve el tipo incorrecto, que es el nombre de clase actual, string.
cadena getUserInfo: devuelve información adicional del usuario, cadena.
string getDebugInfo: el contenido es el mismo que el anterior.
string toString: devuelve una descripción de cadena detallada del objeto actual, incluido el modo de manejo de errores, nivel, información de error, código de error, funciones de devolución de llamada relacionadas, etc.
resumen
, la introducción a PEAR ha terminado. En resumen, si desea crear una aplicación de extensión PEAR, debe hacer esto:
require_once "PEAR.php"
Utilice la clase your_pear_extend extends PEAR{} para definir su nueva clase.
En el constructor de tu clase, llama al constructor de la clase principal PEAR: function your_pear_extend{
$esto->PERA();
...
}
Si es necesario, define tu destructor _your_pear_extend
Si es necesario, derive su propia clase de manejo de errores de PEAR_Error para configurar su modo de manejo de errores y desencadenar errores cuando sea apropiado.
Después de ejecutar el código que puede generar errores, use PEAR::isError($obj) para capturar los errores correspondientes.
Implemente su propia funcionalidad.
En la versión principal de PEAR, ya existen muchos módulos de aplicación excelentes, como PHPDoc, Cache y HTML.