Recursos ocultos do PHP? [fechadas]

Eu sei que isso soa como uma pergunta de merda, mas deixe-me explicar de onde venho.

Fora da faculdade, consegui um emprego em uma loja de PHP. Eu trabalhei lá por um ano e meio e pensei que tinha aprendido tudo o que havia para aprender sobre programação.

Então, consegui um emprego como uma loja de desenvolvimento interno individual em uma empresa considerável, onde todo o trabalho era em C #. No meu compromisso com a posição, comecei a ler uma tonelada de blogs e livros e rapidamente percebi o quanto eu estava errada ao pensar que sabia tudo. Aprendi sobre testes de unidade, injeção de dependência e padrões de decorador, o princípio de design de acoplamentos soltos, a composição sobre o debate sobre herança e assim por diante - e continuo absorvendo tudo isso. Escusado será dizer que meu estilo de programação mudou completamente no ano passado.

Agora eu me pego pegando um projeto php fazendo alguma codificação para a inicialização de um amigo e me sinto completamente constrangido em oposição à programação em C #. Realmente me incomoda que todas as variáveis ​​em um escopo de classe devam ser referidas anexando '$ this->'. Me incomoda que nenhum dos IDEs que eu tentei tenha muito bom senso e que meus métodos de teste de unidade SimpleTest tenham que começar com a palavra 'test'. Isso me deixa louco porque a digitação dinâmica me impede de especificar implicitamente qual tipo de parâmetro um método espera, e que você precisa escrever uma instrução switch para sobrecarregar o método. Não suporto que você não possa ter namespaces aninhados e precise usar o operador :: para chamar o construtor da classe base.

Agora, não tenho intenção de iniciar um debate entre PHP e C #, mas o que quero dizer é que tenho certeza de que existem alguns recursos do PHP que eu não conheço ou que ainda não consigo usar corretamente. Estou no meu universo C # e estou tendo problemas para enxergar fora da tigela de vidro.

Então, eu estou perguntando, quais são seus recursos favoritos do PHP? Quais são as coisas que você pode fazer e não pode ou é mais difícil nos idiomas .Net?

Documentação . A documentação recebe meu voto. Não encontrei uma documentação on-line mais completa para uma linguagem de programação - tudo o que tenho para reunir em vários sites e páginas de manual.

Matrizes . A julgar pelas respostas a esta pergunta, acho que as pessoas não apreciam completamente o quão fácil e útil são as matrizes em PHP. Matrizes PHP agem como listas, mapas, pilhas e estruturas de dados genéricas, tudo ao mesmo tempo. As matrizes são implementadas no núcleo do idioma e são usadas em todo o lugar, o que resulta em boa localidade do cache da CPU. O Perl e o Python usam construções de linguagem separadas para listas e mapas, resultando em mais cópias e transformações potencialmente confusas.

Os manipuladores de fluxo permitem que você estenda o "Sistema de arquivos" com uma lógica que, até onde eu sei, é bastante difícil de fazer na maioria dos outros idiomas.

Por exemplo, com o manipulador de fluxo do MS-Excel, você pode criar um arquivo do MS Excel da seguinte maneira:

$fp = fopen("xlsfile://tmp/test.xls", "wb");
if (!is_resource($fp)) { 
    die("Cannot open excel file");
}

$data= array(
    array("Name" => "Bob Loblaw", "Age" => 50),  
    array("Name" => "Popo Jijo", "Age" => 75),  
    array("Name" => "Tiny Tim", "Age" => 90)
); 

fwrite($fp, serialize($data));
fclose($fp);

Métodos mágicos são métodos de passagem que são chamados sempre que você invoca um método que não existe, atribui ou lê uma propriedade que não existe, entre outras coisas.

interface AllMagicMethods {
    // accessing undefined or invisible (e.g. private) properties
    public function __get($fieldName);
    public function __set($fieldName, $value);
    public function __isset($fieldName);
    public function __unset($fieldName);

    // calling undefined or invisible (e.g. private) methods
    public function __call($funcName, $args);
    public static function __callStatic($funcName, $args); // as of PHP 5.3

    // on serialize() / unserialize()
    public function __sleep();
    public function __wakeup();

    // conversion to string (e.g. with (string) $obj, echo $obj, strlen($obj), ...)
    public function __toString();

    // calling the object like a function (e.g. $obj($arg, $arg2))
    public function __invoke($arguments, $...);

    // called on var_export()
    public static function __set_state($array);
}

Um desenvolvedor de C ++ aqui pode notar que o PHP permite sobrecarregar alguns operadores, por exemplo, ()ou (string). Na verdade, o PHP permite sobrecarregar ainda mais, por exemplo, o []operador ( ArrayAccess ), a foreachconstrução da linguagem ( Iterator e IteratorAggregate ) e a countfunção ( Countable ).

A classe padrão é um contêiner limpo. Eu só aprendi sobre isso recentemente.

Em vez de usar uma matriz para armazenar atributos do servidor

$person = array();
$person['name'] = 'bob';
$person['age'] = 5;

Você pode usar uma classe padrão

$person = new stdClass();
$person->name = 'bob';
$person->age = 5;

Isso é particularmente útil ao acessar essas variáveis ​​em uma string

$string = $person['name'] . ' is ' . $person['age'] . ' years old.';
// vs
$string = "$person->name is $person->age years old.";

Os arquivos de inclusão podem ter um valor de retorno que você pode atribuir a uma variável.

// config.php
return array(
    'db' => array(
        'host' => 'example.org',
        'user' => 'usr',
        // ...
    ),
    // ...
);

// index.php
$config = include 'config.php';
echo $config['db']['host']; // example.org

Você pode tirar vantagem do fato de o oroperador ter precedência menor do =que fazer isso:

$page = (int) @$_GET['page'] 
  or $page = 1;

Se o valor da primeira atribuição for avaliado true, a segunda atribuição será ignorada. Outro exemplo:

$record = get_record($id) 
  or throw new Exception("...");

__autoload()arquivos (de classe) auxiliados por set_include_path().

Agora, no PHP5, é desnecessário especificar longas listas de instruções "include_once" ao fazer OOP decente.

Basta definir um pequeno conjunto de diretórios no qual os arquivos da biblioteca de classes são estruturados de maneira adequada e defina o caminho de inclusão automática:

set_include_path(get_include_path() . PATH_SEPARATOR . '../libs/');`

Agora a __autoload()rotina:

function __autoload($classname) {
    // every class is stored in a file "libs/classname.class.php"

    // note: temporary alter error_reporting to prevent WARNINGS
    // Do not suppress errors with a @ - syntax errors will fail silently!

    include_once($classname . '.class.php');
}

Agora, o PHP incluirá automaticamente os arquivos necessários sob demanda, economizando tempo e memória de análise.

Facilidade . O maior recurso é como é fácil para os novos desenvolvedores sentar e escrever scripts "trabalhando" e entender o código.

O pior recurso é como é fácil para os novos desenvolvedores sentar e escrever scripts "trabalhando" e achar que eles entendem o código.

A abertura da comunidade em torno do PHP e a enorme quantidade de projetos PHP disponíveis como código aberto são muito menos intimidantes para quem entra no mundo do desenvolvimento e, como você, pode ser um trampolim para linguagens mais maduras.

Não discutirei as coisas técnicas que muitos antes de mim têm, mas se você considerar o PHP como uma comunidade e não como uma linguagem da web, uma comunidade que claramente o abraçou quando você começou a desenvolver, os benefícios realmente falam por si.

Variáveis ​​e funções variáveis, sem dúvida!

$foo = 'bar';
$bar = 'foobar';
echo $$foo;    //This outputs foobar

function bar() {
    echo 'Hello world!';
}

function foobar() {
    echo 'What a wonderful world!';
}
$foo();    //This outputs Hello world!
$$foo();    //This outputs What a wonderful world!

O mesmo conceito se aplica aos parâmetros do objeto ($ some_object -> $ some_variable);

Muito muito bom. Crie códigos com loops e padrões muito fáceis, e é mais rápido e mais controlado do que o eval (Thanx @Ross & @Joshi Spawnbrood!). T

Você pode usar funções com um número indefinido de argumentos usando o func_get_args().

<?php

function test() {

    $args = func_get_args();
    echo $args[2]; // will print 'd'
    echo $args[1]; // will print 3
}

test(1,3,'d',4);

?>

Eu amo arquivos remotos . Para o desenvolvimento da web, esse tipo de recurso é excepcionalmente útil.

Precisa trabalhar com o conteúdo de uma página da web? Um simples

$fp = fopen('http://example.com');

e você já tem um identificador de arquivo pronto, como qualquer outro arquivo normal.

Ou que tal ler um arquivo ou página da Web remota diretamente em uma string?

$str = file_get_contents('http://example.com/file');

A utilidade desse método em particular é difícil de exagerar.

Deseja analisar uma imagem remota? Que tal fazê-lo via FTP?

$imageInfo = getimagesize('ftp://user:password@ftp.example.com/image/name.jpg');

Quase todas as funções PHP que funcionam com arquivos podem funcionar com um arquivo remoto. Você pode igualar include()ou require()codificar arquivos remotamente dessa maneira.

strtr ()

É extremamente rápido, tanto que você ficaria surpreso. Internamente, provavelmente usa alguma estrutura maluca do tipo b-tree para organizar suas correspondências pelos prefixos comuns. Eu o uso com mais de 200 localizações e substituições de strings e ele ainda passa por 1 MB em menos de 100ms. Apesar de todas as seqüências trivialmente pequenas, strtr () é significativamente mais rápido que strtolower () ao fazer exatamente a mesma coisa, mesmo levando em consideração o conjunto de caracteres. Você provavelmente poderia escrever um analisador inteiro usando chamadas strtr sucessivas e seria mais rápido que a correspondência de expressão regular usual, descobrir o tipo de token, produzir isso ou aquilo, o próximo tipo de expressão regular.

Eu estava escrevendo um normalizador de texto para dividir o texto em palavras, com letras minúsculas, remover pontuação etc.

Um recurso não tão conhecido do PHP é extract()uma função que descompacta uma matriz associativa no espaço de nomes local. Provavelmente isso existe para o aborto autoglobal, mas é muito útil para modelar:

function render_template($template_name, $context, $as_string=false)
{
    extract($context);
    if ($as_string)
        ob_start();
    include TEMPLATE_DIR . '/' . $template_name;
    if ($as_string)
        return ob_get_clean();
}

Agora você pode usar render_template('index.html', array('foo' => 'bar'))e somente $foocom o valor "bar"aparece no modelo.

Range () não está oculto por si só, mas ainda vejo muitas pessoas interagindo com:

for ($i=0; $i < $x; $i++) { 
    // code...
}

quando eles poderiam estar usando:

foreach (range(0, 12) as $number) {
    // ...
}

E você pode fazer coisas simples como

foreach (range(date("Y"), date("Y")+20) as $i)
{
print "\t<option value=\"{$i}\">{$i}</option>\n";
}

O espaço na web habilitado para PHP geralmente é mais barato do que algo com (asp) .net. Você pode chamar isso de recurso ;-)

A staticpalavra-chave é útil fora do ponto de vista do OOP. É possível implementar rápida e facilmente 'memorização' ou cache de funções com algo tão simples como:

<?php
function foo($arg1)
{
    static $cache;

    if( !isset($cache[md5($arg1)]) )
    {
        // Do the work here
        $cache[md5($arg1)] = $results;
    }

    return $cache[md5($arg1)];
}
?>

A staticpalavra-chave cria uma variável que persiste apenas dentro do escopo dessa função após a execução. Essa técnica é ótima para funções que atingem o banco de dados como get_all_books_by_id(...)ou get_all_categories(...)que você chamaria mais de uma vez durante o carregamento da página.

Advertência: Certifique-se de encontrar a melhor maneira de criar uma chave para o seu hash, em quase todas as circunstâncias md5(...)acima não é uma boa decisão (problemas de velocidade e comprimento de saída), usei-a para fins ilustrativos. sprintf('%u', crc32(...))ou spl_object_hash(...)pode ser muito melhor dependendo do contexto.

Um recurso interessante do PHP é a CLI . Não é tão "promovido" na documentação, mas se você precisar de scripts de rotina / aplicativos de console, o uso do cron + php cli é muito rápido de desenvolver!

Então, "e imprima" o truque

<?php $flag and print "Blah" ?>

Ecoará Blah se $ flag for verdadeiro. NÃO FUNCIONA COM ECO.

Isso é muito útil no modelo e substitui o? : que não são realmente fáceis de ler.

Você pode usar caracteres negativos em nomes de variáveis como este:

class style
{
  ....
  function set_bg_colour($c)
  {
    $this->{'background-color'} = $c;
  }
}

Por que usar isso? Não faço ideia: talvez para um modelo CSS? Ou algum JSON estranho que você precisa produzir. É uma característica estranha :)

A sintaxe HEREDOC é o meu recurso oculto favorito. Sempre difícil de encontrar, pois você não pode procurar no Google <<<, mas impede que você escape grandes pedaços de HTML e ainda permite que você solte variáveis ​​no fluxo.

echo <<<EOM
  <div id="someblock">
    <img src="{$file}" />
  </div>
EOM;

Provavelmente muitos não sabem que é possível especificar constantes "variáveis" como valores padrão para parâmetros de função:

function myFunc($param1, $param2 = MY_CONST)
{
//code...
}

Strings podem ser usadas como se fossem matrizes :

$str = 'hell o World';
echo $str; //outputs: "hell o World"

$str[0] = 'H';
echo $str; //outputs: "Hell o World"

$str[4] = null;
echo $str; //outputs: "Hello World"

A coisa mais útil sobre o código PHP é que, se eu não entender uma função, vejo que posso procurar usando um navegador e digitando:

http://php.net/function

No mês passado, vi a função "range" em algum código. É uma das centenas de funções que eu nunca consegui usar, mas que são realmente úteis:

http://php.net/range

Esse URL é um alias para http://us2.php.net/manual/en/function.range.php . Essa ideia simples, de mapear funções e palavras-chave para URLs , é incrível.

Desejo que outras linguagens, estruturas, bancos de dados, sistemas operacionais tenham um mecanismo tão simples para procurar a documentação.

Comentários de bloqueio rápido

/*
    die('You shall not pass!');
//*/


//*
    die('You shall not pass!');
//*/

Esses comentários permitem alternar se um bloco de código for comentado com um caractere.

Minha lista .. a maioria deles se encaixa mais nos "recursos ocultos" do que nos "recursos favoritos" (espero!), E nem todos são úteis, mas ... sim.

// swap values. any number of vars works, obviously  
list($a, $b) = array($b, $a);

// nested list() calls "fill" variables from multidim arrays:  
$arr = array(  
  array('aaaa', 'bbb'),  
  array('cc', 'd')  
);  
list(list($a, $b), list($c, $d)) = $arr;  
echo "$a $b $c $d"; // -> aaaa bbb cc d  

// list() values to arrays  
while (list($arr1[], $arr2[], $arr3[]) = mysql_fetch_row($res)) { .. }  
// or get columns from a matrix  
foreach($data as $row) list($col_1[], $col_2[], $col_3[]) = $row;

// abusing the ternary operator to set other variables as a side effect:  
$foo = $condition ? 'Yes' . (($bar = 'right') && false) : 'No' . (($bar = 'left') && false);  
// boolean False cast to string for concatenation becomes an empty string ''.  
// you can also use list() but that's so boring ;-)  
list($foo, $bar) = $condition ? array('Yes', 'right') : array('No', 'left');

Você também pode aninhar operadores ternários, às vezes é útil.

// the strings' "Complex syntax" allows for *weird* stuff.  
// given $i = 3, if $custom is true, set $foo to $P['size3'], else to $C['size3']:  
$foo = ${$custom?'P':'C'}['size'.$i];  
$foo = $custom?$P['size'.$i]:$C['size'.$i]; // does the same, but it's too long ;-)  
// similarly, splitting an array $all_rows into two arrays $data0 and $data1 based  
// on some field 'active' in the sub-arrays:  
foreach ($all_rows as $row) ${'data'.($row['active']?1:0)}[] = $row;

// slight adaption from another answer here, I had to try out what else you could  
// abuse as variable names.. turns out, way too much...  
$string = 'f.> <!-? o+';  
${$string} = 'asdfasf';  
echo ${$string}; // -> 'asdfasf'  
echo $GLOBALS['f.> <!-? o+']; // -> 'asdfasf'  
// (don't do this. srsly.)

${''} = 456;  
echo ${''}; // -> 456  
echo $GLOBALS['']; // -> 456  
// I have no idea.  

Certo, vou parar por agora :-)

Hmm, já faz um tempo ..

// just discovered you can comment the hell out of php:
$q/* snarf */=/* quux */$_GET/* foo */[/* bar */'q'/* bazz */]/* yadda */;

Assim, acabamos de descobrir que você pode passar qualquer string como um nome de método, se você a incluir entre colchetes. Você não pode definir nenhuma string como um método, mas pode capturá-las com __call () e processá-las ainda mais, conforme necessário. Hummm ....

class foo {
  function __call($func, $args) {
    eval ($func);
  }
}

$x = new foo;
$x->{'foreach(range(1, 10) as $i) {echo $i."\n";}'}();

Encontrei esta pequena jóia nos comentários do Reddit:

$foo = 'abcde';
$strlen = 'strlen';
echo "$foo is {$strlen($foo)} characters long."; // "abcde is 5 characters long."

Você não pode chamar funções dentro de {} diretamente assim, mas pode usar variáveis-holding-the-function-name e chamá-las! (* e * você também pode usar variáveis ​​variáveis)

Manipulação de matriz.
Toneladas de ferramentas para trabalhar e manipular matrizes. Pode não ser exclusivo do PHP, mas nunca trabalhei com uma linguagem que facilitasse as coisas.

Sou um pouco como você, codigo PHP há mais de 8 anos. Eu tive que fazer um curso .NET / C # há um ano e gostei muito da linguagem C # (odiava o ASP.NET), mas isso me tornou um desenvolvedor PHP melhor.

O PHP como linguagem é muito ruim, mas sou extremamente rápido com ele e a pilha LAMP é incrível. O produto final supera em muito a soma das peças.

Dito isto, em resposta à sua pergunta:

http://uk.php.net/SPL

Eu amo o SPL , a classe de coleção em C # era algo que eu gostei assim que comecei. Agora eu posso comer meu bolo e comê-lo.

Andrew

Estou um pouco surpreso que ninguém tenha mencionado isso ainda, mas um dos meus truques favoritos com matrizes é usar o operador plus. É um pouco como, array_merge()mas um pouco mais simples. Eu descobri que geralmente é o que eu quero. Com efeito, ele pega todas as entradas no RHS e as faz aparecer em uma cópia do LHS, sobrescrevendo conforme necessário (ou seja, não é comutativo). Muito útil para iniciar com uma matriz "padrão" e adicionar alguns valores reais em uma ocorrência, deixando valores padrão no lugar para valores não fornecidos.

Exemplo de código solicitado:

// Set the normal defaults.
$control_defaults = array( 'type' => 'text', 'size' => 30 );

// ... many lines later ...

$control_5 = $control_defaults + array( 'name' => 'surname', 'size' => 40 );
// This is the same as:
// $control_5 = array( 'type' => 'text', 'name' => 'surname', 'size' => 40 );

Aqui está um, eu gosto de como definir valores padrão em parâmetros de função que não são fornecidos é muito mais fácil:

function MyMethod($VarICareAbout, $VarIDontCareAbout = 'yippie') { }

Rápido e sujo é o padrão.
A linguagem é preenchida com atalhos úteis. Isso faz do PHP o candidato perfeito para projetos (pequenos) que têm um curto tempo de lançamento no mercado. Não que o código PHP limpo seja impossível, é preciso apenas algum esforço e experiência extras.

Mas eu amo PHP porque me permite expressar o que quero sem digitar um ensaio.

PHP:

if (preg_match("/cat/","one cat")) {
   // do something
}

JAVA:

import java.util.regex.*;
Pattern p = Pattern.compile("cat");
Matcher m = p.matcher("one cat")
if (m.find()) {
  // do something
}

E sim, isso inclui não digitar Int .