Quais recursos você gostaria de ter em PHP? [fechadas]

Como agora é a temporada de festas e todo mundo está fazendo pedidos, eu me pergunto - quais recursos de linguagem você gostaria que o PHP tivesse adicionado? Estou interessado em algumas sugestões / desejos práticos para o idioma. Por prática, quero dizer:

1. Algo que pode ser feito na prática (não: "Gostaria que o PHP adivinhasse o que meu código significa e corrigisse bugs para mim" ou "Gostaria que qualquer código fosse executado em menos de 5 ms")
2. Algo que não requer a mudança do PHP para outra linguagem (não: "Eu gostaria que eles deixassem sinais $ e usassem espaço em vez de chaves" ou "Eu gostaria que o PHP fosse compilado, digitado estaticamente e tivesse # em seu nome")
3. Algo que não exigiria a quebra de todo o código existente (não: "Vamos renomear 500 funções e alterar a ordem dos parâmetros para elas")
4. Algo que faz alterar o idioma ou algum aspecto interessante do que (não: "Eu gostaria que houvesse extensão do suporte para o protocolo XYZ" ou "Desejo bug # 12345 foram finalmente fixo")
5. Algo que é mais do que um discurso retórico (não: "Eu gostaria que o PHP não fosse tão ruim")

Alguém tem bons desejos?

Mod Edit: Stanislav Malyshev é um desenvolvedor de PHP básico.

Eu não me importaria com parâmetros nomeados.

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

Infelizmente, os desenvolvedores do PHP já derrubaram essa idéia .

Mais desreferenciamento:

echo something_that_returns_array()[4];

Outros mencionaram parâmetros nomeados e sintaxe de matriz mais curta. Eu não me importaria com sintaxe de objeto mais curta também.

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

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

Depois de trabalhar com PHP por cerca de 13 anos, e pesadamente com JS por cerca de 4, há algumas coisas que acho que o PHP faria bem em pegar emprestado do JS:

1) notação abreviada de Arrays e Objetos. Acredito que isso possa ter sido discutido e abatido no Internals (pelo que ouvi dizer - não gosto de ver como a lingüiça é feita), mas realmente acho que a notação literal para matrizes e objetos em JS é uma grande vitória na produtividade.

Por exemplo:

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

É (IMHO) apenas muito mais fácil de escrever e mais limpo do que

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

Ouvi dizer que surgiram algumas preocupações sobre possíveis confusões, mas, na verdade, isso é mais confuso do que, digamos, a notação heredoc? Pelo menos, criar um objeto stdClass no PHP é detalhado o suficiente para desencorajar a prática, eu acho.

2) Ser capaz de redefinir funções e métodos definidos anteriormente seria realmente útil. Em particular, simplificaria situações que estendem uma classe e instanciar a nova classe é excessivamente complexa ou impraticável. Eu acho que devemos evitar a redefinição de funções e métodos essenciais / não-espaço no usuário.

Além desses dois, acho que o PHP deve suportar transparentemente o unicode . Isso está se tornando cada vez mais um problema para os desenvolvedores, e as soluções atualmente oferecidas no PHP são confusas e freqüentemente não são de bom desempenho. Tornar todas as funcionalidades padrão de cordas compatíveis com unicode fora da caixa seria uma grande vitória para os programadores de PHP.

Obrigado por perguntar!

Coisas que eu gostaria, como ex-apologista de longa data do PHP:

1. Sintaxe mais curta para matrizes. As matrizes PHP são um dos recursos mais impressionantes da linguagem devido à sua flexibilidade, mas é um problema para escrever some_array_method($argity, array('key' => $value));. Acredito que essa proposta já tenha sido eviscerada na lista de discussão do PHP, infelizmente.
2. finally Apoio, suporte
3. Atributos / anotações. Isso permite adicionar comportamento personalizado a um método de maneira a permitir a reutilização de código. Por exemplo, em uma estrutura MVC, pode-se definir um AuthorizeAttributeque indique que um controlador ou método de ação exige que o usuário seja autorizado. A estrutura em si seria responsável por procurar os atributos e agir de acordo com eles. Eu acredito que o PHPUnit já usa um tipo de atributo colocando-os nos comentários do docblock, que podem ser lidos usando reflexão, mas colocar a funcionalidade real nos comentários do docblock certamente é um hack.
4. Sintaxe lambda mais curta. Em vez de ter que escrever function($x){ return $x*2;}, talvez eu pudesse escrever $x => return $x*2, ou algo assim. Novamente, isso é algo que dificulta o uso desse recurso. Por exemplo, $results = array_filter(array(1,2,3), function($a) { return $a % 2; }):vs $results = array_filter(array(1,2,3), $a => return $a % 2 );O primeiro tem muito mais encanamento, que é basicamente irrelevante para o trabalho real que você está tentando realizar.
5. Uma Decimalmatemática interna (ponto fixo) que suporta operações matemáticas por meio dos operadores normais seria bem legal, já que não temos sobrecarga de operador.
6. MÉTODOS MÁGICOS DO MOAR. Métodos mágicos são ótimos. Eu pude ver o PHP adicionando sobrecarga de operador por meio de métodos mágicos (eu sei que isso nunca acontecerá basicamente.) Mas, em geral, eles oferecem ótimas maneiras de se conectar à linguagem e fazer coisas legais.

Torne o PHP verdadeiramente orientado a objetos. A slap on another global functionevolução do PHP precisa terminar.

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

É difícil para mim ler. Eu tenho que fazer minha própria pilha mental e meio que compilá-la. Basicamente, ele deve ler no verso. $dog->wakeup()->bark();é fácil de ler em comparação combark(wakeup($dog))

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

Você deu o passo para habilitar o suporte a objetos / métodos agora, use-o nas funções principais do PHP.

Vamos renomear 500 funções e alterar a ordem dos parâmetros para elas.

Mudar essa funcionalidade para métodos permitiria que eles fossem renomeados usando alguns de forma consistente. Quebraria alguma compatibilidade com versões anteriores se strings e matrizes tivessem seus próprios métodos?

Um mecanismo de consulta integrado à linguagem seria ótimo. Mais ou menos como o que está disponível no .NET chamado LINQ. Isso ajudaria a classificar arrays maciços de dados e padronizar o acesso ao banco de dados, para que menos ataques de injeção de SQL tenham êxito.

Oh. Digite dicas para primitivas. Isso seria legal.

Eu realmente desejo um melhor suporte unicode pronto para uso. A maioria das linguagens se move nessa direção, mas o PHP ainda tem comandos estranhos espalhados por toda parte.

Strings PHP são apenas matrizes simples de bytes. Seu conteúdo não é portátil, pois depende da codificação padrão atual.

O mesmo se aplica à representação criada por serialize. Ele contém uma representação de bytes com prefixo de comprimento da cadeia de caracteres sem armazenar realmente nenhuma informação de codificação.

A maioria das funções PHP (string) não tem idéia sobre Unicode. Para obter uma lista detalhada incluindo o nível de risco de cada função, consulte: http://www.phpwact.org/php/i18n/utf-8

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

Crie strings como objetos, com métodos internos para substituir os que não são objetos com nome e parâmetro inconsistentes. por exemplo

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

etc.

Edit: mais uma coisa: Esses métodos sempre devem esperar e emitir UTF-8, exceto aqueles especificamente destinados a lidar com codificações. Se a entrada for UTF-8 inválida, uma exceção deve ser lançada, mesmo que a saída da função não seja afetada pela codificação.

1) Gostaria que objetos recém-instanciados retornassem "$ this" para que eu possa usar o método chain, $ user = new User ('john') -> setLastName ('Doe') -> save ();

2) Se você já usou o ruby ​​e, mais recentemente, o nó, eles têm um ótimo shell interativo (IRB). Eu adoraria que o PHP tivesse um que fosse realmente útil.

3) Traits / Mixins, mas ouvi dizer que estão a caminho.

4) Eu quero a segunda matriz curta $ myArray = ['my', 'array'];

5) Nomenclatura / ordem consistente (ou seja, palheiro de agulhas)

1) por favor, livre-se do includes (). As referências a outros arquivos devem ser referências e, na verdade, não colocar o conteúdo de um arquivo de código-fonte em outro. Muitos programadores PHP usam o include () como um tipo de chamada de função e não como um meio de referenciar uma biblioteca. Isso leva a todos os tipos de ambiguidade no estado variável e no código instável. Substitua por um comando 'use' semelhante ao Perl.

2) forneça um fora da caixa método de compilação de um aplicativo PHP em um único arquivo bytecode distribuível ou executável. Isso aumentará bastante o apelo do PHP como uma linguagem de desenvolvimento comercial. Este deve ser um componente básico da linguagem. Não se preocupe com os arquivos html usados ​​na GUI de um aplicativo, porque ...

3) libere a capacidade de incorporar tags PHP em HTML. Ou, pelo menos, forneça um modo "sem incorporação". Essa é uma bagunça absoluta e incentiva o mau design, misturando a lógica e a apresentação do aplicativo. Os desenvolvedores devem usar modelos para exibição e não bater arquivos PHP juntos e esperar o melhor.

Assinado,

GrandmasterB

ps: não escute o que os outros dizem aqui, fui legal o ano todo

Uma diretiva ini para E_ERRORconstantes indefinidas, em vez de assumir que é uma string E_NOTICE.

Normalize o espaço para nome global com uma convenção de nomenclatura bem pensada que faça sentido para os novatos!

Para citar nosso amado Jeff Atwood: PHP é péssimo, mas não importa !

Strings devem ser objetos

1) Sintaxe mais curta de matriz / objeto, como JavaScript (como mencionado anteriormente)

2) Permitir que constvariáveis ​​permitam o resultado de um cálculo como o define()faz.

3) Encadeamento diretamente do construtor: new User()->name('Ryan');

4) Desreferenciamento de matriz: something_that_returns_array()[4];

5) Suporte expandido a SPL. O SPL faz um trabalho decente ao reimaginar funções de string e array (entre outras coisas) como objetos. A expansão do SPL poderia resolver muitas queixas sobre o idioma ser tão superficial.

6) O uso ArrayObject()deve ser tão transparente quanto o uso array(). Você deve ser capaz de fazer coisas como array_filter($array_object_instance)sem fazer array_filter($array_object_instance->getArrayCopy()). Melhor ainda, é claro, seria $array_object_instance->filter().

7) Unicode completo seria bom.

8) Pare de fazer conversões de tipo automáticas estranhas. Por exemplo, você não deve conseguir echoum objeto SimpleXMLElement sem primeiro digitá-lo explicitamente como uma string. Ou pelo menos, jogue alguma coisa quando isso acontecer (por exemplo, no modo estrito, ou seja o que error_reporting(-1)for).

9) Suporte para vários threads ou algum tipo de retorno de chamada assíncrono / evento. Isso é mais importante ao tentar fazer upload de arquivos grandes via cURL. Em vez de tópicos antigos, algo como o Grand Central Dispatch da Apple seria bom. Ou até algo semelhante ao JavaScript, onde você pode fazer solicitações assíncronas e definir retornos de chamada.

10) Nomenclatura / ordem consistente (ou seja, palheiro de agulhas) seria bom, mas acho que isso poderia ser melhor resolvido com o SPL.

11) Um shell PHP interativo com suporte oficial, como o IRB. O Facebook tem um chamado phpshque foi escrito em Python, mas falta o polonês que eu gostaria de ver.

12) Para a API do Reflection, adicione suporte para (a) comentários do docblock em constantes (global e classe) e (b) suporte para analisar comentários semelhantes ao PHPDoc em uma estrutura de dados sensível. Há um pacote PECL chamado "docblock" que tenta fazer isso, mas não parece que o autor tenha ido muito longe.

Edição: 13) Eu também adoraria ver a capacidade de usar !e ?em nomes de funções - como Ruby pode.

1) Compreensão de matrizes no estilo de compreensão de lista Python:

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

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

2) Sintaxe de matriz curta

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

3) Tornar vazio () não considerar a sequência '0' como verdadeira

Eu gostaria de ver um método legítimo de criar / definir matrizes CONSTANT. Existem algumas maneiras imprudentes de simular esse tipo de funcionalidade, mas seria bom se fosse apenas um recurso direto do PHP. Seria bom se você pudesse criar uma matriz de maneira semelhante à declaração "final" do Java.

Eu criei um sistema de login que é muito rápido de configurar. Tudo o que você precisa fazer é alterar o conteúdo de uma matriz em um arquivo de texto para especificar os campos que você deseja obter informações do usuário. Utilizando uma variedade de loops, ele lida com tudo, desde geração de formulários e sensibilização de entrada até chamadas de banco de dados, mas tudo depende dessa matriz original.

O arquivo com a matriz é bloqueado com permissões, mas uma vez que a matriz está se movendo no éter, é mutável. Embora eu sinta que o sistema é bastante seguro, não gosto de deixar nada ao acaso. Um método para finalizar matrizes seria bom para uma situação como essa.

Nova ideia!!

Ohhh, pensei em outra coisa que eu realmente gostaria em php. Gostaria de algum tipo de sistema para controlar operações de arquivos php e operações de diretório semelhantes à maneira como o .htaccess funciona.

O arquivo .phpaccess deve acionar algum tipo de mesmo domínio / mesma política de origem.

Por exemplo, se eu estivesse hospedando muitos sites com hosts virtuais, poderia ter um arquivo .phpaccess em um diretório que instruiria o php a verificar a organização de todos os scripts em execução que estão tentando operar no meu diretório protegido. Se o script não vier desse diretório ou de seus subdiretórios, as operações de arquivo / ou operações de soquete serão negadas.

Eu acho que um sistema como esse tornaria a hospedagem virtual um ambiente muito mais seguro. Se você pudesse colocar uma delas na parte superior de cada host virtual, isso diminuiria a chance de alguém encontrar uma maneira de se infiltrar em um host virtual vizinho.

Além disso, se seria bom ter um método de protegê-lo no sentido inverso dessa maneira. ou seja, restringindo o alcance dos scripts em um único diretório para esse diretório.

É o yin e o yang que você sabe!

Meus dois maiores desejos como programador PHP hardcore:

1. Suporte finalmente. É uma grande confusão ficcionalmente contornar isso através de bandeiras ou meios semelhantes.
2. Eu adoraria ver o suporte na sintaxe do C # para getters e setters. Quando você tem muitos getters e setters, uma sintaxe simples, como C #, é um ótimo impulsionador de desempenho, em vez de fazê-lo da maneira Java e escrever métodos getter e setter. Os métodos mágicos são impressionantes nos casos em que você deseja criar membros dinamicamente (por exemplo, se você deseja fornecer algumas variáveis ​​a um representante de modelo para usar), mas não são boas para propriedades normais nas quais você gostaria que o IDE preenchesse automaticamente, conheça tipos e assim por diante. isso ajudaria a tornar o código menor e ainda mais legível e fácil de usar.

Sintaxe da linguagem : Existem algumas dicas boas em pihipi e phpreboot sobre o que os desenvolvedores estão interessados ​​(embora o phpreboot vá muito longe tornando-se JS).

Metodologia de desenvolvimento : Melhoraria muito a vida útil do PHP.net se essas pesquisas fossem realmente levadas em consideração. Não tome mais decisões de sintaxe da sessão do IRC da tarde à toa ou à tarde.

Recursos individuais : alguns já foram mencionados antes, mas felizmente queimarei algum karma para ser mais franco aqui:

• Tipo de seqüência de caracteres Unicode.
• Bigint (consulte Python).
• Runkit interno para remover / renomear / substituir funções e classes internas, que nem sempre são bem projetadas.
• OOP moderno
  • herança múltipla (em vez de complexidade para suportar casos extremos com sintaxe de características desajeitadas)
  • escalares podem dobrar como objetos (consulte Python), por exemplo, array () funciona como ArrayObject ou strings como SplString (precisa de métodos utilizáveis, todas as funções de string devem estar disponíveis como str::toupper())
• Preterir a \sintaxe de namespace de merda , fixar o analisador e adotar ::como alternativa. Você sabe, como uma linguagem real.
• Qualquer variação do LINQ (embora eu não confie em vocês, crie uma sintaxe sensata)
• literais ou XML.
• Livre-se do comportamento do tempo de execução do php.ini e das opções semânticas. Isso tira parte da emoção, é verdade, mas beneficiaria os desenvolvedores e a base de usuários.
• Sim, as magic_quotes ainda não se foram.
• Conversão bytecode do Zend Engine para PBC

Embora isso não seja óbvio, eu financiaria com prazer qualquer outra pessoa para fazer o último e eliminaria o php.net como principal implementação. :P
Ah, acabei de notar, é um wiki da comunidade. Portanto, há uma chance de você não estar realmente aqui pelo karma, mas por um interesse genuíno. Nesse caso, examine a <b> questão </b> que prejudica seriamente a linguagem (directorite).

Eu adoraria ver a unificação de erros e exceções em um único conceito (exceções). É ótimo poder capturar exceções e gravá-las em um log, para encontrar e corrigir erros dessa maneira. Mas se houver algo fundamentalmente errado (leia-se: Erro do PHP) em um caminho de código que raramente é atingido, não há uma boa maneira de canalizar essas informações para o mesmo banco de dados de problemas.

Por favor, Papai Noel, introduza uma opção no php.ini que transforma todos os erros em exceções - idealmente, exceções que eu posso pegar no meu código.

O PHP combina comigo muito bem, pois é para acessar sites pequenos e médios; Devo ser um pouco sem imaginação, a única coisa que eu poderia pensar como resposta a essa pergunta seria algo que a tornasse melhor para sites de alto tráfego.

Estou pensando em termos de geração de processos para outros núcleos, por exemplo, atualizando um banco de dados em um processo enquanto cria a página de saída em outro processo. Uma rápida pesquisa no Google indica que isso pode ser simulado, mas atualmente não é suportado diretamente no php.

Eu realmente senti falta de que os tipos escalares não sejam tratados como objetos, e objetos reais não podem agir como qualquer outro tipo ou objeto (exceto a string devido a __toString ()).

• suporte para enumerações (como java 1.5+)
• Ser capaz de definir tipos de retorno de método, em interfaces e classes
• suporte para definição de anotações / metadados em propriedades e métodos.
• ser capaz de fazer sugestões de tipo estritas para argumentos escalares de métodos.

Limpe "Notas contribuídas pelo usuário" em http://php.net . Eles são uma verdadeira bagunça às vezes, embora sejam um grande valor em geral.

Existem algumas funções de matriz bastante decentes no PHP, fornecendo capacidade de processamento de lista, com retornos de chamada e create_function()fornecendo um cálculo lambda básico.

O principal problema com isso é que, em PHP, é muito detalhado, um sistema de taquigrafia seria excelente, principalmente no que diz respeito aos comandos de mapear / reduzir.

Mais importante, as funções da lista não estão totalmente completas:

• não há foldrfunção, array_reduce()fornecefoldl
• array_map()deve passar a chave no segundo argumento, como array_walk()faz
• um array_map_keys()poderia ser útil para modificação de chave
• compreensão da lista é muito desajeitado, range(), array_fill()e array_fill_keys()apenas lidar com tantos casos, e array_filter()é separado

Não pretendo transformar o PHP no Haskell, mas o PHP é frequentemente usado para manipulação da estrutura de dados do tipo lista e ter um conjunto completo de ferramentas nesse sentido seria útil.

Sobrecarga do operador:

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

Adicione exceções em vez de produzir E_WARNING ... É muito irritante não poder usar algo como:

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

Obviamente, atualmente não é muito prático, mas é muito chato receber:

AVISO

AVISO

AVISO

e não consigo controlar o fluxo de código sem escrever meu próprio error_handler e string sniffing que erro foi produzido (permissão, nome de arquivo incorreto ou qualquer outra coisa; não me importo com outras fontes de erros aqui) para gerar a exceção correta .

Espero não ter que explicar por que é importante.

O PHP tornou-se Orientado a Objetos há um tempo e nós, programadores que usamos PHP, estamos ansiosos por recursos de OO, não apresentando "goto" ... Quando eu descobri que realmente aconteceu, pensei que era o dia da mentira.

1. Consolide o modelo de objeto - faça com que todos os objetos estendam a classe Object básica. A classe Object (entre outras coisas) implementaria todos os métodos mágicos (para que não fossem mais mágicos!)

2. Mova extensões para seus próprios namespaces - organize o namespace global $conn = new \MySQLi\Connection();

3. Desfaça a spl_autoload()função! Sério, esse é possivelmente um dos maiores recursos do PHP e também o mais inútil ao mesmo tempo. spl_autoloadé o carregador automático padrão, que suporta namespaces e várias extensões de arquivo, mas, por algum motivo desconhecido, exige que os nomes dos arquivos sejam minúsculos. Há um relatório de bug preenchido para isso , mas a equipe respondeu que não o corrigirá devido à compatibilidade com versões anteriores. Certo ... não é como todo framework é fornecido com seu próprio carregador automático, já que o padrão está aleijado!

Suporte a arquivos grandes. Bonita por favor?

Veja http://bugs.php.net/bug.php?id=27792 (embora possa haver mais áreas / funções que também precisam de atenção).

Traga o suporte ao contaminação para a versão mais recente e inclua-o nas compilações padrão, de preferência ativadas na configuração padrão http://wiki.php.net/rfc/taint

Isso impediria ataques de injeção XSS e SQL, fazendo com que as pessoas codificassem corretamente.