Fonctionnalités cachées de PHP? [fermé]

Je sais que cela ressemble à une question pointilleuse, mais laissez-moi vous expliquer d'où je viens.

À la sortie de l'université, j'ai trouvé un emploi dans une boutique PHP. J'y ai travaillé pendant un an et demi et j'ai pensé que j'avais appris tout ce qu'il y avait à apprendre sur la programmation.

Ensuite, j'ai trouvé un emploi en tant qu'atelier de développement interne individuel dans une grande entreprise où tout le travail était en C #. Dans mon engagement à ce poste, j'ai commencé à lire une tonne de blogs et de livres et j'ai rapidement réalisé à quel point j'avais tort de penser que je savais tout. J'ai appris sur les tests unitaires, l'injection de dépendances et les modèles de décorateurs, le principe de conception du couplage lâche, la composition sur le débat sur l'héritage, et ainsi de suite et ainsi de suite. Inutile de dire que mon style de programmation a complètement changé l'année dernière.

Maintenant, je me retrouve à ramasser un projet php en train de coder pour la start-up d'un ami et je me sens complètement contraint par opposition à la programmation en C #. Cela me dérange vraiment que toutes les variables d'une portée de classe doivent être référencées en ajoutant «$ this->». Cela me dérange qu'aucun des IDE que j'ai essayés n'a une très bonne intelligence et que mes méthodes de tests unitaires SimpleTest doivent commencer par le mot «test». Cela me rend fou que le typage dynamique m'empêche de spécifier implicitement le type de paramètre qu'une méthode attend, et que vous devez écrire une instruction switch pour effectuer des surcharges de méthode. Je ne supporte pas que vous ne puissiez pas avoir d'espaces de noms imbriqués et que vous deviez utiliser l'opérateur :: pour appeler le constructeur de la classe de base.

Maintenant, je n'ai pas l'intention de lancer un débat PHP vs C #, mais ce que je veux dire, c'est que je suis sûr qu'il y a des fonctionnalités PHP que je ne connais pas ou que je ne connais pas encore utiliser correctement. Je suis installé dans mon univers C # et j'ai du mal à voir à l'extérieur du bol en verre.

Alors je demande, quelles sont vos fonctionnalités préférées de PHP? Que pouvez-vous y faire que vous ne pouvez pas ou qui sont plus difficiles dans les langages .Net?

Documentation . La documentation obtient mon vote. Je n'ai pas rencontré de documentation en ligne plus complète pour un langage de programmation - tout le reste que je dois rassembler à partir de divers sites Web et pages de manuel.

Tableaux . À en juger par les réponses à cette question, je ne pense pas que les gens apprécient pleinement à quel point les tableaux en PHP sont faciles et utiles. Les tableaux PHP agissent en même temps comme des listes, des cartes, des piles et des structures de données génériques. Les tableaux sont implémentés dans le cœur du langage et sont utilisés partout, ce qui se traduit par une bonne localisation du cache du processeur. Perl et Python utilisent tous deux des constructions de langage distinctes pour les listes et les cartes, ce qui entraîne davantage de copies et des transformations potentiellement déroutantes.

Les gestionnaires de flux vous permettent d'étendre le "FileSystem" avec une logique qui, pour autant que je sache, est assez difficile à faire dans la plupart des autres langages.

Par exemple, avec le gestionnaire de flux MS-Excel, vous pouvez créer un fichier MS Excel de la manière suivante:

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

Les méthodes magiques sont des méthodes de secours qui sont appelées chaque fois que vous invoquez une méthode qui n'existe pas ou que vous attribuez ou lisez une propriété qui n'existe pas, entre autres.

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

Un développeur C ++ ici pourrait remarquer que PHP permet de surcharger certains opérateurs, par exemple ()ou (string). En fait, PHP permet encore plus de surcharger, par exemple l' []opérateur ( ArrayAccess ), la foreachconstruction du langage ( Iterator et IteratorAggregate ) et la countfonction ( Countable ).

La classe standard est un conteneur soigné. Je ne l'ai appris que récemment.

Au lieu d'utiliser un tableau pour contenir des attributs de serveur

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

Vous pouvez utiliser une classe standard

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

Ceci est particulièrement utile lors de l'accès à ces variables dans une chaîne

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

Les fichiers d'inclusion peuvent avoir une valeur de retour que vous pouvez affecter à une variable.

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

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

Vous pouvez profiter du fait que l' oropérateur a une priorité plus faible que =pour faire ceci:

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

Si la valeur de la première affectation est évaluée à true, la deuxième affectation est ignorée. Un autre exemple:

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

__autoload()(classe-) fichiers aidés par set_include_path().

En PHP5, il est désormais inutile de spécifier de longues listes d'instructions "include_once" lorsque vous faites une POO décente.

Définissez simplement un petit ensemble de répertoires dans lequel les fichiers de bibliothèque de classes sont correctement structurés et définissez le chemin d'inclusion automatique:

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

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

Désormais, PHP inclura automatiquement les fichiers nécessaires à la demande, économisant ainsi le temps d'analyse et la mémoire.

Facilité . La plus grande caractéristique est la facilité avec laquelle les nouveaux développeurs peuvent s'asseoir et écrire des scripts «fonctionnels» et comprendre le code.

La pire caractéristique est la facilité avec laquelle les nouveaux développeurs peuvent s'asseoir et écrire des scripts «fonctionnels» et penser qu'ils comprennent le code.

L' ouverture de la communauté autour de PHP et les quantités massives de projets PHP disponibles en open-source sont beaucoup moins intimidantes pour quelqu'un qui entre dans le monde du développement et comme vous, peuvent être un tremplin vers des langages plus matures.

Je ne discuterai pas des choses techniques comme beaucoup avant moi, mais si vous considérez PHP comme une communauté plutôt qu'un langage Web, une communauté qui vous a clairement embrassé lorsque vous avez commencé à développer, les avantages parlent vraiment d'eux-mêmes.

Variables et fonctions variables sans aucun doute!

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

Le même concept s'applique aux paramètres d'objet ($ some_object -> $ some_variable);

Très très gentil. Rendez le codage avec des boucles et des modèles très facile, et c'est plus rapide et plus sous contrôle que eval (Thanx @Ross & @Joshi Spawnbrood!).

Vous pouvez utiliser des fonctions avec un nombre d'arguments indéfini à l'aide de 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);

?>

J'adore les fichiers distants . Pour le développement Web, ce type de fonctionnalité est extrêmement utile.

Besoin de travailler avec le contenu d'une page Web? Un simple

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

et vous avez un descripteur de fichier prêt à l'emploi, comme n'importe quel autre fichier normal.

Ou que diriez-vous de lire un fichier distant ou une page Web directement dans une chaîne?

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

L'utilité de cette méthode particulière est difficile à surestimer.

Vous souhaitez analyser une image distante? Que diriez-vous de le faire via FTP?

$imageInfo = getimagesize('ftp://user:[email protected]/image/name.jpg');

Presque toutes les fonctions PHP qui fonctionnent avec des fichiers peuvent fonctionner avec un fichier distant. Vous pouvez même include()ou les require()fichiers de code à distance de cette façon.

strtr ()

C'est extrêmement rapide, à tel point que vous seriez surpris. En interne, il utilise probablement une structure de type b-tree folle pour organiser vos correspondances par leurs préfixes communs. Je l'utilise avec plus de 200 chaînes de recherche et de remplacement et il passe toujours par 1 Mo en moins de 100 ms. Pour toutes les chaînes, sauf pour des petites chaînes, strtr () est encore beaucoup plus rapide que strtolower () pour faire exactement la même chose, même en tenant compte du jeu de caractères. Vous pourriez probablement écrire un analyseur entier en utilisant des appels strtr successifs et ce serait plus rapide que la correspondance habituelle des expressions régulières, déterminer le type de jeton, générer tel ou tel autre type d'expression régulière.

J'écrivais un normalisateur de texte pour diviser le texte en mots, en minuscules, en supprimant la ponctuation, etc. et strtr était mon couteau suisse, il a battu le pantalon des expressions régulières ou même str_replace ().

Une fonctionnalité moins connue de PHP est extract()une fonction qui décompresse un tableau associatif dans l'espace de noms local. Cela existe probablement pour l'abormination autoglobale mais est très utile pour la création de modèles:

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

Maintenant, vous pouvez utiliser render_template('index.html', array('foo' => 'bar'))et uniquement $fooavec la valeur "bar"apparaît dans le modèle.

Range () n'est pas caché en soi, mais je vois encore beaucoup de gens itérer avec:

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

quand ils pourraient utiliser:

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

Et vous pouvez faire des choses simples comme

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

L'espace Web compatible PHP est généralement moins cher que quelque chose avec (asp) .net. Vous pourriez appeler cela une fonctionnalité ;-)

Le staticmot-clé est utile en dehors d'un point de vue POO. Vous pouvez rapidement et facilement implémenter la `` mémorisation '' ou la mise en cache de fonctions avec quelque chose d'aussi simple que:

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

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

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

Le staticmot clé crée une variable qui persiste uniquement dans la portée de cette fonction après l'exécution. Cette technique est idéale pour les fonctions qui frappent la base de données comme get_all_books_by_id(...)ou get_all_categories(...)que vous appelleriez plus d'une fois pendant le chargement d'une page.

Attention: assurez-vous de trouver la meilleure façon de créer une clé pour votre hachage, dans à peu près toutes les circonstances, ce qui md5(...)précède n'est PAS une bonne décision (problèmes de vitesse et de longueur de sortie), je l'ai utilisé à des fins d'illustration. sprintf('%u', crc32(...))ou spl_object_hash(...)peut être beaucoup mieux selon le contexte.

Une fonctionnalité intéressante de PHP est la CLI . Ce n'est pas si "promu" dans la documentation, mais si vous avez besoin de scripts / applications de console de routine, l'utilisation de cron + php cli est vraiment rapide à développer!

Puis "et imprimez" le truc

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

Fera écho Blah si $ flag est vrai. NE FONCTIONNE PAS AVEC ECHO.

Ceci est très pratique dans le modèle et remplace le? : ce ne sont pas vraiment faciles à lire.

Vous pouvez utiliser le caractère moins dans les noms de variables comme ceci:

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

Pourquoi l'utiliser? Aucune idée: peut-être pour un modèle CSS? Ou un JSON étrange que vous devez générer. C'est une caractéristique étrange :)

La syntaxe HEREDOC est ma fonction cachée préférée. Toujours difficile à trouver car vous ne pouvez pas Google pour <<< mais cela vous évite d'avoir à échapper de gros morceaux de HTML et vous permet toujours de déposer des variables dans le flux.

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

Peu de gens savent probablement qu'il est possible de spécifier des «variables» constantes comme valeurs par défaut pour les paramètres de fonction:

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

Les chaînes peuvent être utilisées comme s'il s'agissait de tableaux :

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

La chose la plus utile à propos du code PHP est que si je ne comprends pas très bien une fonction que je vois, je peux la rechercher en utilisant un navigateur et en tapant:

http://php.net/function

Le mois dernier, j'ai vu la fonction "range" dans un certain code. C'est l'une des centaines de fonctions que j'ai réussi à ne jamais utiliser mais qui s'est avérée vraiment utile:

http://php.net/range

Cette URL est un alias pour http://us2.php.net/manual/en/function.range.php . Cette idée simple, de mapper des fonctions et des mots-clés vers des URL , est géniale.

Je souhaite que d'autres langages, frameworks, bases de données, systèmes d'exploitation aient un mécanisme aussi simple pour rechercher de la documentation.

Commentaires de bloc rapide

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


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

Ces commentaires vous permettent de basculer si un bloc de code est commenté avec un caractère.

Ma liste… la plupart d'entre elles relèvent plus des «fonctionnalités cachées» que des «fonctionnalités préférées» (j'espère!), Et toutes ne sont pas utiles, mais… ouais.

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

Vous pouvez également imbriquer des opérateurs ternaires, ce qui est parfois 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.  

Bon, je vais m'arrêter pour l'instant :-)

Hmm, ça fait un moment ...

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

Donc, je viens de découvrir que vous pouvez passer n'importe quelle chaîne comme nom de méthode SI vous la placez entre accolades. Vous ne pouvez malheureusement pas définir de chaîne comme méthode, mais vous pouvez les attraper avec __call () et les traiter davantage si nécessaire. Hmmm ...

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

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

J'ai trouvé ce petit bijou dans les commentaires de Reddit:

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

Vous ne pouvez pas appeler des fonctions à l'intérieur de {} directement comme ceci, mais vous pouvez utiliser des variables contenant le nom de la fonction et les appeler! (* et * vous pouvez également utiliser des variables variables dessus)

Manipulation de tableau.
Des tonnes d'outils pour travailler et manipuler des tableaux. Ce n'est peut-être pas unique à PHP, mais je n'ai jamais travaillé avec un langage qui le rende aussi simple.

Je suis un peu comme vous, j'ai codé PHP depuis plus de 8 ans. J'ai dû suivre un cours .NET / C # il y a environ un an et j'ai vraiment apprécié le langage C # (détesté ASP.NET) mais cela a fait de moi un meilleur développeur PHP.

PHP en tant que langage est assez pauvre, mais je suis extrêmement rapide avec lui et la pile LAMP est géniale. Le produit final dépasse de loin la somme des pièces.

Cela dit, en réponse à votre question:

http://uk.php.net/SPL

J'adore le SPL , la classe de collection en C # était quelque chose que j'ai aimé dès que j'ai commencé avec. Maintenant, je peux avoir mon gâteau et le manger.

Andrew

Je suis un peu surpris que personne ne l'ait encore mentionné, mais l'un de mes trucs préférés avec les tableaux utilise l'opérateur plus. C'est un peu comme array_merge()mais un peu plus simple. J'ai trouvé que c'est généralement ce que je veux. En effet, il prend toutes les entrées du RHS et les fait apparaître dans une copie du LHS, en les écrasant si nécessaire (c'est-à-dire non commutatif). Très utile pour commencer avec un tableau "par défaut" et ajouter des valeurs réelles en un seul coup, tout en laissant les valeurs par défaut en place pour les valeurs non fournies.

Exemple de code demandé:

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

En voici un, j'aime comment définir des valeurs par défaut sur des paramètres de fonction qui ne sont pas fournis est beaucoup plus facile:

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

Rapide et sale est la valeur par défaut.
Le langage est rempli de raccourcis utiles, ce qui fait de PHP le candidat idéal pour les (petits) projets qui ont un court délai de mise sur le marché. Non pas qu'un code PHP propre soit impossible, cela demande juste un effort et une expérience supplémentaires.

Mais j'aime PHP parce qu'il me permet d'exprimer ce que je veux sans taper un essai.

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
}

Et oui, cela inclut de ne pas taper Int .