<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
    <head>
        <title>NetBeans IDE - Desenvolvimento em PHP</title>
        <link rel="stylesheet" href="../../netbeans.css" type="text/css">
        <link rel="stylesheet" type="text/css" href="../../features.css">
        <meta name="description" content="NetBeans IDE - Integrated Tools for PHP Developers">
        <meta http-equiv="content-language" content="en">
        <meta name="author" content="Ruth Kusterer">
    <meta HTTP-EQUIV="Content-Type" Content="text/html; charset=UTF-8"></head>
    <body>
        <h1>Desenvolvimento em PHP</h1>
        <p class="xintro"> 
            <img alt="Desenvolvimento PHP no NetBeans IDE" class="box" src="../../images_www/v7/3/features/php/php-ide_top.png"><br>
        </p>
        <p class="intro">Um ambiente de codificação PHP dedicado e uma integração completa com padrões Web, com suporte completo ao desenvolvimento HTML5, JavaScript e CSS3, conforme descrito na página <a href="../html5/index.html">Suporte ao Desenvolvimento Web HTML5</a>.</p>

        <span class="overview-right" id="im2"><img src="/images_www/v7/3/features/php/php-code-completion_small.png"></span>
        
        <h2>Editor de Código-Fonte de PHP Avançado</h2>
        
        <p> O editor PHP do NetBeans fornece modelos de código e ferramentas de geração de código, como geração de "getter e setter", refatoração, "renomeação instantânea", dicas de ferramentas de parâmetros, dicas e correções rápidas e i recurso autocompletar código inteligente.
        </p> 
        
        <p>Benefício do código sintático e semântico, destacando documentação pop-up e formatação e dobramento do código, marcando pontos de saída e ocorrências, funcionalidade autocompletar código try/catch inteligente, preenchimento de parâmetro do método inteligente e seleção retangular.
        </p>
        
        <div class="line">&nbsp;</div>
        <span id="im1" class="overview-left"><img src="/images_www/v7/3/features/php/php-54-traitcc_small.png"></span>    
        <h2>Suporte a PHP 5.4 </h2>
        <p>O NetBeans IDE para PHP 7.3 oferece várias funcionalidades específicas para serem desenvolvidas com PHP 5.4. Você pode configurar seu projeto PHP 5.4 para ser executado no <a href="https://blogs.oracle.com/netbeansphp/entry/php_5_4_support_built">servidor web incorporado</a> no PHP 5.4. O recurso autocompletar do PHP de IDE suporta estilos de array de PHP 5.4, como <a href="https://blogs.oracle.com/netbeansphp/entry/php_5_4_support_array">cancelamento da referência de array</a> e <a href="https://blogs.oracle.com/netbeansphp/entry/php_5_4_support_short">sintaxe curta de array</a>. O NetBeans IDE também reconhece <a href="https://blogs.oracle.com/netbeansphp/entry/php_5_4_support_traits">Características</a> e <a href="https://blogs.oracle.com/netbeansphp/entry/php_5_4_support_anonymous">variáveis de objeto anônimo</a> (também chamadas "instanciação fluente"). Finalmente, o NetBeans IDE para PHP 7.3 inclui <a href="https://blogs.oracle.com/netbeansphp/entry/php_5_4_support_minor">funcionalidades mínimas</a>, como dicas de tipo chamáveis, notação binária de inteiros e chamada de <code>Classe::{expr}()</code>.</p>
    </p>
    <div class="line">&nbsp;</div>
    <span id="im1" class="overview-right"><img src="/images_www/v7/3/features/php/frameworks.png"></span>
    <h2>Frameworks Web</h2>
    <p>O NetBeans IDE suporta os seguintes frameworks comuns da Web:
    <ul>
        <li><a href="http://framework.zend.com/">Zend Framework</a> (<a href="https://netbeans.org/kb/docs/php/zend-framework-screencast.html">screencast</a>)</li>
        <li><a href="http://symfony.com/">Framework Symfony2 </a></li>
        <li><a href="http://symfony.com/legacy">Framework Symfony1 </a> (<a href="https://netbeans.org/kb/docs/php/symfony-screencast.html">screencast</a>)</li>
    </ul>
    <p>Crie novos projetos PHP com esses frameworks, execute comandos do framework, navegue dos controladores (ação) para suas views, use anotações do framework e o recurso autocompletar código no editor e personalize suas configurações.</p>
<div class="line">&nbsp;</div>
<span id="im3" class="overview-left"><img src="/images_www/v7/3/features/ide-collaboration-hudson-cut.png"></span>
<h2>Suporte de Integração Contínua </h2>
<p>O NetBeans IDE para PHP tem suporte para integração contínua. Integração contínua é uma prática de desenvolvimento de software que envolve o controle da versão e um servidor especializado. O servidor especializado é executado em testes de Cobertura de Código e PHPUnit no software.</p>
<p>Os resultados de teste são associados com informações de controle de versão, de modo que os desenvolvedores possam identificar de forma rápida e fácil bugs que eles introduzem no software. O IDE usa <a href="http://jenkins-php.org/" target="_blank" title="Modelo do job PHP de Jenkins">Modelo para Jobs de Jenkins para projetos PHP</a>, que deve ser configurado com os plug-ins necessários e ferramentas no servidor de integração.<br /><br /> <a class="arr-link" href="https://netbeans.org/kb/docs/php/screencast-continuous-builds.html">Suporte para PHP em Servidores de Construção Contínua</a></p>
<div class="line">&nbsp;</div>
<span id="im3" class="overview-right"><img src="/images_www/v7/3/features/php/php-project.png"></span>
<h2>Projetos PHP</h2>
<p> O projeto NetBeans oferece uma versão de IDE sob medida para desenvolver sites de PHP que compreende uma variedade de linguagens de marcação e script. O editor PHP é integrado dinamicamente com as funcionalidades de edição de HTML, JavaScript e CSS.</p>
<p> Concentre-se no código e agilize a análise do código ao excluir os diretórios individuais nas propriedades do Projeto. O NetBeans IDE é totalmente compatível com o desenvolvimento interativo, portanto o teste de projetos PHP segue os padrões clássicos familiares para desenvolvedores da Web.</p>
<div class="line">&nbsp;</div>
<span id="im3" class="overview-left"><img src="/images_www/v7/3/features/php/php-debugger.png"></span>
<h2>Depurador</h2>
<p>
    Depure código de PHP usando o Xdebug: é possível inspecionar variáveis locais, definir watches, determinar pontos de detenção e avaliar códigos ao vivo. Navegue para declarações, tipos e arquivos usando atalhos Ir para e links de hipertexto. Use um caminho de inclusão de PHP global para todos os projetos ou personalize-o por projeto.
</p><p>
    O NetBeans IDE para PHP também oferece depuração de linhas de comandos: a saída de programa PHP é exibida em uma exibição de linha de comandos no próprio IDE e você pode inspecionar o HTML gerado sem a necessidade de alternar para um browser.
</p><p>
    É possível depurar scripts e páginas Web, tanto local quanto remotamente. A integração do depurador PHP do NetBeans permite mapear os caminhos do servidor para os caminhos locais a fim de ativar a depuração remota.
</p>
<h2>Consulte Também</h2>
<ul class="bigger">
    <li><a href="/community/releases/81/index.html">Página de Release do NetBeans IDE 8.1</a> para obter uma lista de funcionalidades específicas da última versão estável.</li>
    <li><a href="../../kb/trails/php.html">Trilha de Aprendizado de PHP e HTML5</a> para tutoriais que o ajudarão a começar.</li>
</ul>
</body>
</html>
