Introdução ao pear: Use o pear para escrever seu próximo programa php
Conteúdo:
O que é uma pêra
Por que usar pêra?
Que benefícios a pera pode trazer para mim?
As regras de codificação Pear começam a usar Pear
Resumo dos recursos relevantes e introdução do autor
Pan Fan (velejador noturno) ( [email protected] )
Pequim Saidi.com Tecnologia da Informação Co., Ltd.
Em junho de 2001 você provavelmente já era um veterano em PHP e havia escrito muitos códigos excelentes. Mas se você quiser adicioná-los ao seu projeto atual agora, é um pouco difícil? Seu amigo quer usar seu código como um módulo em seu projeto, mas você descobre que usa estilos de codificação completamente diferentes. Deixe-o adaptá-lo ou até mesmo reescrevê-lo!
Por favor, siga-me e escreva seu programa PHP usando o padrão pear. Seu programa terá maior vitalidade. Seu programa e código serão facilmente integrados com códigos de outros especialistas.
O que é um par
Pear é a abreviatura da extensão php e repositório de aplicativos. É um repositório de código para extensões e aplicativos PHP. Simplificando, pear é o cpan do PHP.
Por que usar pêra?
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, especialmente para aqueles sites. Para desenvolvedores que precisam ser capazes de desenvolver aplicativos para pequenas e médias empresas de maneira rápida e eficiente, o PHP é a linguagem preferida. No entanto, com o número crescente de aplicativos PHP, há uma falta de padrões unificados e de gerenciamento eficaz para esses 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 tem a capacidade de compartilhar código e aplicativos como 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 na classificação apropriada diretório em cpan, e outras pessoas podem reutilizar muito facilmente, é claro, você também precisa seguir as diretrizes ao escrever módulos de aplicativo).
Por isso surgiu o pear e, a partir do 4.04, foi distribuído com o núcleo PHP.
Que benefícios a pera 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 para pêra
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, conteúdo de código, tags PHP, blocos de comentários em cabeçalhos de arquivos, tags cvs, amostras de URL e nomenclatura de constantes. Aqui está uma breve introdução:
Regras de recuo:
Você precisa usar 4 espaços em pêra para recuar o código e não usar tabulações. Se você usa o vim, coloque as seguintes configurações em seu ~/.vimrc:
definir guia de expansão
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 modo php, para que quando você escrever código pera, ele ajuste automaticamente seu estilo de recuo. muito mais Recurso muito interessante, você pode baixar a versão mais recente do modo php 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ção 1) && (condição 2)) {
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;
$resultado = foo($param1, $param2, $param3);
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:
As definições de função seguem a convenção "uma chave verdadeira":
função conectar(&$dsn, $persistent = falso)
{
if (is_array($dsn)) {
$dsninfo = &$dsn;
} outro {
$dsninfo = banco de dados::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 pêra. 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 a forma 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 compatibilidade com peras 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 Pear Core, você deve adicionar a seguinte instrução de comentário no início do arquivo:
/* vim: define expandtab tabstop=4 shiftwidth=4: */
// +---------------------------------------------------------- --- -----------------------+
// | 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 na licença do arquivo 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 php e não consegue |
// | obtenha-o através da rede mundial de computadores, envie uma mensagem para |
// |[email protected] 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 pear core, é 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, a modelina do vim também é adicionada à primeira linha, para que o estilo de código da pêra possa ser mantido no vim.
etiqueta 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 consultar RFC 2606 e usar " http://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_. As regras de codificação acima são as do pear. Para regras de codificação detalhadas, consulte a descrição do arquivo coding_standard no pear. Para entender melhor essas regras de codificação, você também pode consultar o código do módulo Pear Core existente.
Comece a usar pêra
pera
Usar o Pear é fácil, você só precisa definir seu próprio programa Pear assim:
require_once "pear.php";
classe your_class_name estende pera{
Sua definição de classe...
}
Claro, você precisa obedecer às regras de codificação de pera mencionadas anteriormente 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:
pera: Esta é a classe base de pera e todas as extensões de pera devem herdar e derivar dela.
pear_error: A classe base do 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 de pear. código:
<código>
função pêra() {
if (method_exists($this, "_".get_class($this))) {
global $_pear_destructor_object_list;
$_pear_destructor_object_list[] = &$this;
}
if ($this->_debug) {
printf("Construtor pêra 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_destructor_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. Desta forma, quando o script for executado, o PHP chamará 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ê. 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 o iserror de pear para detectar se há um erro, e você pode usar o getmessage de pear_error para obter a mensagem de erro mais recente. Nota: Certifique-se de usar pear::iserror em locais-chave
Usar raiseerror
Após o php4.0.5, o pear tem mais 2 funções:
seterrhandling($mode, $options = 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. .
pera_error
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:
$erro = new pear_error($mensagem, $código, $modo, $opções, $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 em 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. Esses métodos não estão descritos na documentação do PHP.
int getmode: Retorna o modo de tratamento de erros atual, 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 é o mesmo acima.
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.
Em resumo, a introdução à pêra acabou. Em resumo, se você quiser fazer uma aplicação de extensão de pera, 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:
função your_pear_extend{
$this->pêra();
...
}
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 disparar 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 do pear core 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.
Recursos relacionados
pêraPágina inicial
página inicial do php
Página inicial do phpdoc, que pode gerar documentos API semelhantes ao javadoc a partir do código-fonte do seu aplicativo pear
modo php para xemacs/emacs, fornece suporte à sintaxe PHP para emacs/xemacs e pode suportar bem o estilo de código pera
A página inicial do vim, um editor muito bom, também tem um bom suporte para php