Características ocultas de PHP? [cerrado]

Sé que esto suena como una pregunta puntual, pero déjame explicarte de dónde vengo.

Fuera de la universidad conseguí un trabajo en una tienda PHP. Trabajé allí durante un año y medio y pensé que había aprendido todo lo que había que aprender sobre programación.

Luego conseguí un trabajo como taller de desarrollo interno de un solo hombre en una corporación considerable donde todo el trabajo estaba en C #. En mi compromiso con el puesto, comencé a leer un montón de blogs y libros y rápidamente me di cuenta de lo equivocado que estaba al pensar que lo sabía todo. Aprendí sobre las pruebas unitarias, la inyección de dependencia y los patrones decoradores, el principio de diseño del acoplamiento flojo, la composición sobre el debate de la herencia, y así sucesivamente. Todavía lo estoy absorbiendo todo. No hace falta decir que mi estilo de programación ha cambiado completamente en el último año.

Ahora me encuentro recogiendo un proyecto de PHP haciendo algo de codificación para el inicio de un amigo y me siento completamente limitado en comparación con la programación en C #. Realmente me molesta que todas las variables en un ámbito de clase tengan que ser mencionadas agregando '$ this->'. Me molesta que ninguno de los IDE que he probado tengan muy buena inteligencia y que mis métodos de prueba de unidad SimpleTest tengan que comenzar con la palabra 'prueba'. Me vuelve loco que la escritura dinámica me impida especificar implícitamente qué tipo de parámetro espera un método, y que usted tiene que escribir una declaración de cambio para realizar sobrecargas de métodos. No puedo soportar que no puedas tener espacios de nombres anidados y que tengas que usar el operador :: para llamar al constructor de la clase base.

Ahora no tengo intención de iniciar un debate PHP vs C #, más bien lo que quiero decir es que estoy seguro de que hay algunas características de PHP que no conozco o que aún no uso correctamente. Estoy ambientado en mi universo C # y tengo problemas para ver fuera del recipiente de vidrio.

Entonces, pregunto, ¿cuáles son sus características favoritas de PHP? ¿Qué cosas puedes hacer en él que no puedes o son más difíciles en los idiomas .Net?

Documentación . La documentación obtiene mi voto. No he encontrado una documentación en línea más exhaustiva para un lenguaje de programación; todo lo demás lo tengo que reunir de varios sitios web y páginas de manual.

Las matrices . A juzgar por las respuestas a esta pregunta, no creo que las personas aprecien completamente cuán fáciles y útiles son las matrices en PHP. Las matrices PHP actúan como listas, mapas, pilas y estructuras de datos genéricos, todo al mismo tiempo. Las matrices se implementan en el núcleo del idioma y se utilizan en todas partes, lo que da como resultado una buena ubicación de la caché de la CPU. Perl y Python usan construcciones de lenguaje separadas para listas y mapas, lo que resulta en más copias y transformaciones potencialmente confusas.

Los controladores de transmisión le permiten ampliar el "FileSystem" con una lógica que, hasta donde yo sé, es bastante difícil de hacer en la mayoría de los otros idiomas.

Por ejemplo, con el controlador MS-Excel Stream puede crear un archivo MS Excel de la siguiente manera:

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

Los métodos mágicos son métodos fallidos que se llaman cada vez que invocas un método que no existe o asignas o lees una propiedad que no existe, entre otras cosas.

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 desarrollador de C ++ aquí podría notar que PHP permite sobrecargar algunos operadores, por ejemplo, ()o (string). En realidad, PHP permite sobrecargar aún más, por ejemplo, el []operador ( ArrayAccess ), la foreachconstrucción del lenguaje ( Iterator e IteratorAggregate ) y la countfunción ( Contable ).

La clase estándar es un contenedor ordenado. Solo me enteré recientemente.

En lugar de usar una matriz para contener varios atributos

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

Puedes usar una clase estándar

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

Esto es particularmente útil cuando se accede a estas variables en una cadena

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

Los archivos de inclusión pueden tener un valor de retorno que puede asignar a una variable.

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

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

Puede aprovechar el hecho de que el oroperador tiene menos prioridad que =hacer esto:

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

Si el valor de la primera asignación se evalúa como true, la segunda asignación se ignora. Otro ejemplo:

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

__autoload()(clase) archivos ayudados por set_include_path().

En PHP5 ahora no es necesario especificar largas listas de declaraciones "include_once" cuando se hace una OOP decente.

Simplemente defina un pequeño conjunto de directorios en el que los archivos de la biblioteca de clases estén estructurados de manera sensata y configure la ruta de inclusión automática:

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

Ahora la __autoload()rutina:

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

Ahora PHP incluirá automáticamente los archivos necesarios a pedido, conservando el tiempo de análisis y la memoria.

Facilidad . La mejor característica es lo fácil que es para los nuevos desarrolladores sentarse y escribir scripts "de trabajo" y comprender el código.

La peor característica es lo fácil que es para los nuevos desarrolladores sentarse y escribir scripts "funcionales" y pensar que entienden el código.

La apertura de la comunidad que rodea a PHP y la gran cantidad de proyectos de PHP disponibles como código abierto es mucho menos intimidante para alguien que ingresa al mundo del desarrollo y, como usted, puede ser un trampolín hacia lenguajes más maduros.

No debatiré las cuestiones técnicas que muchos tienen antes que yo, pero si miras PHP como una comunidad en lugar de un lenguaje web, una comunidad que claramente te abrazó cuando comenzaste a desarrollar, los beneficios realmente hablan por sí mismos.

¡Variables variables y funciones sin duda!

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

El mismo concepto se aplica a los parámetros del objeto ($ some_object -> $ some_variable);

Muy, muy agradable. La codificación de Make con bucles y patrones es muy fácil, y es más rápida y está más controlada que Eval (¡Thanx @Ross & @Joshi Spawnbrood!).

Puede usar funciones con un número indefinido de argumentos usando 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);

?>

Me encantan los archivos remotos . Para el desarrollo web, este tipo de característica es excepcionalmente útil.

¿Necesita trabajar con los contenidos de una página web? Un simple

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

y tiene un identificador de archivo listo para usar, como cualquier otro archivo normal.

¿O qué tal leer un archivo remoto o una página web directamente en una cadena?

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

La utilidad de este método en particular es difícil de exagerar.

¿Quieres analizar una imagen remota? ¿Qué tal hacerlo a través de FTP?

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

Casi cualquier función PHP que funcione con archivos puede funcionar con un archivo remoto. Incluso puede include()o require()archivos de código de forma remota de esta manera.

strtr ()

Es extremadamente rápido, tanto que te sorprendería. Internamente, probablemente utiliza alguna estructura de tipo b-tree loco para organizar sus coincidencias por sus prefijos comunes. Lo uso con más de 200 cadenas de búsqueda y reemplazo y todavía pasa por 1 MB en menos de 100 ms. Para todas las cadenas, excepto trivialmente pequeñas, strtr () es incluso significativamente más rápido que strtolower () para hacer exactamente lo mismo, incluso teniendo en cuenta el conjunto de caracteres. Probablemente podría escribir un analizador completo utilizando llamadas strtr sucesivas y sería más rápido que la coincidencia de expresión regular habitual, averiguar el tipo de token, generar esto o aquello, el siguiente tipo de expresión regular.

Estaba escribiendo un normalizador de texto para dividir el texto en palabras, minúsculas, eliminar signos de puntuación, etc. y strtr era mi navaja suiza, superaba a los pantalones con expresiones regulares o incluso str_replace ().

Una característica no tan conocida de PHP es extract(), una función que desempaqueta una matriz asociativa en el espacio de nombres local. Esto probablemente existe para la aborto autoglobal, pero es muy útil para crear plantillas:

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

Ahora puede usar render_template('index.html', array('foo' => 'bar'))y solo $foocon el valor "bar"aparece en la plantilla.

Range () no está oculto per se, pero todavía veo mucha gente iterando con:

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

cuando podrían estar usando:

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

Y puedes hacer cosas simples como

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

El espacio web habilitado para PHP suele ser menos costoso que algo con (asp) .net. Usted puede llamar a eso una característica ;-)

La staticpalabra clave es útil fuera de un punto de vista de OOP. Puede implementar rápida y fácilmente la 'memorización' o el almacenamiento en caché de funciones con algo tan simple como:

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

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

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

La staticpalabra clave crea una variable que persiste solo dentro del alcance de esa función después de la ejecución. Esta técnica es ideal para funciones que afectan a la base de datos get_all_books_by_id(...)o get_all_categories(...)que llamaría más de una vez durante una carga de página.

Advertencia: asegúrese de encontrar la mejor manera de hacer una clave para su hash, en casi todas las circunstancias lo md5(...)anterior NO es una buena decisión (problemas de velocidad y longitud de salida), lo usé con fines ilustrativos. sprintf('%u', crc32(...))o spl_object_hash(...)puede ser mucho mejor dependiendo del contexto.

Una buena característica de PHP es la CLI . No está tan "promocionado" en la documentación, pero si necesita scripts de rutina / aplicaciones de consola, ¡usar cron + php cli es realmente rápido de desarrollar!

Luego truco "e imprimir"

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

Se hará eco de Blah si $ flag es verdadero. NO FUNCIONA CON ECHO.

Esto es muy útil en la plantilla y reemplazar el? : que no son realmente fáciles de leer.

Puede usar el carácter menos en nombres de variables como este:

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

¿Por qué usarlo? No tengo idea: ¿tal vez para un modelo CSS? O algún JSON extraño que necesites generar. Es una característica extraña :)

La sintaxis de HEREDOC es mi característica oculta favorita. Siempre es difícil de encontrar, ya que no puedes buscar en Google <<< pero evita que tengas que escapar de grandes fragmentos de HTML y aún te permite colocar variables en la secuencia.

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

Probablemente no muchos sepan que es posible especificar "variables" constantes como valores predeterminados para los parámetros de función:

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

Las cadenas se pueden usar como si fueran matrices :

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

Lo más útil del código PHP es que si no entiendo una función, veo que puedo buscarla usando un navegador y escribiendo:

http://php.net/function

El mes pasado vi la función "rango" en algún código. Es una de las cientos de funciones que nunca pude usar, pero resultó ser realmente útil:

http://php.net/range

Esa url es un alias para http://us2.php.net/manual/en/function.range.php . Esa idea simple, de funciones de mapeo y palabras clave para URL , es increíble.

Deseo que otros idiomas, marcos, bases de datos, sistemas operativos tengan un mecanismo tan simple para buscar documentación.

Comentarios rápidos de bloque

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


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

Estos comentarios le permiten alternar si un bloque de código se comenta con un carácter.

Mi lista ... la mayoría de ellos se encuentran más en las "características ocultas" que en las "características favoritas" (¡espero!), Y no todas son útiles, pero ... 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');

También puede anidar operadores ternarios, a veces resulta ú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.  

Bien, me detendré por ahora :-)

Hmm, ha pasado un tiempo ...

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

Entonces, acabo de descubrir que puede pasar cualquier cadena como nombre de método SI la encierra con llaves. No puede definir ninguna cadena como método, por desgracia, pero puede atraparlas con __call () y procesarlas aún más según sea necesario. Hmmm ...

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

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

Encontré esta pequeña joya en los comentarios de Reddit:

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

No puede llamar a las funciones dentro de {} directamente de esta manera, ¡pero puede usar variables-holding-the-function-name y llamarlas! (* y * también puedes usar variables variables en él)

Manipulación de matrices.
Toneladas de herramientas para trabajar y manipular matrices. Puede que no sea exclusivo de PHP, pero nunca he trabajado con un lenguaje que lo haya hecho tan fácil.

Soy un poco como tú, he codificado PHP por más de 8 años. Tuve que tomar un curso .NET / C # hace aproximadamente un año y realmente disfruté el lenguaje C # (odiaba ASP.NET) pero me convirtió en un mejor desarrollador de PHP.

PHP como lenguaje es bastante pobre, pero soy extremadamente rápido con él y la pila de LAMP es increíble. El producto final supera con creces la suma de las partes.

Dicho esto, en respuesta a tu pregunta:

http://uk.php.net/SPL

Me encanta el SPL , la clase de colección en C # fue algo que me gustó tan pronto como comencé con él. Ahora puedo tener mi pastel y comerlo.

Andrés

Estoy un poco sorprendido de que nadie lo haya mencionado todavía, pero uno de mis trucos favoritos con las matrices es usar el operador plus. Es un poco como array_merge()pero un poco más simple. He descubierto que generalmente es lo que quiero. En efecto, toma todas las entradas en el RHS y las hace aparecer en una copia del LHS, sobrescribiendo según sea necesario (es decir, no es conmutativo). Muy útil para comenzar con una matriz "predeterminada" y agregar algunos valores reales en un solo golpe, mientras se dejan los valores predeterminados para los valores no proporcionados.

Código de muestra 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 );

Aquí hay uno, me gusta cómo establecer valores predeterminados en los parámetros de función que no se proporcionan es mucho más fácil:

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

Rápido y sucio es el valor predeterminado.
El lenguaje está lleno de atajos útiles. Esto hace que PHP sea el candidato perfecto para proyectos (pequeños) que tienen poco tiempo de comercialización. No es que el código PHP limpio sea imposible, solo requiere un esfuerzo extra y experiencia.

Pero me encanta PHP porque me permite expresar lo que quiero sin escribir un ensayo.

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
}

Y sí, eso incluye no escribir Int .