O que é PEAR?
PEAR é a abreviatura de PHP Extension and Application Repository. É um repositório de código para extensões e aplicativos PHP. Simplificando, PEAR é o CPAN do PHP.
Por que usar PEAR?
PHP é uma linguagem de script excelente, concisa e eficiente. Com o lançamento do 4.0, mais e mais pessoas estão usando-o para desenvolver sites dinâmicos. Pode-se dizer que o PHP se tornou uma das melhores linguagens de desenvolvimento da INTERNET, principalmente o PHP. linguagem preferida para desenvolvedores de sites que precisam ser capazes de desenvolver aplicativos para pequenas e médias empresas de maneira rápida e eficiente. No entanto, com o número crescente de aplicativos PHP, há uma falta de padrões unificados e de gerenciamento eficaz desses aplicativos. Portanto, é difícil para a comunidade PHP compartilhar os códigos e aplicativos uns dos outros de maneira tão conveniente quanto as pessoas da comunidade PERL. PHP não possui os mesmos padrões do CPAN. Uma base de código unificada para classificar e gerenciar módulos de código de aplicativo (qualquer pessoa familiarizada com PERL sabe que CPAN é um enorme armazém de módulos de extensão PERL. Os módulos de aplicativo escritos podem ser colocados no diretório de classificação apropriado em CPAN, e outras pessoas podem É fácil de reutilizar. Claro, você também precisa seguir as diretrizes ao escrever módulos de aplicativo.)
Por esse motivo, o PEAR surgiu e foi distribuído com o núcleo do PHP a partir da versão 4.04.
Que benefícios o PEAR pode trazer para mim?
1. Conforme mencionado acima, o PEAR gerencia a base de código do aplicativo PEAR de acordo com determinadas categorias. Seu código PEAR pode ser organizado em diretórios apropriados e outras pessoas podem facilmente recuperar e compartilhar seus resultados.
2. PEAR não é apenas um repositório de código, é também um padrão. Usar este padrão para escrever seu código PHP aumentará a legibilidade e a reutilização do seu programa e reduzirá a chance de erros.
3. PEAR constrói uma estrutura para você, fornecendo 2 classes para implementar funções como destruidores e captura de erros. Você pode usar essas funções por meio de herança.
Regras de codificação do PEAR
As regras de codificação do PEAR incluem regras de indentação, estruturas de controle, chamadas de função, definições de função, comentários, código incluído, tags PHP, blocos de comentários de cabeçalho de arquivo, tags CVS, amostras de URL e nomenclatura de constantes. Aqui está uma breve introdução:
regras de recuo:
PEAR requer 4 espaços para recuar o código e nenhuma TAB é usada. Se você usa VIM, coloque as seguintes configurações em seu ~/.vimrc: set expandtab
definir largura de deslocamento = 4
set tabstop=4
Se você usa Emacs/XEmacs, você precisa definir indent-tabs-mode como nil.
Mas se você gosta de usar (X)Emacs para editar arquivos PHP como eu, eu recomendo fortemente que você instale o PHP-MODE para que quando você escrever código PEAR, ele ajuste automaticamente seu estilo de indentação. MODE Recurso muito bom, você pode baixar a versão mais recente do PHP-MODE na lista de recursos.
Estrutura de controle:
As estruturas de controle mencionadas aqui incluem: if for while switch, etc. Para estruturas de controle, deve haver um espaço após a palavra-chave (como if para ..) e depois os parênteses de controle, para que não seja confundido com chamadas de função. Além disso, você deve tentar usar chaves {}. tão completamente quanto possível, mesmo que seja sintaticamente opcional. Isso evitará confusões lógicas ou erros quando você precisar adicionar novas linhas de código no futuro. Aqui está um exemplo: if ((condição1) && (condição2)) {
Declaração 1;
}esleif ((Condição 3) || (Condição 4)) {
Declaração 2;
}outro {
Declaração 3;
}
Chamada de função:
Para chamadas de função, não deve haver espaço entre o nome da função e o colchete de abertura (()), para parâmetros de função, deve haver a mesma separação de espaço entre a vírgula delimitadora e o próximo parâmetro, e não deve haver espaço entre o último parâmetro e o colchete de fechamento. Abaixo está uma chamada de função padrão;
Escrita irregular:
$resultado=foo ($param1,$param2,$param3);
$resultado=foo($param1,$param2, $param3);
Além disso, se você deseja atribuir o resultado de retorno da função, deve haver um espaço entre o sinal de igual e a variável atribuída. Ao mesmo tempo, se for uma série de instruções de atribuição relacionadas, adicione espaços apropriados para alinhar. eles, assim:$resultado1 = $foo($param1, $param2, $param3);
$var2 = $foo($param3);
$var3 = $foo($param4, $param5);
Definição de função:
A definição da função segue a convenção "uma chave verdadeira": function connect(&$dsn, $persistent = false)
{
if (is_array($dsn)) {
$dsninfo = &&dsn;
} outro {
$dsninfo = DB::parseDSN($dsn);
}
if (!$dsninfo || !$dsninfo['phptype']) {
return $this->raiseError();
}
retornar verdadeiro;
}
Conforme mostrado acima, os parâmetros opcionais devem estar no final da lista de parâmetros e sempre tentar retornar valores de função significativos.
Em relação aos comentários:
Para documentação online de classes, ela deve poder ser convertida por PHPDoc, assim como JavaDoc. PHPDoc também é um aplicativo PEAR. Para uma introdução mais detalhada, você pode acessar http://www.phpdoc.de/ para visualizá-lo. Além da documentação on-line de classes, é recomendável usar comentários que não sejam de documentação para explicar seu código. Ao ver um trecho de código, você pensa: Ah, não acho que seja necessário descrevê-lo cuidadosamente na documentação. . Então é melhor você dar um comentário simples a este código para evitar que você se esqueça de como ele funciona. Para formulários de comentários, /* */ de C e // de C++ são bons. No entanto, não use o método de comentário # do Perl ou do shell.
Contém código:
Sempre que precisar incluir incondicionalmente um arquivo de classe, você deve usar require_once; quando precisar incluir condicionalmente um arquivo de classe, você deve usar include_once, isso garante que o arquivo que você deseja incluir será incluído apenas uma vez, e essas 2 instruções Ambas; compartilhe a mesma lista de arquivos, para que você não precise se preocupar com a confusão dos dois. Depois que require_once incluir um arquivo, include_once não incluirá o mesmo arquivo novamente e vice-versa.
Marcação de código PHP:
Sempre use <?php ?> para definir seu código php em vez de simplesmente usar <?> Isso garante a compatibilidade do PEAR e facilita a portabilidade entre plataformas.
Declaração de comentário no cabeçalho do arquivo:
Para todos os arquivos de código PHP que precisam ser incluídos na versão principal do PEAR, você deve adicionar a seguinte instrução de comentário no início do arquivo: /* vim: set expandtab tabstop=4 shiftwidth=4: */
// +---------------------------------------------------------- --- -----------------------+
// | PHP versão 4.0 |
// +---------------------------------------------------------- --- -----------------------+
// | Direitos autorais (c) 1997, 1998, 1999, 2000, 2001 O Grupo PHP |
// +---------------------------------------------------------- --- -----------------------+
// | Este arquivo fonte está sujeito à versão 2.0 da licença PHP, |
// | que acompanha este pacote no arquivo LICENSE e é |
// | disponível na Internet em |
// | http://www.php.net/license/2_02.txt .
// | Se você não recebeu uma cópia da licença do PHP e não consegue |
// | obtenha-o através da rede mundial de computadores, envie uma mensagem para |
// | [email protected] para que possamos enviar uma cópia para você imediatamente |
// +---------------------------------------------------------- --- -----------------------+
// | Autores: Autor Original |
// | Seu nome |
// +---------------------------------------------------------- --- -----------------------+
//
// $Id$
Para arquivos que não estão na base de código principal PEAR, é recomendado que você também tenha um bloco de comentários semelhante no início do arquivo, indicando copyright, acordo, autor, etc. Ao mesmo tempo, adicione MODELINE do VIM na primeira linha, para que o estilo de código do PEAR possa ser mantido no VIM.
Marcação CVS:
Conforme mostrado acima, adicione a tag CVS ID a cada arquivo. Se o arquivo que você edita ou modifica não tiver essa tag, adicione-a ou substitua-a por uma expressão semelhante no arquivo original (como "Última modificação" etc. )
amostra de URL:
Você pode seguir a RFC 2606 e usar " www.example.com " como todos os exemplos de URL.
Nomenclatura constante:
As constantes devem ser escritas em letras maiúsculas sempre que possível e, para facilitar o entendimento, use sublinhados para separar cada palavra. Ao mesmo tempo, você deve prefixar o nome do pacote ou nome da classe onde a constante está localizada. Por exemplo, as constantes na classe Bug devem começar com Bug_. Acima estão as regras de codificação do PEAR. Para regras de codificação detalhadas, consulte a descrição do arquivo CODING_STANDDARD no PEAR. Para entender melhor essas regras de codificação, você também pode consultar o código do módulo principal PEAR existente.
Comece com PEAR
PERA
Usar o PEAR é muito simples, você só precisa definir seu próprio programa PEAR assim: require_once "PEAR.php";
classe seu_nome_da_classe estende PEAR{
Sua definição de classe...
}
Claro, você precisa obedecer às regras de codificação PEAR mencionadas acima e então poderá implementar o que deseja fazer dentro de sua classe. A seguir, vamos discutir isso. Na verdade, PEAR nos fornece 2 classes predefinidas: PEAR: Esta é a classe base do PEAR e todas as extensões PEAR devem herdar e derivar dela. PEAR_Error: classe base de tratamento de erros do PEAR, você pode optar por derivar sua própria classe de tratamento de erros.
De modo geral, você não deve criar uma instância de PEAR diretamente, mas derivar você mesmo uma nova classe e, em seguida, criar uma instância dessa nova classe. Como classe base, PEAR nos fornece algumas funções úteis, as mais importantes são destruidores e
destruidores de tratamento de erros.
PHP suporta construtores, mas não suporta destruidores. No entanto, o PHP fornece a função Register_shutdown_function(), que pode chamar de volta a função registrada antes que o script termine. Se você tiver uma subclasse de PEAR chamada mypear, então na classe mypear, você pode definir uma função. O nome da função é um sublinhado mais o nome da sua classe, _mypear(). Porém, esse destruidor é diferente do destruidor em C++. Ele não será executado quando o objeto for excluído, mas quando o script terminar. Como Register_shutdown_function() é usado, as informações impressas não serão retornadas ao navegador em seu destruidor. Além disso, em seu construtor, você precisa chamar o construtor de sua classe pai, pois o PHP não chamará automaticamente o construtor da classe pai, e o destruidor precisa ser registrado no construtor do PEAR. Código fonte PEAR: <código>
função PERA() {
if (method_exists($this, "_".get_class($this))) {
global $_PEAR_destructor_object_list;
$_PEAR_desstructor_object_list[] = &this;
}
if ($this->_debug) {
printf("Construtor PEAR chamado, class=%sn",
get_class($this));
}
.....
função _PEAR_call_destructors() {
global $_PEAR_destructor_object_list;
if (is_array($_PEAR_destructor_object_list) && sizeof($_PEAR_destructor_object_list)) {
redefinir($_PEAR_destructor_object_list);
while (lista($k, $objref) = cada($_PEAR_destructor_object_list)) {
$destruidor = "_".get_class($objref);
if (method_exists($objref, $destruidor)) {
$objref->$destruidor();
}
}
//Limpa a lista de objetos cadastrados,
//Evita chamadas repetidas
$_PEAR_desstructor_object_list = array();
}
}
....
registrar_shutdown_function("_PEAR_call_destructors");
</código>
O código acima mostra como o PEAR implementa o destruidor. Na função do componente, ele verificará se existe um destruidor na classe atual. Nesse caso, a referência da classe atual será colocada em uma lista global, em _ In PEAR_call_destructors. , verifique se cada elemento da lista global possui um destruidor correspondente; em caso afirmativo, chame-o e, por fim, limpe a lista global.
Na última linha do código em PEAR.php, chame register_shutdown_function("_PEAR_call_destructors") para registrar _PEAR_call_destructors, para que quando o script for executado, o PHP chame de volta esta função. Usando o destruidor, você pode realizar alguns trabalhos de "cuidados posteriores" necessários antes de sair após processar a solicitação do usuário. Exemplos típicos são: você pode fechar arquivos abertos, desconectar-se do banco de dados e armazenar determinados dados no disco, etc.
Tratamento de erros
PEAR permite que você lide com erros de várias maneiras. Você não apenas retorna um código de erro ou informações de erro, mas também pode retornar um objeto PEAR_Error ou um novo objeto de erro derivado de PEAR_Error.
O objeto de erro no PEAR não limita o formulário de saída específico. Ele pode apenas capturar o erro sem retornar muitas informações ao usuário ou pode retornar uma função especial de tratamento de erros ao mesmo tempo, mesmo que gere informações de erro. , também pode ser forçado a usar o formato HTML. Você pode gerar XML, formato CSV ou outros formatos definidos por você mesmo. Você só precisa derivar uma nova classe de PEAR_Error e, em seguida, criar e "lançar" essa nova classe no. momento apropriado.
Tratamento de erros simples:
No PEAR, o tratamento de erro mais simples é "lançar" o erro. Você simplesmente cria e retorna um objeto PEAR_Error. Aqui está um exemplo simples: <código>
função minhaconexão($host = "localhost", $porta = 1080)
{
$fp = fsockopen($host, $porta, $errno, $errstr);
if (!is_resource($fp)) {
retornar novo PEAR_Error($errstr, $errno);
}
retornar $fp;
}
$meia = minhaconexão();
if (PEAR::isError($sock)) {
print "erro de conexão: ".$sock->getMessage()."<BR>n"
}
</code>
Conforme mostrado no código acima, após executar um trecho de código que pode produzir um erro, você precisa usar isError de PEAR para detectar se há um erro e pode usar getMessage de PEAR_Error para obter a mensagem de erro mais recente.
Nota: Certifique-se de usar PEAR::isErrore raiseError
em locais importantes.
Após o PHP4.0.5, o PEAR possui mais 2 funções:
setErrorHandling($modo, $opções = null)
raiseError($message = null, $code = null, $mode = null,$options = null, $userinfo = null)
O primeiro pode definir o modo de tratamento de erros padrão do PEAR, e o último é uma função wrapper que retorna um objeto PEAR_Error, o que é um pouco diferente de criar e retornar diretamente um objeto PEAR_Error. Se você omitir parâmetros como $mode e $options, ele usará valores padrão para criar o objeto PEAR_Error. Você pode usar setErrorHandling() para personalizar esses valores padrão. .
PEAR_Erro
PEAR_Error é uma classe base do objeto de erro do PEAR. Ao contrário do PEAR, de modo geral, você pode criar diretamente uma instância de PEAR_Error. O método de criação é: $error = new PEAR_Error($message, $code, $mode, $options, $userinfo. );
$message é a sua mensagem de erro, $code é o número do erro e os três últimos parâmetros estão intimamente relacionados:
$mode: é o modo de tratamento de erros, que pode ser as seguintes constantes:
PEAR_ERROR_RETURN: Retorna apenas o objeto de erro (modo padrão)
PEAR_ERROR_PRINT: Imprime esta mensagem de erro na função de construção, mas o programa atual continuará em execução.
PEAR_ERROR_TRIGGER: Use trigger_error() do PHP para disparar um erro. Se você configurou uma função de tratamento de erros ou definiu o nível de tratamento de erros do PHP como E_USER_ERROR, o programa atual será encerrado.
PEAR_ERROR_DIE: Imprime o erro e sai, o programa termina.
PEAR_ERROR_CALLBACK: Use uma função ou método de retorno de chamada para lidar com o erro atual e o programa termina.
$options: Este parâmetro só funciona quando $mode é PEAR_ERROR_TRIGGER e PEAR_ERROR_CALLBACK Se for PEAR_ERROR_TRIGGER, $options deve ser uma das três constantes E_USER_NOTICE, E_USER_WARNING ou E_USER_ERROR, que é consistente com o valor de trigger_error no PHP. Se $mode for PEAR_ERROR_CALLBACK, $options pode ser uma string contendo o nome da função a ser chamada de volta, ou um array de 2 elementos, respectivamente uma variável de objeto e uma string (indicando o método a ser chamado).
$userinfo: Armazena informações adicionais do usuário. Você pode colocar informações de depuração relevantes aqui.
Existem alguns métodos comumente usados em PEAR_Error, que não são descritos na documentação do PHP. Eles estão listados aqui:
int getMode: Retorna o modo atual de tratamento de erros, inteiro.
string getMessage: Retorna a mensagem de erro completa atual, string.
getCallback misto: Retorna as informações de retorno de chamada atuais, que podem ser o nome da função que está sendo chamada de volta ou um array de (objetos, métodos).
int getCode: Retorna um código de erro inteiro.
string getType: Retorna o tipo errado, que é o nome da classe atual, string.
string getUserInfo: Retorna informações adicionais do usuário, string.
string getDebugInfo: O conteúdo é igual ao anterior.
string toString: Retorna uma descrição detalhada da string do objeto atual, incluindo modo de tratamento de erros, nível, informações de erro, código de erro, funções de retorno de chamada relacionadas, etc.
resumo
, a introdução ao PEAR acabou. Em resumo, se você quiser fazer uma aplicação de extensão PEAR, você precisa fazer o seguinte:
require_once "PEAR.php"
Use a classe your_pear_extend extends PEAR{} para definir sua nova classe.
No construtor da sua classe, chame o construtor da classe pai PEAR: function your_pear_extend{
$this->PEAR();
...
}
Se necessário, defina seu destruidor _your_pear_extend
Se necessário, derive sua própria classe de tratamento de erros de PEAR_Error para definir seu modo de tratamento de erros e acionar erros quando apropriado.
Após executar o código que pode gerar erros, use PEAR::isError($obj) para capturar os erros correspondentes.
Implemente sua própria funcionalidade.
Na última versão principal do PEAR do PHP4.05, já existem muitos módulos de aplicativos excelentes, como: PHPDoc, Cache, HTML... Claro, comparado ao CPAN, o PEAR está apenas começando e precisa de pessoas da comunidade PHP. Com nossos esforços conjuntos para melhorá-lo e aprimorá-lo, o PHP se tornará cada vez mais poderoso.
Materiais de referência
Página inicial do Pear Página
inicial do PHP
A página inicial do PHPDoc, que pode gerar documentos API semelhantes ao JAVADOC a partir do código-fonte do seu aplicativo PEAR
PHP-Mode para XEmacs/Emacs, fornece suporte de sintaxe php para emacs/xemacs e pode também suportar
a página inicial do Vim no estilo de código pear. Um editor muito bom com bom suporte para PHP
Sobre o autor
Pan Fan (Night Sailer): Engenheiro da Beijing Saidi Data Co., Ltd. Envolvido principalmente na análise e conversão de dados, bem como no trabalho de desenvolvimento relacionado. Bom no uso de VB, PERL, PHP para desenvolvimento e trabalho em língua chinesa no Linux. Meus interesses recentes são a aplicação de Perl, PHP e XML, o modelo de desenvolvimento MVC do PHP e o uso de PERL-GTK. Você pode contatá-lo através do e-mail: [email protected].