O WordPress é um CMS(Content Management System), open source escrito em PHP e utiliza o banco de dados MySQL. O mesmo é o sucessor do **b2/cafelog**, criado por Michel Valdrighi, que foi lançado em 2001. Em 2002, o desenvolvimento do b2, se encerrou. E em 2003, um calouro universitário decidiu criar um `fork` do projeto. Matthew Mullenweg Charles, juntamente com Mike Little, começaram a criar o WordPress a partir do código do b2.## Pré-requisitos- PHP 5.6 ou superior - MySQL 5.6 ou superior - Módulo Apache mod_rewrite, ativo## InstalaçãoO [download](https://wordpress.org/download/) da versão estável pode ser feito no site oficial. Apos o download, basta extrair o `.zip` no seu servidor.## ConfiguraçãoPrimeiramente, você precisa criar um banco de dados **Mysql** e atribuir a um usuário as permissões necessárias. Agora é hora de navegar para o seu site para começar com o processo de instalação.Você precisará informar algumas informações, como :- Nome do banco de dados - Nome do usuário do banco - Senha do banco - Servidor do banco de dados - Prefixo utilizado na criação das tabelasO nome do banco de dados, usuário e senha, você já saberá se fez o primeiro passo informado para a configuração. O servidor, dificilmente precisará ser alterado, podendo manter o valor `localhost`. Quanto aos prefixos das tabelas, só terá a necessidade de ser alterado, caso tenha múltiplas instalações com o Wordpress no mesmo banco de dados.Após preencher essas informações no formulário apresentado, basta submeter. Esses dados serão armazenados no arquivo `wp-config.php`, que estará na raiz do projeto. Caso queira fazer esse passo manualmente, basta renomear ou duplicar o arquivo `wp-config-sample.php`, que se encontra na raiz do projeto. Dentro do arquivo encontraremos:```php define('DB_NAME', '[nome_do_banco_de_dados]');/** Usuário do banco de dados MySQL */ define('DB_USER', '[nome_de_usuario]');/** Senha do banco de dados MySQL */ define('DB_PASSWORD', '[senha]');/** nome do host do MySQL */ define('DB_HOST', 'localhost');// ...$table_prefix = 'wp_'; ```O importante é que se tenha o arquivo `wp-config`, preenchido na raiz do projeto, para que seja identificado a instalação.Preenchendo as informações do banco de dados pelo navegador ou manualmente, logo após teremos o passo de preencher as informações básicas para o painel de controle. Esse passo, será feito pelo navegador. Informaremos o nome do site e os dados para a criação de um usuário para acessar o painel de controle do WordPress.Assim, temos uma instalação completa. Podemos fazer o login, para acessar o painel ou ver o site carregado com o tema padrão.s## Estrutura de pastas- **wp-admin./** - Contém os arquivos(PHP) do paindel de controle e normalmente não são alterados por usuários ou desenvolvedores - **wp-content/** - Contém os seus temas, plugins e conteúdo carregados e alterados quando você adicionar mídia, plugins e temas - languages/ - plugins/ - themes/ - upgrade/ - uploads/ - **wp-includes/** - Contém arquivos(PHP) do núcleo do WordPress e normalmente também não são alterados por usuários ou desenvolvedores - ...## ConclusãoO WordPress é uma boa ferramenta para criação de blogs, para usuários sem muito conhecimento de desenvolvimento web e desenvolvedores experientes. Poupando tempo para criação de um painel de controle. Nos próximos artigos veremos mais sobre seus recursos.
De acordo com Taylor Otwell (criador), Laravel foi lançado em junho de 2011, simplesmente para resolver a falta de funcionalidades com o framework **CodeIgniter**. Que na época, era bem conhecido pela sua simplicidade e e documentação abrangente.Laravel se trata de um **Framework PHP**, que utiliza o padrão MVC. Vem com muitos recursos e é construído em muitos padrões, ajudando no desenvolvimento de aplicações seguras e performáticas de forma rápida. Possui algumas características que motivam na sua utilização como: facilidade de roteamento, arquitetura modular alimentado por Composer, comunidade ativa e solidária, boa dicumentação, sistema de templates (Blade), Artisan (CLI 'Command Language Interpreter' do Laravel) e mais.## InstalaçãoPré-requisitos:- PHP >= 5.5.9 - OpenSSL PHP Extension - PDO PHP Extension - Mbstring PHP Extension - PHP Extension### ComposerO composer é um controlador de dependências e você pode fazer a instalação do mesmo, das seguintes formas:```bash # via cURL curl -sS https://getcomposer.org/installer | php# via PHP php -r 'readfile('https://getcomposer.org/installer');' | php ```A instalação do Laravel, é simples com o comando:```bash composer global require 'laravel/installer' ```Após a instalação, será necessário adicionar o caminho do mesmo no **Path** do sistema. Pode fazê-lo, pela interface do sistema operacional ou pelo comando:```bash export PATH='$PATH:$HOME/.composer/vendor/bin' ```## Primeiro projetoPara criar um novo projeto, usamos o comando:```bash # new [nome do projeto] laravel new Example ```## ConfiguraçãoVou me basear na versão atual (5.2). Todos os arquivos de configuração se encontram na pasta `config`. Os valores de configuração podem ser acessados facilmente com a função global `config`. Os valores podem ser acessados, usando o nome do arquivo e a opção desejada por intermédio do caractere `.`. Exemplo:```php $value = config('app.timezone'); ```Para definir um valor em tempo de execução, passamos um `array`, na função `config`:```php config(['app.timezone' => 'America/Sao_Paulo']); ```### AmbienteÉ sempre bom separar o ambiente de desenvolvimento e o ambiente de produção. O Laravel tora isso fácil, utilizando a biblioteca [DotEnv](https://github.com/vlucas/phpdotenv), criada por Vance Lucas.Durante a instalação do Laravel, via Composer, o arquivo `.env.example` é copiado para `.env`:```bash php -r 'copy('.env.example', '.env');' ```Nesse novo arquivo, teremos todas as varáveis que serão carregadas no `$_ENV`. Podemos utilizar a função `env`, para recuperar os valores dessas variáveis. Exemplo:```php // o segundo parâmetro é um valor default // que é usado quando não existe // nenhuma variável de ambiente // para a chave informada 'debug' => env('APP_DEBUG', false) ```O ambiente atual da aplicação é determinado através da variável `APP_ENV`, no arquivo `.env`. Podemos acessar esse valor com o método `environment`, da interface estática(facade) da classe `App`:```php $environment = App::environment(); ```Também podemos passar argumentos para o `environment`, para verificação.```php if (App::environment('local')) { // The environment is local }if (App::environment('local', 'staging')) { // The environment is either local OR staging... } ```Podemos também acessar pelo método auxiliar `app`:```php $environment = app()->environment(); ```### Cache da configuraçãoPara aumentar a velocidade da sua aplicação, podemos armazenar em cache os arquivos de configuração em apenas um arquivo. Isso é possível, usando o `config:cache`, do Artisan. Não se deve ser executado no ambiente de desenvolvimento, por ser frequentemente alterado. Então, para a implantação de produção, execute:```bash php artisan config:cache ```## ObservaçõesNa instalação via Composer, além da execução do comando para a criação do arquivo `.env`, também executado outros comandos. Um deles é o comando:```bash php artisan key:generate ```O mesmo cria uma chave no arquivo de ambiente, sendo o valor da varável `APP_KEY`. Se a chave da aplicação não estiver definida, as suas sessões de usuário e outros dados criptografados não serão seguros.## Estrutura de pastas- **app/** - Componentes da sua aplicação. - **bootstrap/** - Arquivos que inicializam o framework e configuram o autoloading. - **config/** - Arquivos de configuração do projeto. - **database/** - Contém os arquivos de `migration` e `seeds` do seu banco de dados, nas pastas `factories`, `migrations` e `seed`. - **public/** - É o seu DocumentRoot (toda requisição efetuada pelo usuário cairá nela). - **node_modules/** - Será criada na execução do comando `npm install`, na raiz do projeto. - **resources/** - Contém as suas views, raw assets (LESS, SASS, CoffeeScript), e arquivos de localização. - **storage/** - É responsável por armazenar os arquivos de uso interno do Laravel tais como: Cache, logs e etc. - **tests/** - Contém os arquivos de testes, para a aplicação. - **vendor/** - Gerada automaticamente pelo composer, é nela que encontramos as bibliotecas que farão com que o Laravel rode. – .env – .env.example – .gitattributes – .gitignore – artisan – composer.json – composer.lock – gulpfile – package.json – phpunit.xml – readme.md – server.php## ConclusãoEssa é uma breve introdução ao Laravel, onde podemos fazer a instalação e criar um novo projeto. Nos próximos artigos, veremos coisas mais práticas e conheceremos mais sobre suas funcionalidades e etc.
A Programação orientada a objetos permite que os desenvolvedores agrupem tarefas semelhantes em classes. O PHP não é uma linguagem que foi criada para ser orientada a objetos. Começando a dar suporte ao mesmo na versão 3, sendo melhorada na versão 4 e tendo um bom suporte na versão 5.3.O primeiro e mais importante conceito de orientação a objetos é a classe, uma abstração do software de objetos similares, ou seja, um template do qual os objetos serão criados.Na criação de uma classe, o nome é precedido da palavra reservada `class` e seguida de um par de chaves `{}` :```php```## Atributos/PropriedadesSão elementos que definem uma classe, também são conhecidos como variáveis de classe. A palavra chave `public` determina a visibilidade da propriedade (vamos ver mais sobre isso no decorrer do artigo, na parte de visibilidade de propriedades e métodos). Depois disso, a propriedade é nomeada usando os padrões básicos de nomeação de variáves e é mostrado que não necessitam de valores iniciais.```php```## MétodosSão funções internas das classes que realizam algo, geralmente tomando por base os dados armazenados nas propriedades. Dentro dos métodos, as propriedades e outros métodos internos da classe são referenciados utilizando `$this`.### ConstrutorO construtor da classe é um bloco declarado com o mesmo nome que a classe.```php getPerson(); } function getPerson(){ $this->name = 'Hemerson'; $this->cpf = '123.123.123-22'; $this->age = 29; } function getMessage(){ return 'Meu nome é ' . $this->name; } } ?> ```Após criar a classe, ela pode ser instanciada e guardada em alguma variável usando a palavra chave `new`. O operador `->`, permite acessar as propriedades e métodos de um objeto.```php name; // Hemerson echo $person->getMessage(); // Meu nome é Hemerson ?> ```## Métodos MágicosAo invés de termos um método com o mesmo nome da classe para ser o construtor, o PHP provê o método `__construct()`, que é chamado automaticamente quando a classe é instanciada. Também há inúmeras constantes mágicas, como `__CLASS__`, que retorna o nome da classe. Podemos ver as constantes disponíveis no [Manual do PHP](http://us3.php.net/manual/pt_BR/language.constants.predefined.php). Os demais métodos mágicos podemos conferir no [Manual](http://php.net/manual/pt_BR/language.oop5.magic.php).```php name .' e a classe ' . __CLASS__ . ' foi instanciada'; } }$person = new Person(); // Meu nome é Hemerson e a classe Person foi instanciada ?> ```## Herança de ClasseNa Orientação a objetos, as classes podem herdar métodos e propriedades de outra classe. Isso é possível utilizando a palavra chave `extends`.```php name; } }class Example extends Person { function __construct(){ echo 'Essa classe é a ' . __CLASS__; } }$example = new Example(); // Meu nome é Hemerson ?> ```Assim, temos superclasses e subclasses na orientação a objetos. Onde as superclasses são classes mãe, que não derivam de nenhuma outra classe e as subclasses são classes que são criadas a partir de outras classes. Podemos utilizar as palavras parent (se referindo a classe mãe) e self (se referindo a classe atual).```php message.'--'; } }class Example extends Person { public $message = 'Não sou o Hemerson'; public function __construct(){ echo parent::getMessage(); echo self::getMessage(); echo $this->getMessage(); } public function getMessage(){ return $this->message; } }$example = new Example(); // Não sou o Hemerson-- // Não sou o Hemerson // Não sou o Hemerson ?> ```Temos que ficar atentos, que quando há uma propriedade de mesmo nome na subclasse, a propriedade da superclasse será sobrescrita e o valor da subclasse passará a valer.## Visbilidade de Propriedades e MétodosA visibilidade controla como e de onde as propriedades e métodos podem ser acessados. Há três palavras chaves para visibilidade: `public`, `protected`, e `private`. Também pode ser adicionado à sua visibilidade, a palavra chave `static`, o que permite que sejam acessados sem uma instanciação da classe. Se a visibilidade não é declarada, automaticamente se considera como `public`. O uso da declaração de variável com a palavra-chave `var` ainda é suportada por razões de compatibilidade e o mesmo é um sinônimo para a palavra-chave `public`.- **public** - Podem ser acessados de qualquer lugar, tanto dentro quanto fora da classe. - **protected** - Só pode ser acessado dentro da própria classe ou por uma classe herdeira. - **private** - É acessível somente dentro da classe que os define. - **static** - Podem ser acessados sem instanciar a classe.```php cpf; } function getStatus(){ return $this->status; } }$person = new Person(); $example = new Example();echo $person->name; // Hemersonecho $example->name; // Hemerson echo $example->getCpf(); // 123.123.123-22 echo $example->cpf; // FATAL ERROR Cannot access protected property Example::$cpfecho $example->getStatus(); // Undefined property: Example::$status ?> ```Agora um exemplo com a adição da palavra chave `static`:```php exampleMethod() . '/n'; // Teste print $person->message . '/n'; // Accessing static property Person::$message as non static // Undefined property: Person::$message ?> ```Propriedades estáticas não podem ser acessadas através do operador ->.## ConclusãoProgramação orientada a objetos é uma coisa linda. Pode parecer complicado no começo, mas como tudo, a prática e entender o que está fazendo, leva a perfeição. É só cair dentro dos estudos e ver as vantagens, que serão notadas. Facilidade na manutenção e organização, ajudando você e sua equipe.
O assunto de hoje é o sobre `array`. Se já mexeu com alguma linguagem de programação, já deve ter visto ou trabalhado com um `array`. Se é leigo no assunto, vamos estar vendo sobre o mesmo no PHP.Os `arrays` também podem ser identificados como `tipos de dados compostos`. Os elementos e os dados de um `array`, são conhecimos como os `pares de chave e valor`. Vamos supor que temos um `array` com 3 elementos, onde cada um contém uma letra do alfabeto. Exemplo:```php // Chave : 0 1 2 // Valor : a b c ```Na prática temos duas formas de criar um array e representar esse exemplo:```php // função array $array = array(0 => 'a', 1 => 'b', 2 => 'c'); // ou // com colchetes $array2 = array(); $array2 = ['a', 'b', 'c'];// variação com colchetes $array3 = array(); $array3[0] = 'a'; $array3[1] = 'b'; $array3[2] = 'c'; ```Não se preocupe com os exemplos práticos. Logo abaixo vamos estar vendo os tipos, funções de `arrays` e as regras para entender melhor como eles funcionam.## Tipos de arraysUma coisa muito importante, é não esquecer que a chave numérica de um elemento de um `array`, sempre começa em 0. E você pode acessar um elemento do `array`, acessando com a chave entre colchetes. Exemplo:```php $array = array(0 => 'a', 1 => 'b', 2 => 'c'); echo $array[2]; // c ```### Indexado / AssociativoUm `array indexado` é conhecido como tal, qual suas chaves são do tipo numérico. Um `array` de chaves nomeadas com `strings`, é conhecido como `array associativo`.```php // Array com chaves númericas(indexadas) // Chave : 0 1 2 // Valor : a b c $array = array(0 => 'a', 1 => 'b', 2 => 'c'); ``````php // Array com chaves nomeadas(associativas) // Chave : name age status // Valor : Ana 20 1 $array = array('name' => 'Ana', 'age' => 20, 'status' => 1); ```### Bidimensional / MultidimensionalOs `arrays` podem ser de duas ou mais dimensões. Isso quer dizer, que podemos ter um `array`, dentro de um `array`. Não se tem um limite de dimensões para os `arrays`, mas dependendo da quantidade, fica difícil manter o código de fácil entendimento. Exemplo:```php // Array tridimensional $array = array(0 => 'a', 1 => array(0 => 'a', 1 => 'b', 2 => array(0 => 'entrou', 1 => 'saiu')), 2 => 'c'); echo $array[1][2][0]; // entrou ```### DinâmicosJá vimos que os `arrays` podem ser indexados, associativos, bidimensionais e até multidimensionais. No PHP, eles também podem ser dinâmicos. Com isso, podemos adicionar, deletar e alterar os elementos com comandos e funções para esse uso.```php $array = array('name' => 'Ana', 'country' => 'Brasil'); // Comando que adicionará ao final do array $array['age'] = 29; ```Acima, temos um `array` associativo com 3 elementos. O que acontece se adicionarmos um valor, sem informar a chave? Podemos conferir no exemplo abaixo.```php $array = array('name' => 'Ana', 'country' => 'Brasil', 'age' => 29); $array[] = 'ihhhh'; var_dump($array); // 'name' => 'Ana', 'country' => 'Brasil', 'age' => 29, 0 => 'ihhhh' ```É, quando não informamos a chave, automaticamente a chave recebe o próximo índice numérico. Como é apenas um `array` associativo e não tinha nenhuma chave numérica, o próximo índice é o `0`. Vamos ver como fica no próximo exemplo.```php $array = array(0 => 'Ana', 1 => 'Brasil', 'age' => 29); $array[] = 'ihhhh'; var_dump($array); // 0 => 'Ana', 1 => 'Brasil', 'age' => 29, 2 => 'ihhhh' ```Para alterar o valor, é bem intuitivo. Basta informar a chave e lhe dar o novo valor.```php $array = array(0 => 'Ana', 1 => 'Brasil', 'age' => 29); $array['age'] = 31; var_dump($array); // 0 => 'Ana', 1 => 'Brasil', 'age' => 31 ```Agora vamos brincar um pouco ao remover elementos com a função `array_splice`. Na função, você informa 3 parâmetros, sendo o terceiro opcional.```php $array = array(0 => 'Ana', 1 => 'Brasil', 'age' => 29); // Parâmetros // 1º = array, 2º = remover a partir de qual posição , 3º = quantos elementos remover // Quando não informamos o 3º, ele remove da posição informada no 2º parâmetro até o último elemento do array array_splice($array, 1); var_dump($array); // 0 => 'Ana' ``````php $array = array(0 => 'Ana', 1 => 'Brasil', 'age' => 29); array_splice($array, 0, 1); var_dump($array); // 1 => 'Brasil', 'age' => 29 ```Também podemos criar um novo `array`, apenas com o resultado da função `array_splice`, em uma variavel. Exemplo:```php $array = array(0 => 'Ana', 1 => 'São Paulo', 2 => 'Rio de Janeiro'); $arrayTemp = $array; $arrayStates = array_splice($arrayTemp, 1, 2); var_dump($array); // 0 => 'Ana', 1 => 'São Paulo', 2 => 'Rio de Janeiro' var_dump($arrayStates); // 0 => 'São Paulo', 1 => 'Rio de Janeiro' ```Uma outra função para remover elementos de um array, é a função `unset`. Exemplo:```php $array = array(0 => 'Ana', 1 => 'São Paulo', 2 => 'Rio de Janeiro'); unset($array[1]); var_dump($array); // 0 => 'Ana', 2 => 'Rio de Janeiro' ```## ForeachFunciona apenas com arrays. Retorna um erro se for utilizado em uma variável de qualquer tipo diferente ou em variáveis não inicializadas. Pode ser usada de duas formas:```php foreach (array as $valor) { // instrução }foreach (array as $chave => $valor) { // instrução } ``````php $arr = array(1, 2, 3, 4); foreach ($arr as $value) { $value = $value * 2; } // $arr = array(2, 4, 6, 8) ```## Algumas funções de ArrayO `array` é muito usado no PHP. Por esse motivo, tem muitas funções nativas da linguagem, que podemos utilizar.### sortEssa função ordena um array. Os elementos serão ordenados do menor para o maior ao final da execução dessa função.```php // bool sort ( array &$array [, int $sort_flags ] ) $val) { echo 'items[' . $key . '] = ' . $val . '/n'; } ?>// items[0] = item4 // items[1] = item3 // items[2] = item1 // items[3] = item2 ```### rsortEssa função ordena um array em ordem descrescente (do maior para o menor).```php // bool rsort ( array &$array [, int $sort_flags ] ) $val) { echo '$key = $val/n'; } ?>// 0 = item2 // 1 = item1 // 2 = item3 // 3 = item4```### asortEssa função ordena um array de forma que a correlação entre índices e valores é mantida. É usada principalmente para ordenar arrays associativos onde a ordem dos elementos é um fator importante.```php // bool asort ( array &$array [, int $sort_flags ] ) 'item1', 'a' => 'item2', 'b' => 'item3', 'c' => 'item4'); asort($items); foreach ($items as $key => $val) { echo '$key = $val/n'; } ?>// c = item4 // b = item3 // d = item1 // a = item2 ```### arsortEsta função ordena um array de forma que a correlação entre índices e valores é mantida. É usada principalmente para ordenar arrays associativos onde a ordem dos elementos é um fator importante.```php // bool arsort ( array &$array [, int $sort_flags ] ) 'item1', 'a' => 'item2', 'b' => 'item3', 'c' => 'item4'); arsort($items); foreach ($items as $key => $val) { echo '$key = $val/n'; } ?>// a = item2 // d = item1 // b = item3 // c = item4 ```### ksortOrdena um array pelas chaves, mantendo a correlação entre as chaves e os valores. Essa função é bastante útil principalmente para arrays associativos.```php // int ksort ( array &$array [, int $sort_flags ] )'item1', 'a'=>'item2', 'b'=>'item3', 'c'=>'item4'); ksort($items); foreach ($items as $key => $val) { echo '$key = $val/n'; } ?>// a = item2 // b = item3 // c = item4 // d = item1 ```### krsortOrdena um array pelas chaves em ordem descrescente, mantendo a correlação entre entre as chaves e os valores. Essa função é bastante útil em arrays associativos.```php // bool krsort ( array &$array [, int $sort_flags ] )'item1', 'a'=>'item2', 'b'=>'item3', 'c'=>'item4'); krsort($items); foreach ($items as $key => $val) { echo '$key = $val/n'; } ?>// d = item1 // c = item4 // b = item3 // a = item2 ```### usortEssa função irá ordenar um array pelos valores usando uma função de classificação definida pelo usuário. Se o array precisar ser ordenado utilizando um critério não trivial, você deve usar essa função.```php // bool usort ( array &$array , string $cmp_function ) $value) { echo '$key: $value/n'; } ?>// 0: 1 // 1: 2 // 2: 3 // 3: 5 // 4: 6 ```### array_sum`array_sum()` retorna a soma dos valores de um array.```php // number array_sum ( array $array ) 1.2, 'b' => 2.3, 'c' => 3.4); echo 'sum(b) = ' . array_sum($b) . '/n'; ?>// sum(a) = 20 // sum(b) = 6.9 ```### array_uniqueRecebe o argumento array e retorna um novo array sem valores duplicados.```php // array array_unique ( array $array ) 'green', 'red', 'b' => 'green', 'blue', 'red'); $result = array_unique($input); print_r($result); ?>// Array // ( // [a] => green // [0] => red // [1] => blue // ) ```### in_arrayProcura no array, pelo valor informado.```php // bool in_array ( mixed $needle , array $haystack [, bool $strict ] )// Got Irix ```### array_searchProcura no array, pelo valor informado.```php // mixed array_search ( mixed $needle , array $haystack [, bool $strict ] ) 'blue', 1 => 'red', 2 => 'green', 3 => 'red');$key = array_search('green', $array); // $key = 2; $key = array_search('red', $array); // $key = 1; ?>```### array_rand`array_rand()` é bastante útil quando se quer conseguir aleatoriamente um ou mais elementos de um array.```php // mixed array_rand ( array $input [, int $num_req ] )```### array_mergeFunde os elementos de dois ou mais arrays de forma que os elementos de um são colocados no final do array anterior. Retorna o array resultante da fusão.```php // array array_merge ( array $array1 [, array $array2 [, array $... ]] ) 'red', 2, 4); $array2 = array('a', 'b', 'color' => 'green', 'shape' => 'trapezoid', 4); $result = array_merge($array1, $array2); print_r($result); ?>// Array // ( // [color] => green // [0] => 2 // [1] => 4 // [2] => a // [3] => b // [shape] => trapezoid // [4] => 4 // ) ```### array_walkAplica uma função definida pelo usuário nomeada pelo argumento `funcname` em cada elemento de array.```php // bool array_walk ( array &$arrary , string $funcname [, mixed $userdata ] )'; } $a=array('a'=>'red','b'=>'green','c'=>'blue'); array_walk($a,'myfunction'); ?>// The key a has the value red // The key b has the value green // The key c has the value blue ```### countConta os elementos de um array.```php // int count ( mixed $var [, int $mode ] )```### shuffleEssa função mistura de forma aleatória os elementos de um array.```php // bool shuffle ( array &$array )// 15 9 18 19 12 16 4 17 20 1 5 13 8 6 7 3 11 2 14 10 ```### extractImportar variáveis a partir de um array para a tabela de símbolos corrente. `extract()` verifica cada chave e vê se ela tem um válido nome de variável. Também verifica por colisões com já existente variáveis na tabela de símbolo.```php // int extract ( array $var_array [, int $extract_type [, string $prefix ]] ) 'blue', 'size' => 'medium', 'shape' => 'sphere'); extract($var_array, EXTR_PREFIX_SAME, 'wddx');echo '$color, $size, $shape, $wddx_size/n';// blue, large, sphere, medium ?>```### compactCria um array contendo variáveis e seus valores.```php // array compact ( mixed $varname [, mixed $... ] )// Array // ( // [event] => SIGGRAPH // [city] => San Francisco // [state] => CA // ) ```## Referências- [PHP Documentation](http://php.net/docs.php) - Manual do PHP## ConclusãoSe pode brincar bastante com arrays em PHP. Nas linguagens de programação, com certeza irá se deparar com um `array`. Sempre busque a melhor maneira de trabalhar com eles, pois ele pode ser usado da forma mais básica, até a mais complexa com multidimensões.
Tendo até mesmo pouco contato com a programação web, já deve ter visto ou utilizado uma `string`. No PHP, temos as intruções `echo` e `print`para enviar uma `string` para o navegador.### echoPermite vários parâmetros.```php```Estando ativado no `php.ini` o módulo **short_open_tag**, você pode executar o comando `echo`, com a combinação de tags PHP e o sinal de `=`.```php// Test ```### printRetorna 1 após o envio da saída, pode ser usada em expressões e permite apenas um parâmetro.```php```## EscapeNo PHP, para imprimir uma `string`, você pode usar aspas duplas ou simples. Podem haver casos em que seja necessário a impressão das aspas. Para que isso seja possível, temos duas formas: usar os 2 tipos de aspas ou o `escape`(com a barra invertida).```php```O `escape` também pode ser utilizado com outros caracteres. No exemplo abaixo, quando usamos o cifrão, o PHP interpreta que estamos tentando enviar o conteudo de uma variável.```php```Com o `escape`, temos o resultado esperado.```php```É válido também mencionar que a barra invertida tem outra utilidade. Combinando a barra invertida com a letra `n`(/n), o PHP interpreta como uma diretiva de nova linha. Importante lembrar que isso funciona apenas com aspas duplas, não temos o mesmo resultado com aspas simples.```php```Para ser possível ver isso no navegador, é necessário colocar dentro da tag `pre`. Sendo o mais aconselhável, utilizar a tag `br` para esse fim.```php new line '; // line // new line ?> ```## Algumas funções de stringVamos notar que as funções não seguem uma convenção de nomenclatura. Essa flexibilidade é um ponto forte ao mesmo tempo um ponto fraco do PHP.### ltrimRetira espaço em branco (ou outros caracteres) do início de uma string.```php // string ltrim ( string $str [, string $character_mask ] )// string(5) 'Teste' ```### rtrimEsta função retorna uma string com espaços em branco retirados do final da string.```php // string rtrim ( string $str [, string $character_mask ] )// string(5) 'Teste' ```### trimEsta função retira os espaços em branco do início e do final da string.```php // string trim ( string $str [, string $character_mask = ' /t/n/r/0/x0B' ] )// string(5) 'Teste' ```### ucwordsRetorna uma string com o primeiro caractere de cada palavra em maiúscula, se os mesmos forem alfabéticos.```php // string ucwords ( string $str [, string $delimiters = ' /t/r/n/f/v' ] )// string(21) 'Teste Para A Função' ```### srttoupperRetorna string com todos os caracteres do alfabeto convertidos para maiúsculas. Saiba que o alfabeto é determinada pela localidade atual. Por exemplo, 'a' com til (ã) não será convertido, pois o padrão do PHP é o local 'C'.```php // string strtoupper ( string $string )// string(21) 'TESTE PARA A FUNçãO' ```Podemos resolver o problema com a acentuação com a função `setlocale()`. Veja abaixo:```php // string setlocale ( mixed $category , string $locale [, string $... ] ) // string setlocale ( mixed $category , array $locale ) ```Category é uma constante (ou string) especificando a categoria de funções afetadas pela definição local:- `LC_ALL` - para tudo abaixo - `LC_COLLATE` - para comparação de strings, veja strcoll() - `LC_CTYPE` - para classificação de caracteres e conversão, por exemplo strtoupper() - `LC_MONETARY` - para localeconv() - `LC_NUMERIC` - para o separador decimal (Veja também localeconv()) - `LC_TIME` - para formatação de data e hora com strftime()```php// string(21) 'TESTE PARA A FUNÇÃO' ```### srttolowerRetorna string com todos os caracteres do alfabeto convertidos para minúsculas. E também é preciso mudar a localidade da aplicação para aceitar os acentos da língua portuguesa.```php // string strtolower ( string $str )// string(21) 'teste para a função' ```### ucfirstRetorna uma string com o primeiro caractere em maiúscula, se o caractere for do alfabeto.```php // string ucfirst ( string $str )// string(5) 'Teste' ```### lcfirstRetorna uma string com o primeiro caractere em letra minúscula se o caractere for alfabético.```php // string lcfirst ( string $str )// string(5) 'tESTE' ```### str_word_countConta o número de palavras dentro de string. Se o format opcional não é especificado, então o valor de retorno será um inteiro representando o número de palavras encontrado. No caso de o format estar especificado, o valor de retorno será um array, cujo conteúdo é dependente do format.```php // mixed str_word_count ( string $string [, int $format [, string $charlist ]] )// int(3) ```### strlenRetorna o tamanho da string.```php // int strlen ( string $string )// int(13) ```### strstrRetorna parte da string haystack a partir da primeira ocorrência de needle até o final de haystack.```php // string strstr ( string $haystack , mixed $needle [, bool $before_needle ] )// string(7) 'de nada' ```### stristrRetorna tudo de haystack a partir da primeira ocorrência de needle até o final.```php // string stristr ( string $haystack , mixed $needle [, bool $before_needle ] )// string(7) 'de nada' ```### strposRetorna a posição numérica da primeira ocorrência de needle dentro de haystack. Diferentemente de strrpos(), esta função pode ter uma string inteira como o parâmetro needle e toda a string será usada.```php // int strpos ( string $haystack , string $needle [, int $offset ] )// int(6) ```### substrRetorna a parte de string especificada pelo parâmetro start e length.```php // string substr ( string $string , int $start [, int $length ] )// string(12) 'TESTE de nad' ```### str_replaceEsta função retorna uma string ou um array com todas as ocorrências de search em subject substituídas com o valor dado para replace. Se você não precisa de regras de substituição especiais (como expressões regulares), você sempre poderia usar esta função ao invés de ereg_replace() ou preg_replace().```php // mixed str_replace ( mixed $search , mixed $replace , mixed $subject [, int &$count ] )// string(13) 'TESTE de tudo' ```### strip_tagsEsta função tenta retornar uma string retirando todas as tags HTML e PHP de str. Usa o mesmo sistema para retirar as tags do que fgetss().```php // string strip_tags ( string $str [, string $allowable_tags ] ) nada'; var_dump(strip_tags($string, '')); ?>// string(11) ' // // nada // ' ```### addslashesRetorna uma string com barras invertidas antes de caracteres que precisam ser escapados para serem escapados em query a banco de dados, etc. Estes caracteres são aspas simples ('), aspas duplas ('), barra invertida (/) e NUL (o byte NULL).```php // string addslashes ( string $str )// string(7) 'd/'agua' ```### stripslashesRemove barras invertidas de uma string.```php // string stripslashes ( string $str )// string(6) 'd'agua' ```### htmlentitiesEsta função é idêntica a htmlspecialchars() em toda forma, exceto que com htmlentities(), todos caracteres que tem entidade HTML equivalente são convertidos para estas entidades. Se você está querendo decodificar (o inverso), você pode usar html_entity_decode().```php // string htmlentities ( string $string [, int $quote_style [, string $charset [, bool $double_encode ]]] ) nada'; var_dump(htmlentities($string)); ?>// string(34) ''teste' de <b>nada</b>' ```### html_entity_decodehtml_entity_decode() é o oposto da função htmlentities() no que converte todas as entidades HTML para os seus caracteres de string.```php // string html_entity_decode ( string $string [, int $quote_style [, string $charset ]] )// string(23) ''teste' de nada' ```### str_shufflestr_shuffle() mistura uma string. Uma permutação de todas as possibilidades é criada.```php // string str_shuffle ( string $str )// string(6) 'fcebad' ```### md5Calcula o 'hash MD5' de str usando » RSA Data Security, Inc. MD5 Message-Digest Algorithm, e devolve esse hash.```php // string md5 ( string $str [, bool $raw_output ] )// string(32) 'e80b5017098950fc58aad83c8c14978e' ```### sha1Calcula a hash sha1 de str usando » US Secure Hash Algorithm 1, e retorna esta hash. A hash é um número hexadecimal de 40 caracteres. Se o parâmetro opcional raw_output for TRUE, então o resultado é retornado em um formato binário com o tamanho de 20.```php // string sha1 ( string $str [, bool $raw_output ] )// string(40) '1f8ac10f23c5b5bc1167bda84b833e5c057a77d2' ```## ConclusãoHá grandes possibilidades de se trabalhar com string no PHP. E com certeza, utilizará muito todas as funções mostradas acima. A dica é brincar bastante com elas e com as demais. Assim, fixará o conhecimento da linguagem e terá uma resposta mais rápida para possíveis questões que apareção durante o desenvolvimento.
Meu primeiro contato com uma linguagem back-end(lado servidor), foi com o PHP 4. E de início não foi com as boas práticas e com certeza não tinha nenhum vestígio de MVC. Com o tempo isso foi mundando, até por utilizar o Zend framework.O PHP foi criado em 1994, por [Rasmus Lerdorf](https://twitter.com/rasmus), e o código fonte liberado em 1995. E é mantido pela organização `The PHP Group`.> PHP (um acrônimo recursivo para 'PHP: Hypertext Preprocessor', originalmente Personal Home Page) é uma linguagem interpretada livre, usada originalmente apenas para o desenvolvimento de aplicações presentes e atuantes no lado do servidor, capazes de gerar conteúdo dinâmico na World Wide Web. > -- PHP > > - [Wikipédia](https://pt.wikipedia.org/wiki/PHP) > ## O ambientePrimeiramente para conseguirmos ver uma página em PHP funcionando, precisamos ter um servidor Apache/IIS (De preferência um servidor Apache, que muitos sugerem por ser melhor e para `URL Rewriting` se usa o .htaccess e não o web.config) configurado. Para fazer isso na nossa máquina local, tem softwares que ajudam nessa tarefa. Para windows, temos o [XAMPP](https://www.apachefriends.org/pt_br/index.html) e o [WAMP](http://www.wampserver.com/en/). Para mac, temos o [MAMP](https://www.mamp.info/en/). E para o linux, querendo ser mais `hardcore`, pode seguir esses [passos da Digital Ocean](https://www.digitalocean.com/community/tutorials/como-instalar-a-pilha-linux-apache-mysql-php-lamp-no-ubuntu-14-04-pt) para instalação via terminal.O necessário é ter o Apache e o PHP, instalados na máquina. Provalmente precisará de um banco de dados e isso fica por conta da necessidade do projeto. Querendo instalar manualmente, segue os links abaixo:- **_Apache_** - [http://www.apache.org/](http://www.apache.org/) - **_PHP_** - [http://php.net/downloads.php](http://php.net/downloads.php)Sugestões de banco de dados:- **_MySQL_** - [http://dev.mysql.com/downloads/](http://dev.mysql.com/downloads/) - **_PostGRE_** - [http://www.postgresql.org/](http://www.postgresql.org/)## SintaxeJá temos o ambiente e agora precisamos escrever nossas primeiras linhas para ver o PHP, funcionando. Pela lógica arquivos PHP, usaram a extensão `.php`.Podemos usar as tags `HTML`, normalmente como fazemos em arquivos de extensão '.html', mas para usarmos o código PHP, o mesmo deverá ser usado como vemos abaixo:``` Document '>Esse parágrafo tem uma classe inserida via uma função php```### VariávelUma variável no PHP, se inicia com o `$`(cifrão);As regras para nomeação, são bem simples:- Não iniciar com números - Sem espaços - Sem caracteres especiais, exceto `underscore```````## ConstanteTambém é possível definir constantes com a função `define()`. E ela não poderá ser alterado em sua execução. Como boa prática, é sempre boa que seja definida em letras maiúsculas para serem facilmente identificadas.``````## Echo ou PrintPara imprimir algo na tela, temos a função `echo` ou `print`.``` //index.php```Os 2 fazem a mesma coisa, sendo que a maior diferença fica por conta que o `print` também retorna `1` e o `echo` não retorna nada, além do que ele imprime. Podemos ver melhor isso, abaixo:``````O `echo` tem um atalho.```// É o mesmo que```O `print` pode ser usado com ternários, já o `echo`, não.``` $test = ($age ```No caso do `if/else`, se nenhuma condição for atendida, sempre o código contido no `else`, será executado. No caso do `switch/case`, se nenhuma condição for atendida, o `default`, será executado.## LoopsSão os laços de repetição que podemos executar, usando: for, while, do while e foreach.- **_for_** - Executa 3 operações (A primeira antes de executar a condição, onde podemos definir as variáveis que serão utilizadas. A segunda é a condição. E a terceira, o que fará se a condição for verdadeira.) - **_while_** - Só executamos uma operação que é a condição. Sendo verdadeira, executa o código. - **_do while_** - Ao contrário do `while`, primeiro executa o código para depois testar a condição. Como podemos ver no exemplo abaixo (que não faz sentido, apenas para exemplo), que ele executa o código, mesmo a condição sendo falsa. - **_foreach_** - Simplifica o trabalho com um `array`. Executando de acordo com a quantidade de posições do array, sem precisar informar. E já nos informa de uma vez, a chave e valor da posição.``` $value) { echo $key.' - '.$value.''; } // 0 - a // 1 - b // 2 - c // 3 - d ?> ```### Observações1. Para concatenarmos no PHP, usamos `.` .``` //index.php```2. Uma coisa muito importante no PHP, é sempre usar o `;`, após uma declaração. Você pode estar familiarizado com isso no `CSS` e no `Javascript`.``` //index.php```3. Podemos interferir no processo normal de um `loop`. Duas palavrinhas mágicas: `break` e `continue`. Como podemos ver abaixo, com o `break`, ele interrompe o processo quando a condição permite a execução do mesmo. No caso do `continue`, quando a condição é verdadeira e o mesmo é executado, ele vai para o próximo `loop`, não imprimindo o '0 - a'.``` // break $alpha = array('a', 'b', 'c', 'd'); foreach ($alpha as $key => $value) { echo $key.' - '.$value.''; if($value === 'b') { echo 'Parei na letra '.$value; break; } } // 0 - a // 1 - b // Parei na letra b// continue$alpha = array('a', 'b', 'c', 'd'); foreach ($alpha as $key => $value) { if ($value === 'a') continue; echo $key.' - '.$value.''; } // 1 - b // 2 - c // 3 - d ```## ConclusãoEssa foi uma pequena introdução ao PHP, nos próximos artigos mostrarei mais sobre a linguagem, frameworks e etc.
