Meu povo!

Hoje, às 22h, ocorrerá um hangout especial! Hangout com os palestrantes do Seminário PHP – Porto Alegre. Vai ser bem interessante pra galera trocar ideias!

Se você vai ou pretende ir no evento, não pode perder! Falaremos sobre o conteúdo que você encontrará no seminário!

Então não perca a hora! Confirme presença na página do Facebook e fique ligado pois logo será divulgado o link para acesso!

Um abraço a todos e nos vemos lá!
Fiquem com Deus!

O post Hangout com os palestrantes do Seminário PHP – Porto Alegre apareceu primeiro em PHPit.

Galera!

Pra quem não viu, na noite/madrugada passada ocorreu o primeiro Hangout da CodeSquad. Falamos sobre Carreira de Programadores PHP.

Houve mais de 300 pessoas confirmando presença no site do evento no Facebook e momentos em que havia mais de mais de 150 pessoas assistindo a transmissão ao vivo.

Sem dúvidas foi uma excelente troca de experiências em um hangout que contou com o idealizador Elton Minetto, Kinn Coelho Julião, Fábio Vedovelli, Silvano Girardi Jr., Alexandre “Taz” Dos Santos Andrade e este que vos fala.

Mas o hangout não teria sido esse sucesso se não fosse as mais de 100 pessoas que participaram contribuindo com suas dúvidas e sugestões.

Se você perdeu a transmissão pode assistir no vídeo:

Os slides que o Minetto tentou mostrar apresentou, estão no SpeakerDeck.

Se você se interessou pela carreira PHP, não esqueça de se cadastrar no Carreiras Code Squad para receber as novidades sobre os cursos que eles estão preparando.

Um abraço a todos e fiquem com Deus!

O post Hangout – Carreira PHP apareceu primeiro em PHPit.

Se você tem andado próximo à cena PHP, deve ter visto todo o alarde criado em volta do framework Laravel.

Neste artigo vou tentar ser bem prático, falar sobre as primeiras impressões e como iniciar os trabalhos!

Instalando o Laravel

Uma coisa bacana de frameworks como o CodeIgniter é que você apenas joga os arquivos dele em um diretório que o servidor web conheça e estamos prontos. As únicas configurações que precisam ser feita são referentes ao banco de dados, informações básicas do seu site (url, mod_rewrite, etc) e quais recursos devem ser carregados automaticamente.

A desvantagem dessa simplicidade, é que todos os arquivos do framework acabam ficando em um diretório acessível publicamente. Você pode muda isso, mas vai te custar alguns passos a mais. Isso não ocorre no Ruby on Rails ou em frameworks PHP como o Zend, pois possuem um diretório public tão logo você cria a sua aplicação. E o Laravel? Sim, possui um diretório público também! Então quando você cria ou seu domínio local (ou virtual), você deve ter certeza de que está apontando para o diretório público:

Existem algumas permissões para modificar também. Você precisa dar permissão de escrita para /storage/views. Além disso, não há muito o que fazer nesse estágio. Estamos próximos a botar pra funcionar no nosso navegador.

Até agora nós já baixamos o código, despejamos em um diretório habilitado na web, criamos um domínio local, alteramos a permissão de um diretório e estamos prontos! Parece tranquilo, não?

Entretanto, ainda precisamos fazer mais algumas coisinhas. Primeiro, abra config/application.php e altere estas opções:

'index' => '',

/*
|--------------------------------------------------------------------------
| Application Key
|--------------------------------------------------------------------------
|
| This key is used by the encryption and cookie classes to generate secure
| encrypted strings and hashes. It is extremely important that this key
| remains secret and it should not be shared with anyone. Make it about 32
| characters of random gibberish.
|
*/

'key' => 'SuaChaveSecretaVaiAqui!',

Você precisa colocar alguma coisa na chave e pode remover o ‘index.php’, assim podemos utilizar URLs mais bonitas. Agora você já pode botar pra rodar o seu navegador e apontar para o domínio local:

Maravilha! Positivo e operante! Mas ainda existe algo que podemos fazer: adicionar um banco de dados. Como os exemplos clássicos sempre falam em criar blogs, caso você vá seguir este caminho, seria interessante adicionar suporte a sessões (por causa da autenticação de usuários). O banco padrão é o MySQL, mas você pode escolher entre muitos outros.

Abra application/config/database.php e adicione os dados de autenticação na seção do MySQL:

'mysql' => array(
 'driver' => 'mysql',
 'host' => '127.0.0.1',
 'database' => 'database',
 'username' => 'root',
 'password' => '',
 'charset' => 'utf8',
 'prefix' => '',
),

Trabalhando com sessões

Os dados de sessão ficam armazenados numa tabela no banco, então precisamos adicioná-la. Também é importante comentar que o Laravel utiliza migrations, que é uma espécie de controle de versão do banco de dados. Se você já trabalhou com Rails, deve saber do que estou falando.

O Laravel vem também com uma ferramenta CLI muito útil, chamada Artisan. Nós precisamos utilizá-la para habilitar nosso banco de dados para acompanhar nossas migrations. Abra o Terminal, navegue até o diretório do projeto e faça o seguinte:

php artisan migrate:install

Você deve ver uma resposta como essa:

Migration table created successfully.

Isso vai criar a tabela de migrations. Agora volte para o terminal e execute o seguinte:

php artisan session:table

O resultado deve ser algo assim:

An application key already exists!
Great! New migration created!
Migrated: application/2013_05_08_213358_create_session_table

E então temos nossa tabela de sessão criada!

Finalmente

Agora já estamos instigados a continuar indo mais fundo no Laravel para entender como realmente funciona! Configurar uma nova aplicação é realmente muito simples e a ferramenta CLI é muito útil!

Espero que tenham conseguido tirar alguma informação útil e que isso possa ajudá-los a explorarem esse novo framework!

Postem comentários com sugestões ou contribuições!

Um abraço e fiquem com Deus!

Texto adaptado do original: http://www.andyhawthorne.co.uk/getting-started-with-laravel-php/

O post Iniciando com Laravel PHP apareceu primeiro em PHPit.

Salve, galera!

Estou aqui para divulgar mais um grande evento de PHP no nosso amado RS!

Tempo Real Eventos e Er Galvão Abbott trazem a Porto Alegre o Seminário PHP: O melhor da PHP Conference Brasil!

Pela primeira vez fora do estado de São Paulo, um evento exclusivíssimo que traz palestras que foram destaque na PHP Conference Brasil 2012!

O evento ocorrerá no sábado, dia 8 de Junho, na UniRitter em Porto Alegre – RS!

Para mais detalhes sobre inscrições e grade de palestras, você pode acessar o site do evento ou então a página no Facebook.

Nos vemos lá!

Um abraço a todos e fiquem com Deus.
Rafael Jaques

O post Seminário PHP em Porto Alegre: O melhor da PHP Conference Brasil apareceu primeiro em PHPit.

Esse post vai mostrar como construir um View Helper básico no Zend Framework 2.

Neste exemplo o nosso helper vai apenas retornar a URL absoluta da página/requisição atual.

<?php
// ./module/Application/src/Application/View/Helper/AbsoluteUrl.php
namespace Application\View\Helper;

use Zend\Http\Request;
use Zend\View\Helper\AbstractHelper;

class AbsoluteUrl extends AbstractHelper
{
    protected $request;

    public function __construct(Request $request)
    {
        $this->request = $request;
    }

    public function __invoke()
    {
        return $this->request->getUri()->normalize();
    }
}

Como você pode perceber, este helper possui uma dependência – um objeto Zend\Http\Request. O Zend Framework 2 possui uma maneira bem simples para injetar as dependências. Nós precisaremos de uma factory com a inicialização lógica para o nosso view helper:

<?php
// ./module/Application/Module.php
namespace Application;

use Application\View\Helper\AbsoluteUrl;

class Module
{
    public function getViewHelperConfig()
    {
        return array(
            'factories' => array(
                // a chave do array aqui é o nome pelo qual você
                // chamará o seu view helper no script da view
                'absoluteUrl' => function($sm) {
                    $locator = $sm->getServiceLocator();

                    // $sm é o gerenciador de view helpers (view
                    // helper manager), então nós precisamos
                    // coletar o gerenciador de serviços principal

                    return new AbsoluteUrl($locator->get('Request'));
                },
            ),
        );
    }

     // Se for copiar/colar esse exemplo, você precisará também
     // do método getAutoloaderConfig(); acabei omitindo para
     // deixar o exemplo mais curto.
}

E é isso! Agora podemos chamar nosso helper nas nossas views:

A URL completa para esta página é: <?php echo $this->absoluteUrl(); ?>

Texto adaptado do original: http://blog.evan.pro/creating-a-simple-view-helper-in-zend-framework-2

O post Criando um View Helper básico no Zend Framework 2 apareceu primeiro em PHPit.

Então você quer aprender Java mas só tem experiência de programação com o PHP? Esse texto é pra você!

Não é segredo pra ninguém que atualmente os profissionais precisam conhecer mais de uma tecnologia. Precisamos estar abertos a novidades e, te prometo, que aprender uma nova linguagem não tira pedaço. Pelo contrário, saber mais de uma linguagem, além de deixar o seu cérebro mais afiado, ainda te dá um currículo mais pesado e maior probabilidade de conseguir um bom emprego.

Como uma das linguagens mais utilizadas para programação Android é o Java, muitos estão tentando assimilá-la ultimamente. Neste artigo tentarei cobrir tudo que alguém que sabe apenas PHP precisaria saber para detonar no Java. Dê uma boa lida no material que segue e responderei algumas questões ao longo do caminho.

Java é uma linguagem fortemente tipada

Talvez você não esteja acostumado com o conceito de “declarar” variáveis. No Java você precisa declará-las antes de utilizar.

DatabaseRecord foo;
foo = new DatabaseRecord();

Na linha 1 declaramos a variável apenas especificando seu tipo (assim podemos nos assegurar de que a variável foo conterá apenas um objeto do tipo DatabaseRecord). Na linha seguinte, criamos um novo objeto DatabaseRecord e o atribuímos a banco. Você também pode fazer isso tudo em uma linha apenas:

DatabaseRecord foo = new DatabaseRecord();

Aqui quando foo é declarada, qualquer valor que for atribuído a esta variável deve ser do tipo DatabaseRecord. E daqui em diante, você só poderá atribuir valores do tipo DatabaseRecord para a variável foo, enquanto no Mundo do PHP você poderia colocar uma string em uma variável na qual havia um objeto apenas alguns segundos atrás.

Então, o código PHP a seguir é válido:

$foo = new Bar();
$foo = "Bla bla bla";

Mas o equivalente não é válido em Java:

DatabaseRecord foo = new DatabaseRecord();
foo = "Bla bla bla";

Até métodos precisam ter o tipo do retorno especificado:

Em PHP:

class myClass {
    public function getName() {
        return "Rafa Jaques";
    }
}

Em Java:

class myClass {
    public String getName() {
        return "Rafa Jaques";
    }
}

É importante perceber que você não deve especificar que é uma função. Para funções que não retornam nenhum valor ou retornam apenas com “return;”, utilize void no lugar de String.

Propriedades do objeto são chamadas de fields

No PHP os objetos possuem propriedades:

class myClass {
    public $foo = 'bar';
    protected $_bar = 'baz';
}

Em Java existem fields (campos). A sintaxe é similar e você precisa especificar um tipo para cada field.

class myClass {
    public String mFoo = 'bar';
    protected String mBar = 'baz';
}

Uma convenção que eu vi nos códigos de exemplo pra Android foi preceder cada um desses fields com a letra ‘m’ (de ‘Member Field’). Eu achei bem útil para identificar quais variáveis são fields do atual objeto, especialmente se você levar em conta o próximo ponto.

Você não utiliza this muito frequentemente

Quando estiver acessando propriedades no Java, você não utiliza $this.

No PHP você faria:

class myClass {
    protected $_bar = 'baz';

    public function getBar() {
        return $this->_bar;
    }
}

No java não é obrigatório usar o this para esses casos.

class myClass {
    protected String mBar = 'baz';

    public String getBar() {
        return mBar;
    }
}

A única vez que você realmente precisa do this é quando ocorre uma colisão de nomes e acaba não ficando muito claro qual variável você está referenciando. Vejamos um exemplo:

Em Java:

class myClass {
    protected String mBar = 'baz';

    public String getBar(String mBar) {
        return this.mBar; // especifique o "this" para acessar o field mBar
                          // em vez do mBar que foi passado como parâmetro
                          // para o método
    }
}

Annotations (ex.: @override)

Quando você começar a sobrecarregar métodos, perceberá um @override antecedendo os métodos que são sobrescritos (geralmente a IDE coloca isso lá).

Essas anotações servem para fazer Reflection (falarei mais sobre isso a seguir). Como é um assunto bastante extenso, não vou explicar em detalhes o que é aqui, mas deixo um link para que você possa aprofundar seus estudos sobre annotations e reflection.

Você pode criar as annotations que quiser por qualquer motivo que der na telha e depois acessar annotations de um método específico usando reflection.

Aqui está um exemplo da utilização de annotations:

class MyActivity extends Activity {
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        return super.onCreateOptionsMenu(menu);
    }
}

Reflection – “O que é Object.class?”

Cada classe que você declara essencialmente estende a classe Objeto. Essa classe lhe dará um punhado de métodos e fields padrão. Um deles é o membro estático acessado via NomeDaClasse.class cujo o objetivo é retornar o objeto Classe.

Esse objeto classe descreve seu objeto e possui vários métodos para explorá-lo. Por exemplo: você pode utilizá-lo para verificar quais annotations um método possui, ou pode também passar informações para que outro método saiba qual classe criar.

Você deve ver algo parecido com isso:

String someObject = "Uma string";
Intent i = new Intent(someObject, MyActivity.class)

Esse código cria um novo objeto Intent, passando um objeto string e depois passando um objeto Classe do field estático MyActivity.class. Por exemplo: internamente o objeto Intent pode utilizar o objeto Classe para criar um novo objeto MyActivity pois o objeto dessa classe possui um método newInstance().

Parênteses angulares genéricos em Java

Se por acaso você ver algo do tipo, poderá ficar um pouco confuso:

List<Integer> = new LinkedList<Integer>();

São conhecidos como generics e permitem a você indicar ao objeto List que tipo de objeto ele estará armazenando.

Se quiser ler mais sobre generics, recomendo dar uma lida neste link, pois possui um tutorial bem detalhado.

Arrays não são mais a solução

Em Java você não irá achar arrays tão úteis quanto no PHP no qual você pode declarar um array sem especificar tamanho, tipo ou qualquer outra coisa.

Quando criar arrays em Java você precisará especificar o tamanho e só poderá atribuir valores de um mesmo tipo de objeto (tudo string ou tudo integer, por exemplo).

Então em PHP teríamos:

$stringArray = array('Um', 'Dois', 'Três');

Em Java:

String[3] stringArray;
stringArray[0] = "Um";
stringArray[1] = "Dois";
stringArray[2] = "Três";

Perceba que declara-se um array colocando parênteses quadrados (colchetes) contendo o tamanho do array. Então você poderá acessar esses, e apenas esses, três elementos.

Se quiser uma lista de objetos de tamanho não especificado, provavelmente você quer uma lista encadeada: LinkedList. A utilização é como segue:

LinkedList myList = new LinkedList();
myList.add(new MyObject());
myList.add(new MyObject());
myList.add(new MyObject());

Esse snippet adiciona três objetos MyObject à lista. O jeito mais simples de percorrer uma lista encadeada é utilizando a sintaxe do foreach, que é semelhante à do PHP. Utilizar um loop com myList.size() também funciona.

Para interagir utilizando o foreach, você precisa trabalhar sobre algo que implemente a interface Collection. Tanto List quanto LinkedList implementam essa interface, então o código ficaria mais ou menos assim:

LinkedList myList = new LinkedList();
myList.add(new MyObject());
myList.add(new MyObject());
myList.add(new MyObject());

for (MyObject myobj : myList) {
    myobj.doSomething();
}

Mais ou menos algo como para cada (MyObject)myObj em myList, faça isso. O equivalente em PHP seria:

$myList = array();
$myList[] = new MyObject();
$myList[] = new MyObject();
$myList[] = new MyObject();

foreach ($myList as $myObj) {
    $myObj.doSomething();
}

Pessoalmente eu acho que a maneira do Java faz mais sentido. No PHP parece que estamos fazendo de trás pra frente.

Arrays Associativos

Até o presente momento quando você não possuir alternativa e precisar utilizar arrays associativos, terá de apelar para hashtables.

Dê uma olhada neste link para aprender mais sobre HashTable, HashMap e HashCode.

Perceba também que você precisará dar cast nos objetos no caminho - os Hashtables não utilizam o mecanismo de generics para assegurar um tipo específico de dado.

Implementando interfaces com objetos anônimos

Algo que eu achei realmente muito legal (e se você já usou interfaces antes tenho certeza de que também irá gostar) é a capacidade de implementar interfaces com objetos anônimos. Em PHP, se você possui uma interface, necessita de uma declaração sólida da sua interface antes de implementá-la em uma classe.

Em Java você pode implementar uma interface na hora. Você especifica a interface que você está implementando, seguida pelo bloco de código contendo a implementação:

OnClickListener myClickListener = new OnClickListener() {
    public void onClick(DialogInterface dialoginterface, int i) {
        startGame(i);
    }
};

Simples, não? Parece bastante útil quando você precisa desenvolver pequenos manipuladores como esses.

Classes e Interfaces Aninhadas

No exemplo anterior eu acabei omitindo algo: o OnClickListener, na verdade, é uma interface estática aninhada. O código correto seria:

DialogInterface.OnClickListener myClickListener = new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialoginterface, int i) {
        startGame(i);
    }
};

Vou tenta explicar em miúdos. Você pode dar uma olhada no site oficial do Java (texto em inglês) e também no site da Caelum um tutorial sobre classes aninhadas.

O primeiro exemplo fala de uma classe interna comum (não uma estática como OnClickListener). Você pode ter uma declaração de classe dentro de outra classe e apenas a classe exterior poderá criar uma nova instância dessa classe interna. A seguir vemos um exemplo de classe aninhada e como ela se parece:

class MyClass {
    class MyInnerClass {
    }

    public void foo() {
        MyClass.MyInnerClass innerObject = new MyClass.MyInnerClass();
    }
}

Então aqui você faz uma declaração de classe interna (MyInnerClass) que apenas pode existir dentro da sua classe externa (MyClass).

Algumas vezes a classe deve estar dentro de uma outra classe mas ainda ser acessível para o mundo – está dentro de outra classe apenas por causa dos namespaces, como o exemplo do OnClickListener acima (a diferença é que ali está mais pra interface do que pra uma classe, então você deve apenas substituir class por interface).

Neste caso você deveria utilizar a palavra-chave static:

class MyClass {
    static class MyInnerClass {
    }

    public void foo() {
        MyClass.MyInnerClass innerObject = new MyClass.MyInnerClass();
    }
}

class MyOtherClass {
    public void foo() {
        MyClass.MyInnerClass inner = new MyClass.MyInnerClass();
    }
}

Perceba que nesse caso a classe interna pode residir totalmente dentro de outra classe. Não precia estar dentro de MyClass.

Considerações Finais

Muitas dessas peculiaridades do Java, que podem ser consideradas implementações mais puras da orientação a objetos, podem ser integradas ao novo PHP 6. Caso você queira dar uma olhada no que vem por aí dentro do PHP, sugiro que leiam meu outro artigo: O que há de novo no PHP 5.4? Conheça as mudanças mais significativas.

Espero que essas experiências possam ajudá-los a melhorar suas aptidões em novas linguagens e, assim, não ficar parado no tempo. É importante nunca parar de estudar e aperfeiçoar-se cada vez mais.

Aproveitem os comentários para exporem suas dúvidas e contribuírem com a discussão.

Um abraço a todos e fiquem com Deus!

Texto adaptado do original: http://www.searbe.co.uk/moving-from-php-to-java

O post Ensinando Java a Programadores PHP apareceu primeiro em PHPit.

Criar um tema de WordPress para acomodar os conceitos de design do seu website torna-se muito mais fácil quando você sabe algumas coisas como Páginas com Templates Personalizados. O WordPress trabalha utilizando posts e páginas, mas uma página não precisa ter exatamente o mesmo formato de outra. Você pode criar layouts e conteúdos únicos para páginas específicas, criando sites com efeitos visuais interessantíssimos e que ainda sim podem ser editados pelo poderoso WordPress.

O que é uma Página com Template Personalizado?

Estes templates personalizados do WordPress são arquivos de tema que disponibilizam uma alternativa para o arquivo page.php padrão. Esses templates podem conter qualquer HTML e tags de template que você desejar e que sejam necessários para construir o layout ou conteúdo escolhido, então o arquivo pode ser associado a uma página específica de modo que o WordPress utilize este novo template quando estiver exibindo esta página em particular.

Comumente as páginas com templates personalizados são utilizadas para criar layouts únicos para seções como sobre nós, depoimentos ou serviços; um charmoso portfolio tomado de efeitos visuais; ou um inteligente sistema de contato utilizando códigos inseridos diretamente no template. Se você precisa configurar o layout da sua página além do que está no arquivo page.php padrão, então você precisa de uma página com template personalizado!

Como criar uma Página com Template Personalizado

Criar uma página com template personalizado não poderia ser mais simples! Crie um arquivo PHP em branco e adicione o seguinte código:

<?php
/*
Template Name: Portfolio
*/
?>

Configure o nome do template como algo reconhecível, pois é este nome que aparecerá em um menu dropdown dentro da tela de administração do WordPress. Salve o arquivo com um nome correspondente ao template que escolheu e que faça sentido como portfolio.php, por exemplo.

No restante do documento, adicione seu HTML e suas tags do WordPress para construir o layout que deseja. Aqui você pode utilizar tags como <?php get_header(); ?> para construir uma página utilizando os elementos de header/sidebar/footer existentes ou pode criar algo completamente novo e único utilizando apenas alguns loops do WordPress. Não se esqueça que você também pode programar suas rotinas diretamente nesse arquivo também, como uma ação de um formulário, importação de um vídeo do YouTube ou um iFrame do Google Maps.

Depois de criar o seu template personalizado e enviá-lo para o diretório do seu tema, crie uma nova página utilizando o editor do WordPress. Todos os conteúdos que você adicionar utilizando o WYSIWYG aparecerão em qualquer lugar que a tag <?php the_content(); ?> estiver inserida. Essa página utilizará o template page.php padrão a menos que você altere as opções de modelo na área de atributos da página.

Selecione o menu Modelo e escolha o arquivo de template que você criou. Pressione o botão de publicar e veja seu WordPress gerar conteúdo dinâmico na estrutura de página personalizada que você criou.

Texto adaptado do original: http://line25.com/tutorials/how-to-create-a-wordpress-custom-page-template

O post Como criar páginas com template personalizado no WordPress apareceu primeiro em PHPit.

Texto adaptado do original: http://www.tlabsonline.com/blog/php-is-the-best-option-to-learn/

Você acha que tem o que precisa para ser um bom programador web? A arte de aprender novas linguagens frequentemente. Surpreso? Bem, não fique porque não estou falando de Tamil, Telugu, Francês e Suahili, mas de linguagens de programação de computadores. Com diversas linguagens utilizadas para criar sistemas web, há pesquisas contínuas nesse campo buscando a melhor linguagem de programação para a internet.

O PHP é considerado uma das melhores linguagens para programação web atualmente. PHP que teve sua concepção em meados de 1994 têm se tornado uma das linguagens favoritas de muitos que conhecem e utilizam. Mas então o que há de tão especial na programação web? Pra começar, é uma das linguagens mais fáceis de serem aprendidas, especialmente por pessoas leigas. Trazendo à luz as vantagens do PHP, podemos citar:

1. É uma linguagem do lado do servidor para desenvolvimento web, mas também é utilizada como uma linguagem para diversos propósitos
2. Está plenamente disponível e absolutamente de graça (open source, inclusive!)
3. Funciona em diversas plataformas e integra-se brilhantemente com o MySQL
4. Uma das linguagens mais utilizadas devido à facilidade de uso e natureza dinâmica
5. É possível encontrar diversas informações e referências sobre a linguagem por todos os cantos da internet
6. O dinamismo da aplicação é imenso. É muito simples de criar websites dinâmicos e rápidos e permite que essas páginas sejam hospedadas por um baixo custo e sem aborrecimentos

Por agora você já deve estar mais por dentro desta maravilhosa criação da tecnologia da informação. Então, mesmo sendo técnico ou leigo, você pode definitivamente arriscar uma tentativa em aprender esta linguagem. Mas lembre-se, embora possa ser fácil, você vai precisar de um bom professor para aprender com precisão e eficiência. E não se esqueça disso!

Aproveite a grande comunidade que temos aqui no Brasil e intereja, pergunte, investigue, experimente! E lembre-se sempre que todos são bem vindos a participar da construção do conhecimento aqui no blog e em toda a nossa comunidade!

Um abraço a todos e fiquem com Deus!

O post PHP é a melhor opção pra começar apareceu primeiro em PHPit.

Tutorial adaptado do original escrito por EvanDotPro: http://blog.evan.pro/disabling-the-layout-in-zend-framework-2

As vezes você precisa desativar o layout para uma ação específica. Para fazer isso, simplesmente configure a sua View Model da sua ação para retornar como “terminal”. Isso fará com que o ZF2 não envolva o conteúdo na view em um layout.

<?php

namespace Application\Controller;

use Zend\Mvc\Controller\ActionController;
use Zend\View\Model\ViewModel;

class IndexController extends ActionController
{
    public function nolayoutAction()
    {
        // Turn off the layout, i.e. only render the view script.
        $viewModel = new ViewModel();
        $viewModel->setTerminal(true);
        return $viewModel;
    }
}

Mais exemplos podem ser encontrados na excelente ZF2TestApp do Rob Allen.

O post Desativando o layout no Zend Framework 2 apareceu primeiro em PHPit.

Você tem sorte? Então tá na hora de colocar essa sorte à prova! O PHPit irá sortear dois ingressos SILVER para a PHP Conference Brasil 2012. Deu vontade? Então saiba como conseguir:

• Um ingresso será sorteado pelo Twitter do PHPit para quem der RT no tweet mencionado;
• Um ingresso será sorteado pelo Facebook para quem compartilhar a imagem mencionada;

Lembrando que para quem participar pelo Facebook, só poderão ser contados os compartilhamentos de quem tiver o mural aberto (caso contrário não é possível listar). Também é importante tomar cuidado para compartilhar a imagem original, e não apenas reenviá-la ao seu mural. Os dois sorteios serão realizados no dia 06/11/2012 às 13h.
O vencedor da promoção deve enviar um email para rafael@phpit.com.br ainda no mesmo dia.

O ingresso só é válido até 07/11/2012.

Primeiro será feito o sorteio do Twitter e em seguida do Facebook. Caso a mesma pessoa seja sorteada em ambos os certames, o segundo sorteio será efetuado novamente.

Promoção no Twitter
Promoção no Facebook

Boa sorte a todos e nos vemos lá!

O post PHPit te leva à PHP Conference Brasil 2012 apareceu primeiro em PHPit.