Caratteristiche nascoste di PHP? [chiuso]

So che sembra una domanda pungente, ma lasciami spiegare da dove vengo.

Fuori dal college ho trovato lavoro in un negozio PHP. Ho lavorato lì per un anno e mezzo e ho pensato di aver imparato tutto ciò che c'era da sapere sulla programmazione.

Poi ho ottenuto un lavoro come negozio di sviluppo interno individuale presso una grande azienda in cui tutto il lavoro era in C #. Nel mio impegno per la posizione ho iniziato a leggere un sacco di blog e libri e ho subito capito quanto mi sbagliavo a pensare di sapere tutto. Ho imparato a conoscere i test unitari, l'iniezione delle dipendenze e i motivi del decoratore, il principio di progettazione dell'accoppiamento libero, la composizione sul dibattito sull'ereditarietà e così via e così via - Sto ancora assorbendo moltissimo tutto. Inutile dire che il mio stile di programmazione è cambiato completamente nell'ultimo anno.

Ora mi ritrovo a raccogliere un progetto php facendo un po 'di codice per lo start-up di un amico e mi sento completamente limitato rispetto alla programmazione in C #. Mi disturba davvero il fatto che tutte le variabili nell'ambito di una classe debbano essere citate aggiungendo '$ this->'. Mi dà fastidio che nessuno degli IDE che ho provato abbia un ottimo intellisense e che i miei metodi di test unitari SimpleTest debbano iniziare con la parola "test". Mi fa impazzire il fatto che la digitazione dinamica mi impedisca di specificare implicitamente quale tipo di parametro si aspetta un metodo e che devi scrivere un'istruzione switch per fare sovraccarichi di metodo. Non sopporto che non puoi avere spazi dei nomi nidificati e che devi usare l'operatore :: per chiamare il costruttore della classe base.

Ora non ho intenzione di iniziare un dibattito tra PHP e C #, ma quello che intendo dire è che sono sicuro che ci sono alcune funzionalità di PHP che non conosco o che conosco ma che non riesco a usare correttamente. Sono ambientato nel mio universo C # e ho problemi a vedere fuori dalla ciotola di vetro.

Quindi ti sto chiedendo, quali sono le tue funzionalità preferite di PHP? Quali sono le cose che puoi fare in esso che non puoi o sono più difficili nelle lingue .Net?

Documentazione . La documentazione ottiene il mio voto. Non ho trovato una documentazione online più approfondita per un linguaggio di programmazione - tutto il resto che devo mettere insieme da vari siti Web e pagine man.

Array . A giudicare dalle risposte a questa domanda, non credo che le persone apprezzino appieno quanto siano semplici e utili gli array in PHP. Gli array PHP fungono contemporaneamente da elenchi, mappe, stack e strutture di dati generici. Le matrici sono implementate nel core della lingua e sono utilizzate ovunque, il che si traduce in una buona posizione della cache della CPU. Perl e Python usano entrambi costrutti di linguaggio separati per elenchi e mappe, risultando in più copie e trasformazioni potenzialmente confuse.

I gestori di stream ti consentono di estendere il "FileSystem" con una logica che, per quanto ne so, è abbastanza difficile da fare nella maggior parte delle altre lingue.

Ad esempio con il gestore di flussi MS-Excel è possibile creare un file MS Excel nel modo seguente:

$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);

I metodi magici sono metodi fall-through che vengono chiamati ogni volta che invochi un metodo che non esiste o assegni o leggi una proprietà che non esiste, tra le altre cose.

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);
}

A C ++ sviluppatore qui potrebbe notare, che PHP permette di sovraccaricare alcuni operatori, ad esempio, ()o (string). In realtà PHP consente di sovraccaricare ancora di più, ad esempio l' []operatore ( ArrayAccess ), il foreachcostrutto del linguaggio ( Iterator e IteratorAggregate ) e la countfunzione ( numerabile ).

La classe standard è un contenitore pulito. L'ho imparato solo di recente.

Invece di utilizzare un array per contenere gli attributi server

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

Puoi usare una classe standard

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

Ciò è particolarmente utile quando si accede a queste variabili in una stringa

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

I file di inclusione possono avere un valore di ritorno che è possibile assegnare a una variabile.

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

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

Puoi trarre vantaggio dal fatto che l' oroperatore ha una precedenza inferiore rispetto =a fare questo:

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

Se il valore della prima assegnazione corrisponde a true, la seconda assegnazione viene ignorata. Un altro esempio:

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

__autoload()(class-) file aiutati da set_include_path().

In PHP5 non è ora necessario specificare lunghi elenchi di istruzioni "include_once" quando si esegue OOP decente.

Basta definire un piccolo set di directory in cui i file della libreria di classi sono strutturati in modo sano e impostare il percorso di inclusione automatica:

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

Ora la __autoload()routine:

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');
}

Ora PHP includerà automagicamente i file necessari su richiesta, risparmiando tempo e memoria di analisi.

Facilità . La più grande caratteristica è quanto sia facile per i nuovi sviluppatori sedersi e scrivere script "funzionanti" e comprendere il codice.

La caratteristica peggiore è quanto sia facile per i nuovi sviluppatori sedersi e scrivere script "funzionanti" e pensare di capire il codice.

L' apertura della comunità che circonda PHP e l'enorme quantità di progetti PHP disponibili come open source sono molto meno intimidatori per chi entra nel mondo dello sviluppo e come te, può essere un trampolino di lancio verso lingue più mature.

Non discuterò delle cose tecniche come molti prima di me, ma se guardi a PHP come a una comunità piuttosto che a un linguaggio web, una comunità che ti ha abbracciato chiaramente quando hai iniziato a sviluppare, i vantaggi parlano davvero da soli.

Variabili e funzioni variabili senza dubbio!

$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!

Lo stesso concetto si applica ai parametri degli oggetti ($ some_object -> $ some_variable);

Molto molto carino. Rendere la codifica con loop e pattern molto semplici ed è più veloce e più sotto controllo di eval (Thanx @Ross & @Joshi Spawnbrood!).

È possibile utilizzare le funzioni con un numero indefinito di argomenti utilizzando il 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);

?>

Adoro i file remoti . Per lo sviluppo Web, questo tipo di funzionalità è estremamente utile.

Devi lavorare con i contenuti di una pagina web? Un semplice

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

e hai un handle di file pronto all'uso, proprio come qualsiasi altro file normale.

O che ne dite di leggere un file remoto o una pagina Web direttamente in una stringa?

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

L'utilità di questo particolare metodo è difficile da sopravvalutare.

Vuoi analizzare un'immagine remota? Che ne dici di farlo tramite FTP?

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

Quasi tutte le funzioni PHP che funzionano con i file possono funzionare con un file remoto. Puoi anche include()o require()codificare i file in remoto in questo modo.

strtr ()

È estremamente veloce, così tanto che rimarrai stupito. Internamente probabilmente usa una struttura pazza di tipo b-tree per organizzare le partite in base ai loro prefissi comuni. Lo uso con oltre 200 trovare e sostituire stringhe e passa ancora attraverso 1 MB in meno di 100 ms. Per tutte le stringhe, ma banalmente piccole, strtr () è anche significativamente più veloce di strtolower () nel fare esattamente la stessa cosa, anche tenendo conto del set di caratteri. Probabilmente potresti scrivere un intero parser usando successive chiamate strtr e sarebbe più veloce della solita corrispondenza di espressioni regolari, capire il tipo di token, produrre questo o quello, il prossimo tipo di espressione regolare.

Stavo scrivendo un normalizzatore di testo per dividere il testo in parole, minuscole, rimuovere punteggiatura ecc. E strtr era il mio coltellino svizzero, ha battuto i pantaloni dalle espressioni regolari o addirittura str_replace ().

Una caratteristica non molto nota di PHP è extract(), una funzione che decomprime un array associativo nello spazio dei nomi locale. Questo probabilmente esiste per l'aborminazione autoglobale ma è molto utile per il templating:

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();
}

Ora puoi usare render_template('index.html', array('foo' => 'bar'))e solo $foocon il valore "bar"appare nel modello.

Range () non è nascosto di per sé, ma vedo ancora molte persone che ripetono:

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

quando potrebbero usare:

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

E puoi fare cose semplici come

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

Lo spazio Web abilitato per PHP è generalmente meno costoso di qualcosa con (asp) .net. Si potrebbe chiamare che una caratteristica ;-)

La staticparola chiave è utile al di fuori di un punto di vista OOP. È possibile implementare in modo semplice e veloce la 'memoization' o la memorizzazione delle funzioni nella cache con qualcosa di semplice come:

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

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

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

La staticparola chiave crea una variabile che persiste solo nell'ambito di quella funzione oltre l'esecuzione. Questa tecnica è ottima per le funzioni che colpiscono il database come get_all_books_by_id(...)o get_all_categories(...)che chiameresti più di una volta durante il caricamento della pagina.

Avvertenza: assicurati di trovare il modo migliore per creare una chiave per il tuo hash, in quasi tutte le circostanze quanto md5(...)sopra NON è una buona decisione (problemi di velocità e lunghezza di output), l'ho usato a scopo illustrativo. sprintf('%u', crc32(...))o spl_object_hash(...)potrebbe essere molto meglio a seconda del contesto.

Una bella caratteristica di PHP è la CLI . Non è così "promosso" nella documentazione, ma se hai bisogno di script di routine / app console, usare cron + php cli è davvero veloce da sviluppare!

Quindi trucco "e stampa"

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

Fa eco a Blah se $ flag è vero. NON FUNZIONA CON ECHO.

Questo è molto utile nel modello e sostituisce il? : che non sono proprio facili da leggere.

Puoi usare il carattere meno nei nomi delle variabili come questo:

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

Perché usarlo Nessuna idea: forse per un modello CSS? O qualche strano JSON che devi produrre. È una caratteristica strana :)

La sintassi HEREDOC è la mia funzione nascosta preferita. Sempre difficile da trovare perché non puoi Google per <<< ma ti impedisce di dover sfuggire a grossi blocchi di HTML e ti consente comunque di rilasciare variabili nello stream.

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

Probabilmente non molti sanno che è possibile specificare "variabili" costanti come valori predefiniti per i parametri di funzione:

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

Le stringhe possono essere utilizzate come se fossero matrici :

$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"

L'unica cosa più utile sul codice PHP è che se non capisco bene una funzione vedo che posso cercarla usando un browser e digitando:

http://php.net/function

Il mese scorso ho visto la funzione "range" in alcuni codici. È una delle centinaia di funzioni che non sono mai riuscito a usare ma che si rivelano davvero utili:

http://php.net/range

Quell'URL è un alias per http://us2.php.net/manual/en/function.range.php . Questa semplice idea, di mappare funzioni e parole chiave su URL , è fantastica.

Vorrei che altre lingue, framework, database, sistemi operativi abbiano un meccanismo altrettanto semplice per cercare la documentazione.

Commenti rapidi sui blocchi

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


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

Questi commenti consentono di alternare se un blocco di codice è commentato con un carattere.

La mia lista ... la maggior parte di essi rientra più nelle "funzioni nascoste" che nelle "funzioni preferite" (spero!), E non tutte sono utili, ma ... sì.

// 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');

Puoi anche annidare operatori ternari, a volte è utile.

// 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.  

Bene, per ora mi fermo :-)

Hmm, è passato un po '..

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

Quindi, ho appena scoperto che puoi passare qualsiasi stringa come nome di metodo SE la racchiudi tra parentesi graffe. Purtroppo non è possibile definire alcuna stringa come metodo, ma è possibile catturarle con __call () ed elaborarle ulteriormente se necessario. Hmmm ....

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

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

Ho trovato questa piccola gemma nei commenti di Reddit:

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

Non puoi chiamare le funzioni all'interno di {} direttamente in questo modo, ma puoi usare le variabili-holding-the-function-name e chiamarle! (* e * puoi usare anche variabili variabili)

Manipolazione di array.
Tonnellate di strumenti per lavorare e manipolare le matrici. Potrebbe non essere univoco per PHP, ma non ho mai lavorato con un linguaggio che lo abbia reso così semplice.

Sono un po 'come te, ho programmato PHP per oltre 8 anni. Ho dovuto seguire un corso .NET / C # circa un anno fa e mi è piaciuto molto il linguaggio C # (odiato ASP.NET) ma mi ha reso uno sviluppatore PHP migliore.

PHP come lingua è piuttosto scadente, ma sono estremamente veloce con esso e lo stack LAMP è fantastico. Il prodotto finale supera di gran lunga la somma delle parti.

Detto questo, in risposta alla tua domanda:

http://uk.php.net/SPL

Adoro SPL , la classe di raccolta in C # era qualcosa che mi piaceva non appena ho iniziato con esso. Ora posso avere la mia torta e mangiarla.

Andrea

Sono un po 'sorpreso che nessuno lo abbia ancora menzionato, ma uno dei miei trucchi preferiti con gli array sta usando l'operatore plus. È un po 'come array_merge()ma un po' più semplice. Ho trovato che di solito è quello che voglio. In effetti, prende tutte le voci nell'RHS e le fa apparire in una copia dell'LHS, sovrascrivendole se necessario (cioè non è commutativo). Molto utile per iniziare con un array "predefinito" e aggiungere alcuni valori reali tutti in un colpo solo, lasciando i valori predefiniti in atto per i valori non forniti.

Esempio di codice richiesto:

// 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 );

Eccone uno, mi piace il modo in cui l'impostazione dei valori predefiniti sui parametri di funzione non forniti è molto più semplice:

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

Veloce e sporco è l'impostazione predefinita.
Il linguaggio è pieno di utili scorciatoie, questo rende PHP il candidato perfetto per (piccoli) progetti che hanno un breve time-to-market. Non che un codice PHP pulito sia impossibile, ci vuole solo qualche sforzo ed esperienza in più.

Ma adoro PHP perché mi permette di esprimere ciò che voglio senza scrivere un saggio.

PHP:

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

GIAVA:

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

E sì, questo include non digitare Int .