Como usar instruções de programação PHP

Autor：Eve Cole Data da Última Atualização：2009-06-05 16:33:41

PHP é uma linguagem de programação de rede eficiente. Devido às suas vantagens de escrita flexível e execução rápida, tornou-se rapidamente a linguagem preferida dos programadores da Web. Uma pesquisa confiável mostrou recentemente que 31,6% dos sites agora usam PHP como principal linguagem de programação do lado do servidor.

No entanto, não é fácil se tornar um mestre em programação PHP. Não é como muitas pessoas imaginam, contanto que você possa escrever rapidamente alguns códigos simples para resolver um problema complexo, você é um mestre em programação PHP. Um verdadeiro mestre em PHP também precisa considerar muitas outras questões. As três diretrizes a seguir são as que um programador PHP maduro deve primeiro seguir na programação.

1. A preguiça vale ouro

2. Escreva um código bonito

3. Busque a velocidade da programação, não a velocidade da programação

1. A preguiça vale ouro

Você é um programador preguiçoso? Essa ideia é tão estranha! Porque provavelmente as pessoas mais ocupadas do mundo são programadores de computador. Mas é precisamente porque os programadores estão muito ocupados que deveriam aprender a ser preguiçosos ao programar.

Para um programador, existem duas maneiras preguiçosas: primeiro, use com ousadia os códigos de programa prontos de outras pessoas e integre esses códigos em seus próprios programas ou projetos. A segunda é escrever alguns códigos úteis para construir uma biblioteca de funções, que pode ser facilmente usada ao escrever programas no futuro. Isso economiza muito trabalho repetitivo e, naturalmente, torna você menos preguiçoso.

Esses dois métodos preguiçosos são muito adequados para programadores PHP.

Em primeiro lugar, o PHP é uma linguagem que nasceu e cresceu num ambiente livre e aberto. Existem milhares de programadores em todo o mundo que buscam constantemente a perfeição do PHP e também estão dispostos a compartilhar sua engenhosidade e o código que escrevem com outras pessoas. Você pode encontrar muitos códigos de programa excelentes todos os dias em alguns sites PHP, listas de discussão e grupos de notícias. Ao dizer isso, não estou encorajando você a esperar o dia todo até que outros escrevam código para você, mas você pode "apoiar-se nos ombros de grandes homens" e promover totalmente a "doutrina de uso inteligente dos códigos de programa de outras pessoas". economizar muito tempo. Em segundo lugar, em PHP, você pode facilmente construir sua própria biblioteca de funções, o que pode lhe poupar muitos problemas ao escrever programas no futuro.

O autor abaixo apresenta várias funções comuns para você. Algumas dessas funções vêm de alguns projetos de código aberto na Internet e algumas são selecionadas na lista de discussão. Se você puder adicioná-los à sua própria biblioteca, mais cedo ou mais tarde você se beneficiará deles.

1. Funções gerais de processamento de banco de dados

Em comparação com outras funções CGI, uma das vantagens do PHP é que ele possui recursos de processamento de banco de dados muito poderosos. No entanto, em PHP, algumas funções específicas são usadas para lidar com diferentes bancos de dados e faltam funções gerais de processamento de banco de dados. Isso reduz bastante a portabilidade do código do programa, o que também traz muitos inconvenientes para amigos programadores iniciantes.

Na Internet, muitos programadores resolveram esse problema encapsulando classes. Eles escreveram funções unificadas para lidar com qualquer banco de dados popular - seja o Mysql, que é popular no mundo Linux, ou o SqlServer, que é amplamente popular nas plataformas Windows. Pessoalmente, gosto muito de usar essas funções, porque você pode usar diretamente algumas funções simples, como "query" e "next_record", sem ter que considerar coisas complicadas, como conexões e identificadores de banco de dados, muito menos considerar qual banco de dados você está usando .

Se precisar dessas funções, você pode obtê-las visitando os seguintes URLs:
http://phplib.netuse.de/
http://phpclasses.UpperDesign.com/browse.html/package/20
http://phpdb.linuxbox.com/
http://www.phpchina.com

2. Função de depuração variável

A depuração de programas PHP sempre foi uma dor de cabeça. Não possui um ambiente integrado de compilação e depuração como linguagens de alto nível como VB, nem possui o. capacidade de ser usado em programas PHP como Perl. Executar diretamente em ambiente Linux ou DOS. Na verdade, podemos concluir a depuração do PHP usando a instrução echo de maneira flexível.

As funções a seguir permitem verificar o tipo e o valor de qualquer variável do programa a qualquer momento.

função ss_array_as_string (&$array, $coluna = 0) {
$str = "Array(n";
while(lista($var, $val) = cada($array)){
for (＄i = 0; $i < $coluna+1; $i+＋){
$str .= "    ";
}
＄str.= ＄var. ==> ;
$str .= ss_as_string($val, $coluna+1)." n";
}
for (＄i = 0; $i < $coluna; $i＋＋){
$str .= "    ";
}
retornar $str.);
}
função ss_object_as_string (&$objeto, $coluna = 0) {
if (vazio(＄objeto－>nome da classe)) {
retornar "$objeto";
} outro {
$str = $objeto->nomedaclasse."( n";
while (lista(,$var) = cada($objeto->persistent_slots)) {
for (＄i = 0; $i < $coluna; $i＋＋){
$str .= "    ";
}
global$$var;
＄str.= ＄var. ==> ;
$str .= ss_as_string($$var, coluna+1)." n";
}
for (＄i = 0; $i < $coluna; $i＋＋){
$str .= "    ";
}
retornar $str.);
}
}
função ss_as_string (&$coisa, $coluna = 0) {
if (é_objeto($coisa)) {
return ss_object_as_string(＄coisa, ＄coluna);
}
elseif (is_array($coisa)) {
return ss_array_as_string(＄coisa, $coluna);
}
elseif (is_double(＄coisa)) {
return "Double(".$coisa.")";
}
elseif (é_long(＄coisa)) {
return "Long(".＄coisa.")";
}
elseif (is_string(＄coisa)) {
return "String(".$coisa.")";
}
outro {
return "Desconhecido(".$coisa.")";
}
}

Quando necessário, basta adicionar o seguinte código ao programa para visualizar os tipos e valores das variáveis (incluindo arrays e objetos) usadas no programa:
echo ss_as_string(＄my_variable);

Usando a seguinte instrução, podemos visualizar diretamente os valores de todas as variáveis no programa:
echo ss_as_string($GLOBALS);

3. Funções que controlam informações de Log

Outra forma importante de depurar programas PHP é visualizar informações de Log. Se você puder controlar facilmente o nível das informações do Log e o conteúdo de exibição das informações do Log, isso trará mais comodidade para a depuração do programa. As funções a seguir podem implementar facilmente esta função.

$ss_log_level = 0;
$ss_log_filename = /tmp/ss-log;
$ss_log_levels=array(
NENHUM => 0,
ERRO => 1,
INFORMAÇÕES => 2,
DEBUGAR => 3);
função ss_log_set_level ($level = ERRO) {
global$ss_log_level;
$ss_log_level = $nível;
}
função ss_log (＄nível, $mensagem) {
global $ss_log_level, $ss-log-filename;
if ($ss_log_levels[$ss_log_level] < $ss_log_levels[$level]) {
//Não exibe informações de log
retornar falso;
}
$fd = fopen($ss_log_filename, "a+");
fputs(＄fd, $nível. - [.ss_timestamp_pretty().] - .$mensagem."n");
ffechar(＄fd);
retornar verdadeiro;
}
função ss_log_reset () {
global $ss_log_filename;
@unlink($ss_log_filename);
}

Na função acima, existem quatro variáveis de nível de log. Ao executar um programa PHP, as informações de log podem ser registradas e exibidas somente quando o nível de log for inferior ao valor do nível predefinido. Por exemplo, adicione a seguinte instrução ao programa:
ss_log_set_level(INFO);

Então, ao executar um programa PHP, apenas as informações de LOG de nível ERROR e INFO podem ser registradas e exibidas, e as informações de nível DEBUG são ignoradas. Além disso, também podemos definir o conteúdo das informações exibidas com as seguintes afirmações:
ss_log(ERROR, "ERRO no nível de teste");
ss_log(INFO, "nível de teste INFO");
ss_log(DEBUG, "testing level DEBUG");

Você também pode usar a seguinte instrução para limpar as informações de LOG a qualquer momento:
ss_log_reset();

4. Função de teste de velocidade

Para otimizar o código, precisamos de um método que possa testar o tempo de execução do código para selecionar o código ideal. A função a seguir pode testar o tempo necessário para executar o código:

Agora podemos verificar facilmente o tempo de execução de qualquer trecho de código. Podemos até usar vários temporizadores ao mesmo tempo. Só precisamos definir parâmetros diferentes como o nome do temporizador ao usar as funções acima.

5. Depuração e otimização de operações de banco de dados

Para bancos de dados, a velocidade de execução é crucial. Embora muitos livros e artigos ensinem métodos para executar bancos de dados rapidamente, todos os métodos devem ser testados na prática. A seguir, combinaremos a função query() na biblioteca de funções PHPLib e as funções apresentadas acima para escrever uma nova função query(). Em comparação com a função original, esta função adiciona uma função de monitoramento de tempo de execução.

função consulta($Query_String, $halt_on_error = 1) {
$this->conectar();
ss_timing_start();
$this->Query_ID = @mysql_query($Query_String,$this->Link_ID);
ss_timing_stop();
ss_log(INFO, ss_timing_current().Secs - .$Query_String);
$this->Linha = 0;
$this->Errno =mysql_errno();
$this->Erro =mysql_error();
if (＄halt_on_error && !＄this－>Query_ID) {
$this->halt("SQL inválido: ".$Query_String);
}
return $this－>Query_ID;
}

2. Escreva um código bonito

1. Separe o programa back-end do programa front-end

Ao escrever um programa PHP, alguns códigos são usados para processar algumas transações, como operar bancos de dados, realizar operações matemáticas, etc., enquanto outros. os códigos são apenas para processamento de transações. Os resultados são exibidos, como alguns códigos PHP que usam a instrução echo para exibir os resultados em formato HTML no navegador da Web e os códigos HTML que estão diretamente incorporados no programa PHP. Em primeiro lugar, devemos distinguir claramente entre estes dois tipos de código, chamando o primeiro de programa em segundo plano e o segundo de programa front-end.

Como o PHP é uma linguagem de programação incorporada, ou seja, todo o código PHP pode ser incorporado no código HTML, o que traz muitas conveniências para a escrita de programas. Porém, se as coisas chegarem a extremos, elas deverão ser revertidas. Se você misturar código PHP e código HTML em um programa longo, isso tornará o programa confuso e desfavorável para a manutenção e leitura do programa. Portanto, precisamos transplantar o máximo possível o código PHP misturado ao código HTML nesses programas, encapsular esses códigos em funções em arquivos especiais e, em seguida, usar a instrução include no código HTML para incluir esses arquivos no local apropriado. Basta chamar essas funções.

Por um lado, esta abordagem torna o código HTML e o código PHP simples e fáceis de ler. Por outro lado, como o código HTML precisa ser constantemente atualizado, este método de separação pode garantir que o programa em segundo plano não será destruído. .
Ao contrário dos programas front-end, os programas back-end buscam estabilidade, estrutura e raramente mudam, por isso devem ser cuidadosamente projetados e gerenciados. Na verdade, vale a pena investir muito tempo ao projetar programas de desktop. "Plante árvores agora e aproveite a sombra mais tarde."

2. Uso flexível de arquivos de inclusão

Como mencionado anteriormente, os programas em segundo plano devem ser organizados em uma série de arquivos de inclusão. Os arquivos incluídos podem ser carregados dinamicamente quando necessário por meio da instrução include ou podem ser carregados automaticamente com antecedência usando a diretiva auto_prepend_file no arquivo php.ini.
Se você usar o último método, embora obtenha os benefícios de uma vez por todas, também existem algumas deficiências que merecem nossa atenção. O trecho de código a seguir nos mostra quanto tempo leva para analisar um arquivo de inclusão grande:

require(timing.inc);
ss_timing_start();
incluir(teste.inc);
ss_timing_stop();
eco
.ss_timing_current().
?>

No código acima, test.inc é um arquivo de inclusão de 1000 linhas. Os resultados da execução mostram que leva 0,6 segundos para analisar esse arquivo de inclusão. Para um site grande, essa velocidade não é insignificante.

Outra desvantagem de usar arquivos include é que se ocorrer um erro em uma instrução de um arquivo, o programa PHP de todo o site não poderá ser executado. Portanto, use-o com muito cuidado.

Na verdade, com um pouco de processamento do arquivo de inclusão, o arquivo de inclusão só poderá ser analisado quando necessário. O código a seguir faz com que o arquivo abc.inc seja analisado somente quando o programa precisar dele:

if (definido(__LIBA_INC)) return;
define(__LIBA_INC, 1);
/*
* Código...
*/
?>

3. Use o método de programação orientado a objetos

PHP também é uma linguagem orientada a objetos O método de programação orientado a objetos é um método de design de software altamente respeitado por excelentes programadores. Na programação PHP, as vantagens da linguagem orientada a objetos podem ser totalmente utilizadas. . A vantagem é encapsular objetos na programação. No código anterior, usamos um método orientado a objetos. Por exemplo, ao gerenciar o banco de dados, encapsulamos a função query() na classe do banco de dados, o que facilitou muito o gerenciamento do código e aumentou a legibilidade do programa.

3. Buscar a velocidade do programa em vez da velocidade de programação

Na construção de sites, a velocidade de execução do programa e a velocidade de download da página da web são fatores importantes que determinam o sucesso ou o fracasso. Como programador web, você deve prestar mais atenção à velocidade de execução do seu código. Vários métodos apresentados abaixo melhoram a velocidade de execução do código em vários graus.

1. Use código HTML incorporado em vez da instrução echo do PHP.

Como o PHP é uma linguagem de programação da Web incorporada, o código HTML e o código PHP podem ser incorporados um no outro. No entanto, muitos programadores temem que o uso excessivo de "" para incorporar código PHP no código HTML chame o interpretador PHP várias vezes, reduzindo assim a velocidade de execução do código PHP. Portanto, eles preferem usar a instrução echo do PHP para gerar o código HTML em vez de. diretamente Use o código HTML. Mas a verdade é exatamente o oposto. Cada página PHP chama o interpretador PHP apenas uma vez para interpretar todos os códigos PHP. Portanto, incorporar códigos PHP apenas quando necessário e, na maioria das vezes, usar códigos HTML diretamente para inserir os resultados, não apenas reduzirá a velocidade de execução do programa, mas também não reduzirá a velocidade de execução do programa. Além disso, como a análise das instruções echo é reduzida, a velocidade de execução do código pode frequentemente ser melhorada.

O trecho de código a seguir demonstra nossa conclusão. Neste código, usamos a função de teste de tempo introduzida anteriormente.

Use str-replace em vez de ereg-replace
Os programadores que estão acostumados a programar em Perl estão mais dispostos a usar ereg_replace para concluir o trabalho de substituição de string, porque o uso de ereg_replace em PHP é semelhante ao uso de correspondência de padrões em Perl. No entanto, o código a seguir prova que usar str_replace em vez de ereg_replace melhorará bastante a velocidade de execução do código.

Teste a velocidade de execução de str_replace e ereg_replace

//Este código testa a velocidade de execução de str_replace
ênfase ?>
para (＄i=0; ＄i<1000; ＄i＋＋) {
str_replace(i>, b>, $string).
}
?>

//Este código testa a velocidade de execução de ereg_replace
para (＄i=0; ＄i<1000; ＄i＋＋) {
ereg_replace(<([/]＊)i>, <1b>, $string).
}
?>
//Imprime

a conclusão

do resultado

usando str_replace time -
Hora de usar ereg_pattern -

executando o código acima, o resultado é:

hora de usar str_replace - 0,089757
É hora de usar ereg_pattern - 0.248881

A partir dos resultados da execução, podemos ver que usar str_replace em vez de ereg_replace como a função de substituição de string melhora muito a velocidade de execução do código.

3. Preste atenção às citações de strings.

PHP, como muitas outras linguagens de programação, pode usar aspas duplas ("") para citar strings ou aspas simples (). Mas em PHP, se você usar aspas duplas para citar uma string, o analisador PHP irá primeiro analisar se há uma referência a uma variável na string. Se houver uma variável, ele substituirá a variável. Se forem aspas simples, não é tão complicado - todas as strings entre aspas simples são exibidas diretamente. Obviamente, na programação PHP, é mais rápido usar aspas simples para citar variáveis de string do que aspas duplas.

4. Evite usar operações conjuntas no banco de dados

Em comparação com outras linguagens de programação da Web, a função de banco de dados do PHP é muito poderosa. No entanto, executar o banco de dados em PHP ainda é uma questão muito demorada e trabalhosa. Portanto, como programador da Web, você deve minimizar as operações de consulta ao banco de dados e estabelecer índices apropriados para o banco de dados. Outra coisa que vale a pena notar é que ao usar PHP para operar um banco de dados, tente não usar operações conjuntas de múltiplas tabelas de dados. Embora as operações conjuntas possam melhorar a função de consulta do banco de dados, elas aumentam muito a carga do servidor.

Para ilustrar esse problema, podemos observar o exemplo simples abaixo.

Criamos duas tabelas de dados foo e big_foo no banco de dados. Na tabela de dados foo, existe apenas um campo, que contém todos os números naturais de 1 a 1000. A tabela de dados big_foo também possui apenas um campo, mas contém todos os números naturais de 1 a 1.000.000. Portanto, em termos de tamanho, big_foo é igual a foo combinado consigo mesmo.

$db->query("selecione * de foo");
0,032273 segundos
$db->next_record();
0,00048999999999999 segundos
$db->query("inserir em valores foo (NULL)");
0,019506 segundos
$db->query("selecione * de foo como a, foo como b");
17,280596 segundos
$db－>query("select ＊ from foo como a, foo como b onde a.id > b.id");
14,645251 segundos
$db－>query("select ＊ from foo como a, foo como b onde a.id = b.id");
0,041269 segundos
$db－>query("selecione * de big_foo");
25,393672 segundos

A partir dos resultados da operação acima, podemos descobrir que a velocidade de união de duas tabelas de dados com 1.000 registros não é muito mais rápida do que a operação separada de uma grande tabela de dados com 1.000.000 de registros.

5. Preste atenção à diferença entre include e require.

Na programação PHP, include() e require() têm as mesmas funções, mas há algumas diferenças no uso. include() é uma função de inclusão condicional, enquanto require() é. um incondicional Contém funções. Por exemplo, no exemplo a seguir, se a variável $somgthing for verdadeira, o arquivo somefile será incluído:

if($something){
include("algum arquivo");
}

Mas não importa o valor que $something assuma, o código a seguir incluirá o arquivo somefile no arquivo:

if($something){
require("algum arquivo");
}

O exemplo interessante a seguir ilustra a diferença entre essas duas funções.

$i = 1;
enquanto (＄i < 3) {
require("algumarquivo.$i");
$eu++;
}

Neste código, o programa incluirá o mesmo arquivo sempre que fizer um loop. Obviamente esta não é a intenção original do programador. Pelo código podemos ver que este código espera incluir arquivos diferentes em cada loop. Se você quiser completar esta função, você deve recorrer à função include():

$i = 1;
enquanto (＄i < 3) {
include("algumarquivo.＄i");
$eu++;
}

6. Preste atenção na diferença entre echo e print

As funções de echo e print no PHP são basicamente as mesmas, mas existem diferenças sutis entre os dois. Você pode usar print como uma função comum no código PHP. Por exemplo, após executar o código a seguir, o valor da variável $res será 1.
$ret = print "Hello World";

Isso significa que print pode ser usado em algumas expressões complexas, mas echo não. Da mesma forma, a instrução echo é executada um pouco mais rápido do que a instrução print no código porque a instrução echo não exige que nenhum valor seja retornado.