Introducción a pear: use pear para escribir su próximo programa php
Contenido:
¿Qué es una pera?
¿Por qué utilizar pera?
¿Qué beneficios puede aportarme la pera?
Las reglas de codificación de Pear comienzan a usar Pear
Resumen de recursos relevantes y introducción del autor.
Pan Fan (velero nocturno) ( [email protected] )
Beijing Saidi.com Tecnología de la información Co., Ltd.
En junio de 2001 probablemente ya eras un veterano de PHP y habías escrito un montón de código fantástico. Pero si quieres agregarlos a tu proyecto actual ahora, ¿es un poco difícil? Tu amigo quiere usar tu código como módulo en su proyecto, pero descubres que usas estilos de codificación completamente diferentes. ¡Déjalo adaptarlo o incluso reescribirlo!
Sígueme y escribe tu programa PHP usando el estándar Pear. Tu programa tendrá mayor vitalidad. Tu programa y código se integrarán fácilmente con los códigos de otros expertos. Pear es como cpan para Al igual que Perl, hará que PHP genere mayor potencia.
que es un par
Pear es la abreviatura de la extensión php y el repositorio de aplicaciones. Es un repositorio de código para extensiones y aplicaciones PHP. En pocas palabras, pear es el cpan de PHP.
¿Por qué utilizar pera?
PHP es un lenguaje de programación excelente, conciso y eficiente. Con el lanzamiento de 4.0, cada vez más personas lo utilizan para desarrollar sitios web dinámicos. Se puede decir que PHP se ha convertido en uno de los mejores lenguajes de desarrollo de Internet, especialmente para aquellos sitios web. Para los desarrolladores que necesitan poder desarrollar aplicaciones para pequeñas y medianas empresas de forma rápida y eficiente, PHP es el lenguaje elegido. Sin embargo, con el creciente número de aplicaciones PHP, faltan estándares unificados y una administración efectiva para estas aplicaciones. Por lo tanto, es difícil para la comunidad PHP compartir códigos y aplicaciones entre sí tan convenientemente como las personas de la comunidad Perl, porque. PHP carece de la capacidad de compartir código y aplicaciones como Cpan. Una base de código unificada para clasificar y administrar módulos de código de aplicaciones (cualquiera que esté familiarizado con Perl sabe que cpan es un enorme almacén de módulos de extensión de Perl. Los módulos de aplicaciones escritos se pueden colocar en la clasificación adecuada). directorio en cpan, y otras personas pueden ser muy fáciles de reutilizar (por supuesto, también debe seguir las pautas al escribir módulos de aplicación).
Por esta razón nació pear y, a partir de 4.04, se distribuyó con el núcleo PHP.
¿Qué beneficios puede aportarme la pera?
1. 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.
2. 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.
3. Pear crea un marco para usted proporcionándole 2 clases para implementar funciones como destructores y detección de errores. Puede utilizar estas funciones mediante herencia.
Reglas de codificación para la pera.
Las reglas de codificación de Pear incluyen reglas de sangría, estructuras de control, llamadas a funciones, definiciones de funciones, comentarios, código que contiene, etiquetas PHP, bloques de comentarios en encabezados de archivos, etiquetas cvs, muestras de URL y denominación de constantes. Aquí hay una breve introducción:
Reglas de sangría:
Debe utilizar 4 espacios en pera para sangrar el código y no utilizar tabulaciones. Si usa vim, coloque las siguientes configuraciones en su ~/.vimrc:
establecer pestaña expandida
establecer ancho de desplazamiento = 4
set tabstop=4
Si usa emacs/xemacs, debe configurar indent-tabs-mode en nulo.
Pero si te gusta usar (x)emacs para editar archivos php como yo, te recomiendo encarecidamente que instales php-mode, de modo que cuando escribas código Pear, ajuste automáticamente tu estilo de sangría. Por supuesto, php-mode tiene. muchos más Característica muy buena, puede descargar la última versión del modo php 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ón 1) && (condición 2)) {
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:
Las definiciones de funciones siguen la convención de "una llave verdadera":
función conectar(&$dsn, $persistente = falso)
{
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 de Pear. Para 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 la forma 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:
Utilice siempre <?php ?> para definir su código PHP en lugar de simplemente utilizar <? ?>. Esto garantiza la compatibilidad de 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 de Pear Core, debe agregar la siguiente declaración de comentario al principio del archivo:
/* vim: establece expandtab tabstop=4 shiftwidth=4: */
// +----------------------------------------------- --- -----------------------+
// | PHP versión 4.0 |
// +----------------------------------------------- --- -----------------------+
// | derechos de autor (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 de 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 de php y no puede |
// | obtenerlo a través de la red mundial, por favor envíe una nota a |
// |[email protected] que podamos enviarle una copia por correo inmediatamente.
// +----------------------------------------------- --- -----------------------+
// | autores: autor original |
// | tu nombre |
// +----------------------------------------------- --- -----------------------+
//
// $id$
Para archivos que no están en la base del código principal de Pear, se recomienda que también tenga un bloque de comentarios similar al principio del archivo, que indique derechos de autor, acuerdo, autor, etc. Al mismo tiempo, la línea de modelo de vim también se agrega a la primera línea, de modo que el estilo del código de pear se pueda mantener en vim.
etiqueta 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 consultar RFC 2606 y utilizar " http://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 en 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_standard en pear. Para comprender mejor estas reglas de codificación, también puede consultar el código del módulo principal de Pear existente.
Empezar a usar pera
pera
Usar pear es fácil, sólo necesitas definir tu propio programa pear de esta manera:
require_once "pera.php";
clase tu_nombre_clase extiende pera{
Tu definición de clase...
}
Por supuesto, debe cumplir con las reglas de codificación de Pear mencionadas anteriormente y luego podrá implementar lo que desea 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: la clase base del 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 devolver la función registrada antes de que finalice el script. Por lo tanto, Pear utiliza esta función 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 consultar el código fuente de pear. código:
<código>
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 de pera 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");
</código>
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 esta manera, cuando se ejecute el script, PHP volverá 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 "lanzar" el error. Simplemente crea y devuelve un objeto pear_error. He aquí un ejemplo sencillo:
<código>
función myconnect($host = "localhost", $puerto = 1080)
{
$fp = fsockopen($host, $puerto, $errno, $errstr);
si (!is_resource($fp)) {
devolver nuevo pear_error($errstr, $errno);
}
devolver $fp;
}
$calcetín = miconexión();
if (pera::iserror($calcetín)) {
imprimir "error de conexión: ".$sock->getmessage()."<br>n"
}
</code>
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. Nota: asegúrese de utilizar pear::iserror en lugares clave
Usar aumento de error
Después de php4.0.5, pear tiene 2 funciones más:
seterrorhandling($modo, $opciones = nulo)
riseerror($message = null, $code = null, $mode = null,$options = null, $userinfo = null)
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. que es ligeramente diferente de crear y devolver directamente un objeto pear_error. Si omite parámetros como $mode y $options, usará valores predeterminados para crear el objeto pear_error. Puede usar seterrorhandling() para personalizar estos valores predeterminados. .
error_pera
pear_error es una clase base del objeto de error de pear. A diferencia de pear, en términos generales, puedes crear directamente una instancia de pear_error mediante:
$error = new pear_error($mensaje, $código, $modo, $opciones, $información de usuario);
$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 configurado 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: utiliza 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. Estos métodos 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.
string getuserinfo: Devuelve información adicional del usuario, string.
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.
En resumen, se acabó la introducción a la pera. En resumen, si quieres hacer una aplicación de extensión de pera, debes hacer esto:
require_once "pera.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:
función 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 última versión de Pear Core de php4.05, ya hay muchos módulos de aplicaciones excelentes, como: phpdoc, cache, html... Por supuesto, en comparación con cpan, Pear recién está comenzando y necesita gente de la comunidad php. Con nuestros esfuerzos conjuntos para mejorarlo y mejorarlo, PHP se volverá cada vez más poderoso.
Recursos relacionados
peraPágina de inicio
página de inicio php
Página de inicio de phpdoc, que puede generar documentos API similares a javadoc a partir del código fuente de su aplicación Pear.
Modo php para xemacs/emacs, proporciona soporte de sintaxis PHP para emacs/xemacs y puede admitir el estilo de código Pear.
página de inicio de vim, un muy buen editor, también tiene buen soporte para php