it-swarm.it

Quali caratteristiche vorresti avere in PHP?

Dal momento che è la stagione delle vacanze ora e tutti fanno i desideri, mi chiedo: quali funzionalità linguistiche vorresti PHP avrebbe aggiunto? Sono interessato ad alcuni suggerimenti pratici/desideri per la lingua. Da pratico I significare:

  1. Qualcosa che può essere praticamente fatto (non: "Vorrei PHP indovinerei cosa significa il mio codice e correggerò i bug per me" o "Vorrei che qualsiasi codice venisse eseguito sotto i 5ms")
  2. Qualcosa che non richiede di cambiare PHP in un'altra lingua (non: "Vorrei che lasciassero cadere $ segni e usassero lo spazio invece di parentesi graffe" o "Vorrei PHP sono stati compilati, digitati staticamente e aveva # nel nome ")
  3. Qualcosa che non richiederebbe la rottura di tutto il codice esistente (non: "Rinominiamo 500 funzioni e cambiamo l'ordine dei parametri per loro")
  4. Qualcosa che fa cambia la lingua o qualche aspetto interessante (non: "Vorrei che ci fosse un'estensione per supportare il protocollo XYZ" o "Vorrei bug # 12345 sono stati finalmente risolti ")
  5. Qualcosa che è più di un rant (non: "Vorrei PHP non farebbe schifo così male")

Qualcuno ha degli auguri?

Modifica mod: Stanislav Malyshev è un core PHP.

88
StasM

Non mi dispiacerebbe i parametri nominati.

getData(0, 10, filter => NULL, cache => true, removeDups => true);
// instead of:
getData(0, 10, NULL, true, true);

// or how about:
img(src => 'blah.jpg', alt => 'an albino platypus', title => 'Yowza!');

Purtroppo il PHP devs abbattuto quell'idea già.

Più dereferenziazione:

echo something_that_returns_array()[4];

Altri hanno menzionato parametri nominati e sintassi dell'array più breve. Non mi dispiacerebbe anche la sintassi degli oggetti più corta.

$a1 = array(1, 2, 3, 4);
$a2 = [1, 2, 3, 4];

$b1 = (object)array('name' => 'foo');
$b2 = {'name' => 'foo'}; // or something?
93
Annika Backstrom

Dopo aver lavorato con PHP per circa 13 anni, e pesantemente con JS per circa 4, ci sono un paio di cose che penso PHP farebbe bene a prendere in prestito da JS :

1) notazione abbreviata per array e oggetti. Credo che questo potrebbe essere stato discusso e abbattuto su Internals (quindi sento - non mi piace vedere come è fatta la salsiccia), ma trovo davvero che la notazione letterale per array e oggetti in JS sia un grande vittoria della produttività.

Per esempio:

$arr     = [1,2,3,4];
$assoc   = [foo=>'bar', baz=>'boo'];
$stdobj  = {foo->'bar', baz->'boo'};

(IMHO) è solo molto più facile da scrivere e più pulito di

$arr     = array(1,2,3,4); // not too bad
$assoc   = array("foo"=>'bar', baz=>'boo'); // not too bad either
$stdobj  = new stdClass; // this gets pretty rough
$stdobj->foo = 'bar';
$stdobj->baz = 'boo';

Ho sentito che è stata sollevata una certa preoccupazione per la potenziale confusione, ma in realtà è più confusa di, diciamo, la notazione ereditaria? Almeno, fare un oggetto stdClass in PHP è abbastanza dettagliato da scoraggiare la pratica, penso.

2) Essere in grado di ridefinire funzioni e metodi precedentemente definiti sarebbe davvero utile. Semplificherebbe in particolare le situazioni estendendo una classe e creare un'istanza della nuova classe è eccessivamente complessa o poco pratica. Penso che dovremmo evitare la ridefinizione delle funzioni e dei metodi core/non-userspace.


Oltre a questi due, penso PHP deve supportare in modo trasparente unicode. Questo sta diventando sempre più un problema per gli sviluppatori e le soluzioni attualmente offerte in PHP sono confuse e spesso non performanti. Rendere pronte per l'uso tutte le funzionalità standard di stringa unicode una grande vittoria per i programmatori PHP.

Grazie per avermelo chiesto!

72
Funkatron

Cose che vorrei, come ex apologista di lunga data PHP:

  1. Sintassi più breve per le matrici. PHP le matrici sono una delle caratteristiche più sorprendenti del linguaggio a causa della loro flessibilità, ma è un trascinamento per scrivere some_array_method($argity, array('key' => $value));. Credo che questa proposta sia già stata sviscerata nella mailing list PHP purtroppo.
  2. finally support
  3. Attributi/annotazioni. Questi consentono di aggiungere un comportamento personalizzato a un metodo in modo da consentire il riutilizzo del codice. Ad esempio, in un framework MVC, si potrebbe definire un AuthorizeAttribute che indicherebbe che un controller o un metodo di azione richiede che l'utente sia autorizzato. Il quadro stesso sarebbe responsabile della ricerca degli attributi e della loro azione di conseguenza. Credo che PHPUnit utilizzi già una sorta di attributo inserendoli nei commenti di docblock, che possono essere letti usando la riflessione, ma inserire la funzionalità effettiva nei commenti di docblock è certamente un trucco.
  4. Sintassi lambda più breve. Invece di dover scrivere function($x){ return $x*2;}, forse potrei scrivere $x => return $x*2 O qualcosa del genere. Questo è ancora qualcosa che rende un po 'trascinabile usare questa funzione. Ad esempio $results = array_filter(array(1,2,3), function($a) { return $a % 2; }): vs $results = array_filter(array(1,2,3), $a => return $a % 2 ); Il primo ha un impianto idraulico molto più che è sostanzialmente irrilevante per il lavoro che stai cercando di realizzare.
  5. Un Decimal (matematica a virgola fissa) incorporato che supporta le operazioni matematiche attraverso gli operatori normali sarebbe un po 'bello, dato che non abbiamo un sovraccarico dell'operatore.
  6. METODI MAGICI DEL MOAR. I metodi magici sono fantastici. Ho potuto vedere PHP aggiungere un sovraccarico da parte dell'operatore tramite metodi magici (so che praticamente non accadrà mai). Ma in generale, forniscono davvero dei modi fantastici per agganciarsi al linguaggio e fare cose interessanti.
48
davidtbernal

Crea PHP veramente orientato agli oggetti. L'evoluzione slap on another global function Di PHP deve finire.

array_merge(array_filter(array_intersect_key($arr1, $arr2), "is_int"), $arr3);

Per me è difficile da leggere. Devo creare il mio stack mentale e compilarlo da solo. Fondamentalmente dovrebbe leggere al contrario. $dog->wakeup()->bark(); è facile da leggere rispetto a bark(wakeup($dog))

$arr1->array_intersect_key($arr2)->array_filter("is_int")->array_merge($arr3);

Hai fatto il passo verso l'abilitazione del supporto oggetto/metodo ora per favore usalo nelle effettive core PHP funzioni.

Rinominiamo 500 funzioni e cambiamo l'ordine dei parametri per esse.

Lo spostamento di questa funzionalità sui metodi consentirebbe loro di essere rinominati usando alcuni in modo coerente. Romperebbe qualsiasi retrocompatibilità se stringhe e array avessero i loro metodi?

48
Keyo

Un motore di query integrato nella lingua sarebbe fantastico. Un po 'come quello che è disponibile in .NET chiamato LINQ. Aiuterebbe l'ordinamento attraverso enormi matrici di dati e standardizzerebbe l'accesso al database, in modo che un minor numero di attacchi con iniezione SQL abbia successo.

40
Nick Berardi

Oh. Tipo di suggerimento per i primitivi. Sarebbe carino.

38
ruurd

Vorrei davvero un supporto Unicode pronto all'uso. Molte lingue si muovono in quella direzione ma PHP ha ancora strani comandi disseminati dappertutto.

Le stringhe PHP sono solo array di byte semplici. Il loro contenuto non è portatile in quanto dipende dalla codifica predefinita corrente.

Lo stesso vale per la rappresentazione creata da serialize. Contiene una rappresentazione di byte con prefisso di lunghezza della stringa senza effettivamente memorizzare alcuna informazione di codifica.

La maggior parte delle funzioni PHP (stringa) non ha idea di Unicode. Per un elenco dettagliato che includa il livello di rischio di ciascuna funzione, consultare: http://www.phpwact.org/php/ i18n/utf-8

http://blog.ginkel.com/2010/03/php-unicode-support-or-the-lack-thereof/

34
Emil Stenström

Crea stringhe come oggetti, con metodi integrati per sostituire quelli non nominati e parametrizzati in modo incoerente. per esempio.

$subject->replace($search,$replace);
$string->split($separator);
$string->trim();

eccetera.

Modifica: un'altra cosa: questi metodi dovrebbero sempre prevedere ed emettere UTF-8, ad eccezione di quelli specificamente intesi per gestire le codifiche. Se l'input non è valido UTF-8, dovrebbe essere generata un'eccezione, anche se l'output della funzione non sarà influenzato dalla codifica.

32
rjmunro

1) Mi piacerebbe che gli oggetti appena istanziati restituissero "$ this" in modo da poter eseguire il metodo chain, $ user = new User ('john') -> setLastName ('Doe') -> save ();

2) Se hai mai usato Ruby, e il nodo più recente, hanno un'ottima Shell interattiva (IRB). Mi piacerebbe che PHP ne avessi uno che fosse effettivamente utile.

3) Tratti/Mixin, ma ho sentito che stanno arrivando.

4) Voglio secondare l'array corto $ myArray = ['my', 'array'];

5) Denominazione/ordine coerenti (ad es. Pagliaio dell'ago)

24
Jakefolio

1) si prega di sbarazzarsi di include (). I riferimenti ad altri file dovrebbero essere riferimenti e non posizionare effettivamente il contenuto di un file di codice sorgente in un altro. Troppi troppi PHP usano include () come un tipo di chiamata di funzione piuttosto che un mezzo per fare riferimento a una libreria. Ciò porta a tutti i tipi di ambiguità nello stato variabile e nel codice instabile. Sostituiscilo con un comando "usa" simile al Perl.

2) si prega di fornire un metodo out of the box per compilare un PHP in un singolo file bytecode distribuibile o eseguibile. Ciò migliorerà notevolmente il fascino di PHP come linguaggio di sviluppo commerciale. Questo dovrebbe essere un componente di base del linguaggio. Non preoccuparti dei file html utilizzati per la GUI di un'applicazione perché ...

3) si prega di sbarazzarsi della possibilità di incorporare PHP in HTML. O almeno fornire una modalità 'no embed'. Questo è un casino assoluto e incoraggia la cattiva progettazione mescolando logica dell'applicazione e presentazione insieme. Gli sviluppatori dovrebbero utilizzare i modelli per la visualizzazione e non dare uno schiaffo PHP insieme e sperare per il meglio.

Firmato,

GrandmasterB

ps: non ascoltare ciò che dicono gli altri qui, sono stato bello tutto l'anno

20
GrandmasterB

Una direttiva ini per E_ERROR su costanti indefinite, anziché assumere che sia una stringa con E_NOTICE.

18
Annika Backstrom

Normalizza lo spazio dei nomi globale con una convenzione di denominazione ben ponderata che abbia senso per i nuovi arrivati!

Per citare il nostro amato Jeff Atwood: PHP fa schifo ma non importa !

14
David Murdoch

1) Sintassi più breve di array/oggetti, come JavaScript (come menzionato in precedenza)

2) Consenti alle variabili const di consentire il risultato di un calcolo come fa define().

3) Concatenamento diretto dal costruttore: new User()->name('Ryan');

4) Dereferenziazione di array: something_that_returns_array()[4];

5) Supporto SPL espanso. SPL fa un buon lavoro nel reinventare le funzioni stringa e array (tra le altre cose) come oggetti. L'espansione di SPL potrebbe risolvere molte lamentele sul fatto che la lingua sia così stravagante.

6) L'uso di ArrayObject() dovrebbe essere trasparente come l'uso di array(). Dovresti essere in grado di fare cose come array_filter($array_object_instance) senza fare array_filter($array_object_instance->getArrayCopy()). Ancora meglio, ovviamente, sarebbe $array_object_instance->filter().

7) Unicode completo sarebbe bello.

8) Smetti di fare strane conversioni di tipo automatico. Ad esempio, non dovresti essere in grado di echo un oggetto SimpleXMLElement senza prima averlo digitato in modo esplicito come stringa. O almeno, lancia qualcosa quando succede (ad es. In modalità rigorosa o qualunque sia la modalità error_reporting(-1)).

9) Supporto per più thread o una sorta di callback con evento/asincrono. Ciò è importante soprattutto quando si tenta di caricare file di grandi dimensioni tramite cURL. Invece di vecchi thread skool, qualcosa come Grand Central Dispatch di Apple sarebbe bello. O anche qualcosa di simile a JavaScript in cui è possibile effettuare richieste asincrone e definire callback.

10) La denominazione/ordine coerente (ovvero il pagliaio ad ago) sarebbe bello, ma penso che questo potrebbe essere risolto meglio con SPL.

11) Un interattivo ufficialmente supportato PHP Shell, come IRB. Facebook ne ha uno chiamato phpsh che è stato scritto in Python, ma manca del polacco che vorrei vedere.

12) Per l'API di Reflection, aggiungi il supporto per (a) commenti docblock su costanti (globale e di classe) e (b) supporto per l'analisi di commenti simili a PHPDoc in una struttura di dati sensibile. Esiste un pacchetto PECL chiamato "docblock" che tenta di farlo, ma non sembra che l'autore sia andato molto lontano.

EDIT: 13) Mi piacerebbe anche vedere la possibilità di utilizzare ! e ? nei nomi delle funzioni - come Ruby can.

13
Ryan Parman
13
Kemo

Vorrei vedere un metodo legittimo per creare/definire array COSTANTI. Ci sono alcuni modi per simulare questo tipo di funzionalità, ma sarebbe bello se fosse solo una caratteristica di PHP. Sarebbe bello se si potesse creare un array in un modo simile alla dichiarazione "finale" di Java.

Ho creato un sistema di accesso che è molto veloce da configurare. Tutto quello che devi fare è cambiare il contenuto di un array in un file di testo per specificare i campi desiderati per le informazioni dell'utente. Utilizzando una serie di loop for, gestisce tutto, dalla generazione di moduli e sensibilizzazione dell'input, alle chiamate al database, ma tutto dipende da questo array originale.

Il file con l'array viene bloccato con autorizzazioni, ma una volta che l'array si sposta nell'etere è mutabile. Sebbene ritenga che il sistema sia piuttosto sicuro, non mi piace lasciare nulla al caso. Un metodo per finalizzare le matrici sarebbe bello per una situazione come questa.

Nuova idea !!

Ohhh, ho pensato a qualcos'altro che mi sarebbe davvero piaciuto in php. Vorrei un qualche tipo di sistema per controllare le operazioni dei file php e le operazioni di directory simili al modo in cui funziona .htaccess.

Il file .phpaccess dovrebbe attivare un certo tipo di dominio/stesso criterio Origin.

Ad esempio, se ospitassi molti siti con host virtuali, potrei avere un file .phpaccess in una directory che direbbe a php di controllare l'origine di eventuali script in esecuzione che stanno cercando di operare sulla mia directory protetta. Se lo script non proviene da quella directory o dalle sue sottodirectory, le operazioni sui file/o sui socket verranno negate.

Penso che un sistema come questo renderebbe l'hosting virtuale un ambiente molto più sicuro. Se si potesse collocare uno di questi nella parte superiore di ciascun host virtuale, si ridurrebbe la possibilità che qualcuno trovi un modo per intrufolarsi da un host virtuale vicino.

Anche se sarebbe bene avere un metodo per proteggerlo al contrario di questo modo. vale a dire, limitare la portata degli script in una singola directory a quella directory.

È lo yin e lo yang che sai!

12
Dave B.

1) Comprensione di array nello stile di Python lista di comprensione:

$newlist = array($x->something for $x in $oldlist);

//with short array syntax:
$newlist = [$x->something for $x in $oldlist];

2) Sintassi dell'array breve

$newlist = [1,2,3,4,...];

3) Rendi vuoto () non considerare la stringa '0' come vera

12
sfrench

I miei due più grandi desideri come hardcore PHP:

  1. Sostieni finalmente. È un grande casino aggirare immaginariamente questo attraverso bandiere o mezzi simili.
  2. Mi piacerebbe vedere il supporto sulla sintassi di C # per getter e setter. Quando hai molti getter e setter, una semplice sintassi come quella di C # è un ottimo booster di prestazioni invece di farlo nel modo Java e scrivere metodi getter e setter. I metodi magici sono fantastici nei casi in cui tu vuoi creare membri in modo dinamico (ad esempio, se vuoi dare un renderer di template alcune variabili da usare), ma non sono utili per le proprietà normali su cui vorresti IDE da completare automaticamente, conosci i loro tipi e così via, ciò contribuirebbe a rendere il codice più piccolo, ancora leggibile e facile da usare.
11
Johnco

Sintassi del linguaggio : ci sono alcuni buoni indizi in pihipi e phpreboot di ciò a cui gli sviluppatori sono interessati (anche se phpreboot va troppo lontano diventando JS).

Metodologia di sviluppo : migliorerebbe notevolmente la durata di vita di PHP.net se tali sondaggi fossero effettivamente presi in considerazione. Non prendere altri pomeriggi volenti o brutti IRC decisioni sulla sintassi della sessione.

Funzionalità individuali : alcune sono state menzionate in precedenza, ma brucerò felicemente del karma per essere più schietto qui:

  • Tipo di stringa Unicode.
  • Bigint (vedi Python).
  • Runkit builtin per rimuovere/rinominare/sovrascrivere funzioni e classi integrate, che non sono sempre così ben progettate.
  • Modern OOP
    • ereditarietà multipla (anziché complessità per supportare raramente casi Edge con sintassi di tratti goffi)
    • gli scalari possono raddoppiare come oggetti (vedi Python), ad es. array () funziona come ArrayObject o stringhe come SplString (richiede metodi utilizzabili, tutte le funzioni stringa devono essere disponibili come str::toupper())
  • Deprecare la merda di merda \ sintassi dello spazio dei nomi , correggi il parser e adotta :: come alternativa. Sai, come una vera lingua.
  • Qualsiasi variazione di LINQ (anche se non mi fido di voi ragazzi escogitate una sintassi ragionevole)
  • o letterali XML.
  • Sbarazzarsi del comportamento di runtime php.ini e degli switch semantici. Elimina un po 'di entusiasmo, vero, ma gioverebbe a sviluppatori e utenti.
  • Sì, i magic_quotes non sono ancora spariti.
  • Converti il ​​bytecode di Zend Engine in PBC

Anche se, se ciò non fosse ovvio, potrei finanziare felicemente chiunque altro per fare quest'ultimo, e uccidere php.net come implementazione principale. :P
Oh, ho appena notato, è wiki della community. Quindi c'è la possibilità che tu non sia qui per il karma, ma un interesse genuino. In tal caso, esaminare il <b> problema </b> che danneggia gravemente la lingua (directorite).

9
mario

Mi piacerebbe vedere l'unificazione di errori ed eccezioni in un unico concetto (eccezioni). È fantastico essere in grado di rilevare le eccezioni e scriverle in un registro, per trovare e correggere i bug in quel modo. Ma se c'è qualcosa di fondamentalmente sbagliato (leggi: PHP) in un codepath che viene colpito molto raramente, non c'è un buon modo per incanalare quelle informazioni nello stesso database di problemi.

Per favore, Babbo Natale, introduce un interruttore in php.ini che trasformerebbe tutti gli errori in eccezioni - idealmente, eccezioni che posso catturare nel mio codice.

8
Alex
  • supporto per le enumerazioni (come Java 1.5+)
  • Essere in grado di definire i tipi di restituzione del metodo, in interfacce e classi
  • supporto per la definizione di annotazioni/metadati su proprietà e metodi.
  • essere in grado di fare un suggerimento di tipo rigoroso per gli argomenti scalari del metodo.
7
Kees van Dieren

PHP mi sta bene perché è adatto per creare siti Web di piccole e medie dimensioni; Devo essere un po 'privo di immaginazione, l'unica cosa a cui potrei pensare come risposta a questa domanda sarebbe qualcosa che la rendesse più adatta ai siti ad alto traffico.

Sto pensando in termini di spawn di processi ad altri core, ad esempio l'aggiornamento di un database in un processo durante la creazione della pagina di output in un altro processo. Una rapida ricerca su Google indica che questo può essere simulato, ma al momento non è supportato direttamente in php.

7
geekbrit

Mi è davvero mancato che i tipi scalari non siano trattati come oggetti e gli oggetti reali non possono agire come qualsiasi altro tipo o oggetto (tranne la stringa dovuta a __toString ()).

7
pestaa

Pulisci "Note fornite dall'utente" su http://php.net . A volte sono un vero casino, pur essendo un grande valore in generale.

6
bobah

Ci sono alcune funzioni dell'array abbastanza decenti in PHP, che forniscono capacità di elaborazione dell'elenco, con callback e create_function() che forniscono un calcolo lambda di base.

Il problema principale è che è troppo prolisso in PHP, un sistema abbreviato sarebbe eccellente, in particolare per quanto riguarda i comandi di mappa/riduzione.

Ancora più importante, le funzioni dell'elenco non sono completamente complete:

  • non esiste una funzione foldr, array_reduce() fornisce foldl
  • array_map() dovrebbe passare la chiave nel secondo argomento, come fa array_walk()
  • un array_map_keys() potrebbe essere utile per la modifica dei tasti
  • la comprensione dell'elenco è molto complessa, range(), array_fill() e array_fill_keys() gestiscono solo così tanti casi e array_filter() è separato

Non sto cercando di rendere PHP in Haskell, ma PHP è spesso usato per manipolare la struttura dei dati di tipo elenco e avere un set completo di strumenti in questo il rispetto sarebbe utile.

5
Orbling

Sovraccarico dell'operatore:

$result = $MatrixA + $MatrixB * $MatrixC;
5
MicE

Supporto di file di grandi dimensioni. Abbastanza per favore?

Vedi http://bugs.php.net/bug.php?id=27792 (anche se potrebbero esserci anche più aree/funzioni che richiedono attenzione).

4
Don MacAskill

Aggiungi eccezioni invece di produrre E_WARNING ... È molto fastidioso non poter usare qualcosa come:

try{
   $f = fopen('asd', 'r');
   flock($f, LOCK_SH);

   while(!feof($f)){
       echo fread($f, 512);
   }

   fclose($f);

}catch(IOException $ex){
   echo 'Oops, something wrong: '.$ex->getCode();
}

Naturalmente, al momento non è molto pratico ma è molto fastidioso ricevere:

AVVERTIMENTO

AVVERTIMENTO

AVVERTIMENTO

e non riesco a controllare il flusso di codice senza scrivere il mio gestore_errore e annusare la stringa quale errore è stato prodotto (permesso, nome file errato o altro; non mi dispiace per altre fonti di errori qui) al fine di gettare la corretta eccezione .

Spero di non dover spiegare perché è importante.

PHP è diventato orientato agli oggetti un po 'di tempo fa e noi programmatori che usano PHP non vediamo l'ora di OO caratteristiche, non introducendo "goto" ... Quando ho scoperto che è davvero successo, io pensavo fosse un pesce d'aprile.

4
eRIZ
  1. Consolida il modello a oggetti: estendi tutti gli oggetti alla classe di oggetti base. La classe Object avrebbe (tra le altre cose) implementato tutti i metodi magici (quindi non sarebbero più magici!)

  2. Sposta le estensioni nei loro spazi dei nomi: disordinare lo spazio dei nomi globale $conn = new \MySQLi\Connection();

  3. Annulla la parrucca della funzione spl_autoload()! Seriamente, questa è forse una delle più grandi caratteristiche di PHP e anche la più inutile allo stesso tempo. spl_autoload è il caricatore automatico predefinito, che supporta spazi dei nomi ed estensioni di file multiple, ma per qualche ragione sconosciuta richiede che i nomi dei file siano minuscoli. C'è un segnalazione bug compilata per questo , ma lo staff ha risposto che non lo riparerà a causa della compatibilità con le versioni precedenti. Giusto ... non è come se ogni framework fosse dotato del proprio caricatore automatico, dal momento che quello predefinito è paralizzato!

4
Mchl

Porta il supporto taint all'ultima versione e includilo nelle build standard, preferibilmente attivato nella configurazione predefinita http://wiki.php.net/rfc/taint

Ciò impedirebbe attacchi di iniezione XSS e SQL rendendo il codice persone corretto.

4
rjmunro

Annotazioni per PHP sarebbe fantastico, una caratteristica che si distinguerà per i prossimi anni. Questa funzione aiuterà a scrivere grandi framework con codice pulito.

3
user10916

Vorrei vedere una clausola else per while, for e foreach. Per esempio.:

while (/*condition*/) {
   /* display each result */
}
else {
   /* condition was never true; display "no results found" message */
}

Il blocco else viene eseguito solo se la condizione per while era mai vero.

Ciò lo farebbe in modo da non dover tenere traccia delle bandiere booleane e forse potrebbe aiutarti a pensare ai casi limite e alle possibili condizioni di errore.

3
Macneil

Non sbarazzarti di tag aperti brevi, in particolare l'eco uno = (. Questo:

<?=$myvar?>

... è molto meglio di questo:

<?php echo $myvar;?>
3
dukeofgaming
  1. Mi piacerebbe un giorno vedere il tipo di dati - mi piace anche la semplicità di non dover affrontare i tipi di dati, questa è un'arma a doppio taglio per me.
  2. spazi dei nomi!
  3. Chiamate di funzioni di sovraccarico con firme di metodi diversi
  4. Migliore supporto per i test unitari e l'iniezione di codice, PHPUnit è uno strumento straordinario, così come il framework di iniezione di codice di Symfony fa miracoli ... tuttavia tutti hanno una propria curva di apprendimento.
3
cdnicoll

Sembra che nessuno abbia menzionato una sicurezza di tipo opzionale .

Sarebbe bello poter scrivere codice in questo modo:

<?php
$someVariable = 123;
$someVariable = "Hello World";

int $anotherVariable = 123;
////$anotherVariable  = "Hello"; // This must cause runtime exception.
////int $lastVariable = "World"; // This must cause it too.
?>

Un altro esempio:

<?php
// Current style (which must remain).
function SayHello($howManyTimes)
{
    if (!is_int($howManyTimes))
    {
        throw new Exception('Argument $howManyTimes is invalid. An integer was expected, instead of ' . gettype($howManyTimes) . '.');
    }

    echo str_repeat('Hello', $howManyTimes);
}

// New, optional, style, allowing to have a shorter code.
function SayWorld(int $howManyTimes)
{
    echo str_repeat('World', $howManyTimes);
}

SayHello(123);
SayHello("Hello World");

SayWorld(123);
////SayWorld("Hello World"); // This must cause runtime exception.
?>
2
Arseni Mourzenko

Consenti allo spazio dei nomi di un file dalla chiamata include, qualcosa del genere

include('mytemplate.php', 'MyNamespace');

o

include 'mytemplate.php' use MyNamespace;

E inizia a consentirci di importare ("usare") spazi dei nomi senza prefisso:

use OtherNamespace as self;

(invece di dover importare ogni singola classe per usarla senza un prefisso dello spazio dei nomi)

2
user11122
  • Query SQL non bloccanti (come inserire un registro, ma non attendere il risultato della query)
  • Query SQL parallele

solo un sogno

2
Erlango

Generatori. Come in Python, con resa.

2
ts01

Possibilità di generare eccezioni in __destructor o __toString. E, davvero, c'è qualche spiegazione sul perché non è possibile?

2
ts01

Sarebbe bello avere la possibilità di impostare il tipo primitivo (bool | booleano, int | intero, float, double, stringa, oggetto) di un parametro in un metodo come consentito dalla matrice.

Esempio:

  • attuale:

    class HttpResponse {
    public function __construct($version, $statuscode = HttpStatus::OK, HttpResponseHeaders $headers = array(), $body = '');
    

    }

  • speranza:

    class HttpResponse { public function __construct($version, integer $statuscode = HttpStatus::OK, HttpResponseHeaders $headers = array(), string $body = ''); }
    

Ho anche pensato di avere una classe statica Assert che può essere utile.

2
user11251

supporto per i suggerimenti di tipo per tutti i tipi e metodi magici _toXXX per ogni tipo possibile. (l'uso comune di php deriva da IMHO piuttosto che limitare il tipo di giocoleria/con alcune eccezioni, come il float di conversione <-> int /)

2
ts01

Sicuramente il sovraccarico del metodo utilizzando il suggerimento del tipo per differenziare le firme del metodo. Inoltre, vorrei vedere una sorta di "attributi" di stile ASP.NET, in modo che le azioni del mio controller in un PHP MVC framework potesse apparire così:

/* [HttpGet] */
public function login() {}

/* [HttpPost] */
public function login() {}
2
TaylorOtwell

PHP ha bisogno di una classe di stringhe Unicode immutabile. Assicurarsi che le stringhe di input siano valide, UTF-8 normalizzato e che rimanga valido dovrebbe essere banale.

$str = new Utf8String('āll īs ōk');
$str = $str->ucwords(); // Āll Īs Ōk
$str = $str->strtolower()->toAscii(); // all is ok
(string) $str; // UTF-8 bytes

Ho realizzato un prototipo basato su PHP-UTF8 .

2
Steve Clay

Letterali nativi regexp, virgolette qw{}, qq{} E q{} In stile Perl.

La chiamata del metodo concatenato per tutti gli oggetti: $object{ ->method1(); ->method2(); ->getPerson()->getName(); }

L'espressione dell'istruzione: ({echo $a; $a = $a + 1; $a})

COERENTE, NON CONFIGURABILE, NON PUO 'ESSERE DISATTIVATO short_open_tags. Se non sono configurabili, PHP sarà più portatile. Vedi che cosa includono i tag di stile ERB -

1
Ming-Tang
  • Mi piacerebbe vedere un modo nativo per impostare open_basedir negli host virtuali in base al nome di dominio automaticamente, senza dover configurare una direttiva per Host (simile alla patch di Jason Greene, ma nativa).

  • Per favore, a livello di applicazione a livello globale! Le variabili globali dell'app sarebbero disponibili per tutti gli script php, una volta inizializzati.

  • Un modo per rilasciare la sessione per altri thread, senza chiuderli:

 session_start (); 
 $ _ SESSION ['favcolor'] = 'white'; 
 session_flush (); // la sessione è ora sbloccata, quindi altri thread possono usarla 
 // loop enorme ... 
 $ _ SESSION ['taste'] = 'sweet'; // la sessione si blocca di nuovo automaticamente 
 session_close (); 
  • Forse un po 'di cache su disco sarebbe piacevole, quindi possiamo precompilare manualmente gli script php per un'esecuzione più veloce. Simile alla cache di memoria, ma con file su disco e generazione manuale (probabilmente usando alcune nuove estensioni di file).

  • Inoltre, qualcosa di simile a <? Php = $ variabile?> Come collegamento a <? Php echo $ variabile; ?> sarebbe bello (come nei tag asp, ma con i tag brevi/asp disabilitati).

1
Bacco

e, ovviamente, get_shutdown_functions () e unregister_shutdown_function (). Attualmente non è possibile accedervi. E più in generale, un supporto astratto per lo stacking di callback - qualcosa per unificare spl_autoloads, funzioni di shutdown, gestori di errori (attualmente non impilabili, ma forse ...) ecc. Tipo di register_callback ($ callback, $ stack) e così via, con alcuni stack predefiniti ("caricamento automatico", "arresto", "errore" ...) chiamati da php o dall'utente stesso.

1
ts01

aggiunta di wrapper di oggetti per estensioni utilizzando risorse (curl, ftp, Gd2 ...). Piace

 $oFtp = new Ftp();

 $oFtp->connect();

 $oFtp->close();
1
ts01
  • ambito lessicale per lambdas (usando un'altra parola chiave quindi funzione) (o bloccare la sintassi per creare un ambito lessicale adeguato?)
  • rendere richiamabili le lambda nelle proprietà degli oggetti
  • implica sempre un punto e virgola con parentesi graffe lambda
  • cazzo aggiungi use () per le normali funzioni !!
  • tratti
  • capacità di intercettare instanceof/is_a ()
  • generatori
  • apri Eccezione per modifica di runtime
  • una funzione per verificare le interfacce senza implementarla
1
alan blaire

I miei primi due fastidi non hanno a che fare con PHP, ma con le sue convenzioni d'uso implicite.

  1. "L'estensione del nome file" per il codice della libreria (ad esempio PEAR/Horde/Zend/ecc.) Dovrebbe terminare con .phps Anziché .php. Il vantaggio di ciò è che separa chiaramente il codice da eseguire e il codice da includere, oltre che facoltativamente tutto il (tuo) codice è piuttosto leggibile/navigabile dal server. Come bonus, spl_filename_extensions() può essere utilizzato nel tuo caricatore automatico per comodità degli altri.

  2. La convenzione (nei documenti) è che :: È usato sia per i metodi statici che per quelli di istanza, sarei grato se usassero :: Per statici e -> Per esempio cose. Come una buona convenzione ci sarà ancora spazio per errori di interpretazione, ma è almeno più chiaro.

Per citarne alcuni, vorrei anche vedere quanto segue:

  1. Il getDocComment di Reflection * (o forse un'altra variante del nome o dell'argomento) dovrebbe essere più liberale e anche ottenere solo i primi commenti (fino allo spazio) sopra il tipo menzionato. In altre parole: non mi piace il doccomment dettagliato (leggi: line eating) mentre voglio davvero essere in grado di fornire il minimo indispensabile in qualsiasi tipo di commento: //, # o /* ... */.

  2. Elenco di spazi dei nomi usati, ad es. getdefinednamespaces().

  3. Il comportamento delle "costanti indefinite" dovrebbe essere modificabile da una direttiva ini, ad es. una stringa vuota o un errore irreversibile. Tuttavia, non dovrebbe mai essere implicitamente trasformato in una stringa! (è come il; in javascript).

  4. Anche la costante __CLASS__ Dovrebbe funzionare automaticamente in questo modo (chiamata staticamente) stdClass::__CLASS__ == '\stdClass'. In altre parole, invece di fare riferimento a una classe con una stringa, voglio usare una classe e la sua costante magica __CLASS__ Per fare riferimento ad essa. (sì, è un idefisso)

  5. Digitare casting e metodi magici __fromType($instancetype) e __toType($type). Quindi un oggetto può essere castato su un numero intero: $y = (int) $x o su un altro oggetto $y = (BeanWrap) $x. Tuttavia, un'implementazione di questo significa che dei dodici cast disponibili che coprono otto tipi diversi, i nomi di questi cast non possono più essere usati come nomi di classe (ad esempio int, binario, booleano).

1
23JUL

Quando ho visto questa discussione ho pensato che sarebbe stato utile menzionare alcuni articoli in cui mi sono imbattuto.

  1. Una specie di Groovy Groovy? operatore in PHP: http://justafewlines.com/2009/10/groovys-operator-in-php-sort-of/
  2. Migliora le chiusure: http://justafewlines.com/2009/10/whats-wrong-with-php-closures/
1
Alexey Shein

Essere abbastanza saggi da non rompere la compatibilità all'indietro. Ho imparato l'esistenza di goto come parola chiave nel modo più duro, lo stavo usando come nome di metodo, quindi un aggiornamento del mio codice per php 5.3 ha richiesto 2 o 3 ore.

Qualcosa come i ruoli per le classi sarebbe una buona aggiunta al sistema di oggetti. Niente di complicato.

class abc { use xyz::method; use uvw::__all; }

Questo sceglierebbe il metodo dalla classe xyz e tutti i metodi dalla classe uvm.

La chiamata del costruttore dovrebbe essere utilizzabile come oggetto subito dopo la creazione.

new goodie()->youp();
1
giftnuss
  1. Consenti agli scalari di essere trattati come oggetti. Se provo a fare $ scalar-> toLower (); perché mi dici che mi sbaglio? Perché non lanciarlo temporaneamente in qualcosa come un tipo di oggetto "Scalare" e poi passare a "metodo indefinito" (forse non farlo come nullo)?

  2. Rimuovi risorse dallo spazio utenti. PHP ora ha oggetti. Tutto ciò che è una risorsa ora può essere in un wrapper di oggetti che lo nasconde come proprietà privata. Potrebbe essere necessario aggiungere funzionalità per __sleep () e __wakeup (). La maggior parte delle risorse può essere facilmente ricreato in uno stato "simile". Anche se non è possibile, l'oggetto PDO non può essere serializzato: suppongo che lo stesso possa essere fatto con altri oggetti.

  3. Lascia che l'attuale PHP la comunità voti con il loro codice: permettici di ridefinire metodi, classi e funzioni esistenti. Il codice errato marcirà, proprio come fa in Javascript. Permetterà alle persone usando PHP capisce di cosa hanno bisogno invece di dover indovinare tutto il tempo. Le funzioni e le funzionalità utilizzate/sovrascritte più probabilmente devono essere considerate.

    Questo ha anche l'effetto collaterale di coinvolgere la comunità PHP con i problemi UTF (si spera UTF-8). Invece di avere un'impostazione a livello di sistema che attiva o disattiva l'unicode, PHP possono sovrascrivere le funzionalità di cui hanno bisogno solo per la loro applicazione.

  4. Crea _ un separatore di spazio dei nomi implcit. La gente lo usa da PHP5, lascia che le persone costruiscano il loro codice invece di riscriverlo se per PHP 5.3. Non ne conosco la complessità. So che inizialmente si pensa al codice che fa nomi di classe come Zend_Exception: consentitelo, lo sviluppatore dovrà sempre accedervi come Zend_Exception o\Zend\Exception e mai Eccezione. Consideratelo come un nome completo anziché solo parte di uno.

  5. OOP: prendi alcuni suggerimenti da Javascript/Actionscript/Python. I tratti sembrano promettenti, ma cambiare il tipo dinamicamente in fase di esecuzione sarebbe fantastico.

  6. Proprietà: vedo che sono in corso delle discussioni sulle proprietà, per favore implementale in modo dinamico. PHP dovrebbe essere un linguaggio dinamico. Dovremmo essere in grado di definire le proprietà (quasi tutto) in fase di esecuzione.

  7. Considera le costanti come quelle usate per: variabili globali. Classi/Funzioni/Namespace rientrano tutti in questo disegno di legge. Forse quando tutti inizieranno a rendersi conto che sono tutti globali in questo momento ci saranno più idee per risolvere il problema della presenza di così tante variabili/costanti globali.

  8. Compilazione JIT: Javascript può farlo ed essere super veloce. PHP è uno dei pochi dietro a questo.

  9. PHP dovrebbe essere ottimizzato per "Hypertext", ma non esiste un modo semplice per sfuggire all'output in quanto tale. Personalmente, ridefinirei la 'stampa' per fare un htmlspecialchars (). Nel complesso, potrebbe essere solo necessario essere un printh o un eco.

  10. Semplifica php.ini. php.ini è per amministratori di sistema, non per sviluppatori. Rimuovere le incompatibilità dei tag brevi, correggerli o rimuoverli. È fastidioso per gli amministratori di sistema essere in grado di attivare/disattivare le funzionalità della lingua per l'intero sistema. E aggirali quando provi a distribuire software.

  11. Consenti PHP esiste al termine di un ciclo di richiesta (per FastCGI e Apache). Esponilo su un'API. Consenti all'amministratore di sistema di disabilitarlo o limitarlo. (Richiedi al programma php di restituire il controllo) allo spedizioniere entro 10 secondi o perde il suo stato persistente).

  12. Rendi PHP un linguaggio di programmazione generale. <? I tag php sono fastidiosi: rendilo non necessario quando rilevi un! #/...

  13. Abbreviato per la creazione di oggetti {} e array [], Taje uno sguardo a PiHiPi , implementano questo e molti altri zuccheri sintattici semplici.

    14: Consenti a [] di accedere a proprietà e funzioni sugli oggetti. Le funzioni e le classi sono cittadini di prima classe ora, giusto? Rendi [] il modo di fatto (come javascript/actionscript) per accedere dinamicamente agli oggetti sugli oggetti.

  14. Consenti PHP deve essere PHP. Non dovrei imparare C solo per rendere la mia libreria disponibile a livello di sistema in più processi. Lascia che il = PHP la comunità lo capisce di più.

  15. Invece di prendere idee da Java/C, prendine di più da linguaggi dinamici come Javascript, Actionscript e Python. Di seguito sono elencate funzionalità più specifiche.

  16. Errori fatali: perché la maggior parte degli errori non è ancora recuperabile? Adoro l'idea di errori di registrazione in un file di registro (implementato a un livello molto alto). Quello che non mi piace è sempre sentire parlare di una "pagina bianca". Faccio molti controlli e dichiarazioni nel mio codice per evitarli: ma quando qualcuno passa un null invece di un oggetto alla mia funzione, dio vieta che PHP può recuperare da un tale catastrofico senza fare io stesso faccio un is_null (). Certo è un errore, sembra sciocco che la maggior parte delle altre lingue lo definisca un NullReferenceError/Exception che può essere trattato e presentato con più di un semplice schermo bianco.

    Per lo meno, smetti di aggiungere errori fatali. Ho la possibilità di aggiornare molti server che eseguono PHP 5.2, ma non posso: perché non ho tempo di visitare ~ 200 siti su ciascun server per correggere il vecchio codice Meno nuovi errori fatali vengono aggiunti, maggiore è la probabilità di coinvolgere le persone con le nuove versioni di PHP.

    Rimuovi il maggior numero possibile di errori fatali dalla lingua. PHP dovrebbe essere un linguaggio dinamico: perché ogni altra lingua può recuperare dalla maggior parte degli errori PHP considera fatale? I programmatori possono aggirare gli errori, ma non se il il programma muore forzatamente dopo quello che la maggior parte delle lingue considera NullReferenceException.

  17. Rendere ripristinabili le eccezioni. Quindi possiamo più facilmente mescolare eccezioni ed errori.

  18. (Il più dispendioso in termini di tempo e improbabile) Separare la discussione sulla lingua, la discussione API/modulo e la discussione dell'interprete. Non dovrebbero essere così integrati come in questo momento. I problemi con l'interprete attuale dovrebbero essere risolti per ultimi. Pypy/Parrot/JVM supportano tutti più lingue. V8 no, ma è abbastanza veloce che alcuni stanno lavorando per compilare altre lingue in JavaScript per funzionare su V8 ​​e sfruttare le sue capacità.

    Come interprete/runtime/vm, gli obiettivi di sviluppo sono leggermente diversi da una lingua. Con PHP, sembra che siano la stessa cosa. Quindi le persone che provano a sviluppare altri interpreti hanno difficoltà a tenere il passo con le discussioni quando tutte le discussioni sulla progettazione del linguaggio si mescolano con quelle dell'interprete PHP.

    Come interprete, sento che più lingue l'interprete supporta, meglio è. Perché non possiamo avere un <? Python o un <? Javascript o un <? Actionscript. Sono stanco di riscrivere il codice in un'altra lingua, quindi posso usarlo lì. Alcuni stanno già provando a farlo, probabilmente richiederebbe il supporto di altre aree della comunità.

1
Reece45

La mia caratteristica numero uno sarebbe

sovraccarico operatori

A mio avviso, una funzione ricorrente qui richiesta, vale a dire i tipi nativi come oggetti, può essere risolta creando le proprie classi wrapper. Ho sviluppato per i miei progetti un oggetto arrayData, un oggetto stringData, un oggetto intData e così via ... Questo risolve:

  • Digitazione forte: poiché si tratta di classi personalizzate, possono essere applicate
  • Tipo di overload: posso aggiungere tutti i metodi di cui ho bisogno alla mia classe arrayData
  • Conversione del tipo: ciascuna delle mie classi ha -> toArray (), -> toInt (), -> __ toString () e così via
  • escape HTML nei template (le stringhe sono la classe userStringData che estende la classe stringData).
  • i valori vengono sempre passati per riferimento se non diversamente indicato
  • la creazione di un intData ('stringa') genera un'eccezione.
  • ecc. (l'elenco dei vantaggi è ancora estremamente lungo)

Imho, questo è più vantaggioso dei tipi nativi come oggetti, poiché puoi avere il numero esatto di metodi di cui hai bisogno e chiamarli a tuo piacimento.

Ma ciò che mi manca così tanto è la capacità di utilizzare operatori nativi sui miei oggetti. Sono in grado di utilizzare l'operatore [] grazie a arrayAccess. Ma non posso usare "+", "-", ecc. Se potessi, allora potrei fare stringData + stringData (equivalente a $ string. $ String) o stringData-stringData (equivalente a str_replace ($ str, ' ', $ string)) o confronta i miei tipi con ">" e "<=" ...
La mia attuale implementazione utilizza $ intData-> add ($ n), $ intData-> substract ($ n) e così via. Ingombrante, specialmente nelle funzioni in cui ci si potrebbe aspettare un int nativo o un oggetto intData. Ciò significa che devo verificare con instanceOf all'interno di ciascuna funzione.

In altre parole, sebbene le mie lezioni siano pronte, ottimizzate e carine, fino a quando non riesco a sovraccaricare gli operatori, non sono altro che una prova di concetto. Usarli in un progetto reale è fastidioso.

0
Xananax

Esporre il conteggio dei riferimenti zval. (Sì, potremmo usare xdebug_debug_zval , ma abilitando Xdebug su un sito live, ecc.) Caso d'uso: archivio oggetti record attivo - hai modelli che corrispondono a risorse esterne (come le file del database), e sono responsabile della modifica di tali risorse. Avere due rappresentazioni di oggetti separate per la stessa risorsa sarebbe negativo (perdita di dati a causa di scritture in conflitto e così via), quindi abbiamo bisogno di una sorta di cache che possa restituire il modello per la risorsa richiesta se è già stata caricata. Ciò ucciderebbe la garbage collection, tuttavia: un ultimo riferimento all'oggetto modello rimarrebbe sempre nella cache, quindi iterando attraverso un ampio set di risorse come una query DB di grandi dimensioni o una directory di grandi dimensioni si esaurirebbe rapidamente la memoria. Ciò potrebbe essere evitato se si potesse verificare l'archivio oggetti se esiste un solo riferimento all'oggetto memorizzato (l'archivio stesso) e, in tal caso, distruggerlo.

0
Tgr

Ho bisogno di alcune funzionalità di Erlang in PHP:

  • caricamento codice a caldo
  • atomi
  • pattern matching (include nome delle funzioni, istruzione corrispondente come: case of)

Lavorare con bytecode: salvataggio, caricamento, rimozione e così via ...

Sistema di inclusione flessibile

0
Dan

Mi piacciono i progressi e la scalabilità di php negli ultimi giorni.

Le nuove funzionalità introdotte in Java hanno solo reso le cose complesse piuttosto che renderle semplici.

richiesta 1: funzione db-connection-pool come libreria aggiuntiva.

richiesta 2:

Sto chiedendo la programmazione ajax inversa o la cometa o la funzione RTMP come libreria integrata, che sono già state sviluppate per .net, Java, python e Perl di dojo foundation

Abbiamo cose simili in php ma non una soluzione completa.

  1. Inoltre c'è il supporto per il modello di osservatore in SPL. ma non adeguatamente documentato.
  2. Xajax framework (buono ma richiede riprogettazione dell'applicazione)

arrivederci.

0
Shashank

poche cose che renderebbero la mia giornata

  • Convenzioni di denominazione sensate per funzioni integrate.
  • Digitare suggerimenti per stringhe e numeri
  • Suggerimenti sul tipo di ritorno
  • E_STRICT attivo per impostazione predefinita
  • Tratti, mixin ed eredità multipla
  • Tutto è un oggetto (cioè una purezza simile al rubino)
  • Aggiungi :: supporto agli spazi dei nomi
  • Migliore supporto per windows
  • Test fuori dalla scatola
  • Migliore documentazione per i underworkings di exec ()
  • Riprogettazione di php.net con live-search
  • Xdebug come funzionalità pronta all'uso
  • Miglioramento di PEAR portabilità - gli utenti di Ruby gemme dovrebbero sapere
0
Grayson

Mi piacerebbe davvero avere delle annotazioni ... dopo che RFC è stato abbandonato.

0
crystal88_
  • Supporto UTF-8
  • Rendi la lingua completamente OO, prendendo in prestito il Ruby e Python concetto che tutto è un oggetto. Mi è piaciuto un po 'il rfc di autoboxing. Tuttavia, dà troppa libertà per gli sviluppatori, il che non va bene, ma con alcune limitazioni potrebbe essere una bella aggiunta all'evoluzione del linguaggio.

$ x = array (5, 60, 50, 50); $ x-> map (funzione ($ i) {return $ i * 2;}) -> Push (10);

$ p = "una stringa"; $ q = $ p-> sottostringa (0, 10);

eccetera.

A mio avviso, ciò può essere fatto senza interrompere le attuali funzioni globali. Tuttavia, molti di loro diventeranno inutili e potrebbero essere deprecati nel tempo.

  • Una breve notazione per array sarebbe piacevole, ma non è fondamentale per la lingua.
0
Josh Scott

Sarebbe bello poter usare una classe che estende iterabile in un ciclo foreach, dove si passa un riferimento al ciclo:

 foreach (& $ myclass as $ me) {
 echo $ me; 
} 

Non ho trascorso molto tempo a capire perché al momento non funziona, forse è correlato a come funzionano gli iterabili, non ho studiato molto di più che notare che non funziona.

0
gabe.

Chiamata più veloce della funzione

Abbiamo call_user_func($f,$a1,$aN), ma è stato sostituito con $f($a1,$aN). Tuttavia, non esiste una cosa del genere per call_user_func_array($f,$args).

La mia proposta è di creare una sintassi linguistica specifica per questo, come $f{$args}. Il motivo per cui tutti dovrebbero stare a un miglio di distanza da call_user_func* È che sono estremamente lenti e brutti nel senso che esistono alternative migliori.

Sintassi di declerazione degli oggetti

In questo momento, per creare un oggetto al volo, è necessario: (object)array('prop'=>'value');. Per convenzione, dovremmo anche avere object('prop'=>'value');. Inoltre, potrebbero essere utili sintassi brevi, simili a JSON.

n metodo magico per tutti i tipi

In questo momento, abbiamo __toString(), e molti hanno suggerito __toInt/__toFloat/Etc. Il mio consiglio sarebbe di implementare __toType() o __typecast(), che come primo parametro viene passato il tipo di dati desiderato, ad es .:

class Test {
    public function __toType($type){
        switch($type){
            case 'integer':
                return (int)$this->age;
            case 'string':
                return $this->age.' years';
            default:
                throw new EUnsupportedTypeException();
        }
    }
}

Se volessimo essere più specifici, potremmo aggiungere un altro argomento dopo $ type, ovvero $ class. Quindi puoi: if($class=='person')return new Person($this->age);

Specifica del tipo di dati in foreach

Attualmente, è possibile specificare il tipo di dati di un PHP, in questo modo:

public function say_hello_to(UserClass $user){
    $this->say('Hello, '.$user->name.'!');
}

Sarebbe bello farlo anche in una foreach:

public function on_enter_office(){
    foreach($users as UserClass $user) // <- See UserClass here?
        $user>say_hello_to($this);
}

L'attuale "correzione" sta usando una chiusura, in questo modo:

public function on_enter_office(){
    $users->each(function(UserClass $user){
        $user>say_hello_to($this);
    });
}

La correzione richiede più risorse, più scrittura e rovina l'ambito, quindi perché una soluzione nativa lo renderà più facile, più pulito e probabilmente più veloce della correzione corrente.

Defintions condizionali

Questa probabilmente non sarà una funzionalità utile per molte persone, ma è un ottimo modo per mantenere il codice in esecuzione al minimo anche quando è compatibile con i vecchi sistemi, rendendo l'esecuzione più veloce. Considera il seguente codice:

if (! function_exists ('json_encode')) {function json_encode ($ value, $ options = 0) {// codice legacy}}

  • La sezione // legacy code È ancora analizzata, quindi qualsiasi errore in essa causerà la chiusura di PHP.
  • L'analisi rende anche PHP più lento, anche se non ne ha affatto bisogno.
  • Il codice non è intuitivo per gli sviluppatori
  • Any IDE i motori di analisi verranno confusi poiché ignorano le istruzioni if ​​e finiscono per elencare la funzione due volte.

La correzione? Compilazione condizionale:

#if PHP_VERSION<5.2
function json_encode($value, $options=0){
    // legacy code
}
#endif
0
Christian

include un migliore supporto per i collegamenti ipertestuali, ovvero un metodo funzione/classe che può essere utilizzato per modificare l'uri corrente del browser. o per crearne uno completamente nuovo. utilizzando $ _SERVER ['REQUEST_URI'] || $ _SERVER ['PATH_INFO'] per comprendere la risorsa richiesta. Ciò potrebbe rendere più semplice lo sviluppo di app REST. (secondo UriScheme di rfc e la sua implementazione dello schema predefinito, forse rendere possibile l'implementazione di altri UriSchemes estendendo l'UriBase)

Fornire qualcosa di simile a una classe UriResource, che consente di richiedere piccoli frammenti di funzionalità in un modo che possa trarre vantaggio anche dalle richieste http da parte di un client.

Crea una funzione che può essere chiamata prima e dopo un modello, abilitando i tag brevi tra quelle due chiamate di funzione. Tra queste chiamate di funzione le uniche variabili rese disponibili sono quelle passate alla prima chiamata di funzione (come array associativo (usando extract)). Ciò potrebbe facilitare lo sviluppo di modelli in php stesso (no-framework framework). Il no-framework PHP MVC framework

Tutto sommato, penso che i molti framework php là fuori abbiano alcune somiglianze che potrebbero essere facilmente integrati in php in modo comune.

ma whoami :)

0
immeëmosol
  1. Oggetti a valore immutabile
  2. Classi anonime e/o classi come oggetti
  3. Oggetto incorporato equivalente al tipo di dati stringa (menzionato in precedenza)
  4. Annotazioni o decoratori simili a Python
  5. Oggetti Singleton come alla Scala
  6. Errori predefiniti come eccezioni (menzionati in precedenza)
  7. Supporto UTF8
  8. Rimozione globale ecc
  9. Principio di accesso unificato - un modo per chiamare metodi di oggetto e manipolare proprietà (vedi Scala)
0
sokzzuka