
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ção

O [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ção

Primeiramente, 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 tabelas

O 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ão

O 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.


Começando com Wordpress


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ção

Pré-requisitos:

- PHP >= 5.5.9
- OpenSSL PHP Extension
- PDO PHP Extension
- Mbstring PHP Extension
- PHP Extension

### Composer

O 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 projeto

Para criar um novo projeto, usamos o comando:

```bash
# new [nome do projeto]
laravel new Example
```

## Configuração

Vou 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ção

Para 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ções

Na 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ão

Essa é 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.


Começando com Laravel

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
<?php
class Person {
 // conteúdo da classe
}
?>
```

## Atributos/Propriedades

Sã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
<?php
// person.php
class Person {
 public $name;
 public $cpf;
 public $age;
}
?>
```

## Métodos

Sã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`.

### Construtor

O construtor da classe é um bloco declarado com o mesmo nome que a classe.

```php
<?php
// person.php
class Person {
 public $name;
 public $cpf;
 public $age;

 //construtor da classe
 function Person(){
 $this->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
<?php
require_once 'person.php';

$person = new Person();

echo $person->name;
// Hemerson
echo $person->getMessage();
// Meu nome é Hemerson
?>
```

## Métodos Mágicos

Ao 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
<?php
class Person {
 public $name = "Hemerson";

 public function __construct(){
 echo 'Meu nome é ' . $this->name .' e a classe ' . __CLASS__ . ' foi instanciada';
 }
}

$person = new Person();
// Meu nome é Hemerson e a classe Person foi instanciada
?>
```

## Herança de Classe

Na Orientação a objetos, as classes podem herdar métodos e propriedades de outra classe. Isso é possível utilizando a palavra chave `extends`.

```php
<?php
class Person {
 public $name = "Hemerson";
 public $cpf = "123.123.123-22";
 public $age = 29;

 function __construct(){
 echo 'Essa classe é a ' . __CLASS__;
 }

 function getMessage(){
 return 'Meu nome é ' . $this->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
<?php
class Person {
 public $message = "Eu sou o Hemerson";

 public function __construct(){
 echo 'Essa classe é a ' . __CLASS__;
 }

 public function getMessage(){
 return $this->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étodos

A 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
<?php
class Person {
 public $name = 'Hemerson';
 protected $cpf = '123.123.123-22';
 private $status = true;

 function __construct(){
 }
}

class Example extends Person {
 function __construct(){
 }

 function getCpf(){
 return $this->cpf;
 }

 function getStatus(){
 return $this->status;
 }
}

$person = new Person();
$example = new Example();

echo $person->name; // Hemerson

echo $example->name; // Hemerson
echo $example->getCpf(); // 123.123.123-22
echo $example->cpf; // FATAL ERROR Cannot access protected property Example::$cpf

echo $example->getStatus(); // Undefined property: Example::$status
?>
```

Agora um exemplo com a adição da palavra chave `static`:

```php
<?php
class Person {
 public static $message = 'Teste';

 public static function exampleMethod() {
 return self::$message;
 }
}

print Person::$message; // Teste

$person = new Person();

print $person->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ão

Programaçã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.

PHP - Orientação a objetos

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 arrays

Uma 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 / Associativo

Um `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 / Multidimensional

Os `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âmicos

Já 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'
```

## Foreach

Funciona 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 Array

O `array` é muito usado no PHP. Por esse motivo, tem muitas funções nativas da linguagem, que podemos utilizar.

### sort

Essa 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 ] )

<?php
$items = array("item1", "item2", "item3", "item4");
sort($items);
foreach ($items as $key => $val) {
 echo "items[" . $key . "] = " . $val . "\n";
}
?>

// items[0] = item4
// items[1] = item3
// items[2] = item1
// items[3] = item2
```

### rsort

Essa função ordena um array em ordem descrescente (do maior para o menor).

```php
// bool rsort ( array &$array [, int $sort_flags ] )

<?php
$items = array("item1", "item2", "item3", "item4");
rsort($items);
foreach ($items as $key => $val) {
 echo "$key = $val\n";
}
?>

// 0 = item2
// 1 = item1
// 2 = item3
// 3 = item4

```

### asort

Essa 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 ] )

<?php
$items = array("d" => "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
```

### arsort

Esta 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 ] )

<?php
$items = array("d" => "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
```

### ksort

Ordena 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 ] )

<?php
$items = array("d"=>"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
```

### krsort

Ordena 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 ] )

<?php
$items = array("d"=>"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
```

### usort

Essa 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 )

<?php
function cmp($a, $b) {
	if ($a == $b) {
		return 0;
	}
	return ($a < $b) ? -1 : 1;
}

$a = array(3, 2, 5, 6, 1);

usort($a, "cmp");

foreach ($a as $key => $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 )

<?php
$a = array(2, 4, 6, 8);
echo "sum(a) = " . array_sum($a) . "\n";

$b = array("a" => 1.2, "b" => 2.3, "c" => 3.4);
echo "sum(b) = " . array_sum($b) . "\n";
?>

// sum(a) = 20
// sum(b) = 6.9
```

### array_unique

Recebe o argumento array e retorna um novo array sem valores duplicados.

```php
// array array_unique ( array $array )

<?php
$input = array("a" => "green", "red", "b" => "green", "blue", "red");
$result = array_unique($input);
print_r($result);
?>

// Array
// (
// [a] => green
// [0] => red
// [1] => blue
// )
```

### in_array

Procura no array, pelo valor informado.

```php
// bool in_array ( mixed $needle , array $haystack [, bool $strict ] )

<?php
$os = array("Mac", "NT", "Irix", "Linux");
if (in_array("Irix", $os)) {
 echo "Got Irix";
}
if (in_array("mac", $os)) {
 echo "Got mac";
}
?>

// Got Irix
```

### array_search

Procura no array, pelo valor informado.

```php
// mixed array_search ( mixed $needle , array $haystack [, bool $strict ] )

<?php
$array = array(0 => '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 ] )

<?php
$input = array("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
$rand_keys = array_rand($input, 2);
echo $input[$rand_keys[0]] . "\n";
echo $input[$rand_keys[1]] . "\n";
?>

```

### array_merge

Funde 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 $... ]] )

<?php
$array1 = array("color" => "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_walk

Aplica 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 ] )

<?php
function myfunction($value,$key){
echo "The key $key has the value $value ";
}
$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
```

### count

Conta os elementos de um array.

```php
// int count ( mixed $var [, int $mode ] )

<?php
$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
$result = count($a);
// $result == 3
?>
```

### shuffle

Essa função mistura de forma aleatória os elementos de um array.

```php
// bool shuffle ( array &$array )

<?php
$numbers = range(1, 20);
shuffle($numbers);
foreach ($numbers as $number) {
	echo "$number ";
}
?>

// 15 9 18 19 12 16 4 17 20 1 5 13 8 6 7 3 11 2 14 10
```

### extract

Importar 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 ]] )

<?php

$size = "large";
$var_array = array("color" => "blue",
 "size" => "medium",
 "shape" => "sphere");
extract($var_array, EXTR_PREFIX_SAME, "wddx");

echo "$color, $size, $shape, $wddx_size\n";

// blue, large, sphere, medium
?>

```

### compact

Cria um array contendo variáveis e seus valores.

```php
// array compact ( mixed $varname [, mixed $... ] )

<?php
$city = "San Francisco";
$state = "CA";
$event = "SIGGRAPH";

$location_vars = array("city", "state");

$result = compact("event", "nothing_here", $location_vars);
print_r($result);
?>

// Array
// (
// [event] => SIGGRAPH
// [city] => San Francisco
// [state] => CA
// )
```

## Referências

- [PHP Documentation](http://php.net/docs.php) - Manual do PHP

## Conclusão

Se 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.

PHP - Entendendo o array

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.

### echo

Permite vários parâmetros.

```php
<?php
echo "test", "test2", "test3";
// testtest2test3
echo("test2");
// test2
?>
```

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";?>
// Test
```

### print

Retorna 1 após o envio da saída, pode ser usada em expressões e permite apenas um parâmetro.

```php
<?php
$example = print("print");
// print
echo $example;
// 1
?>
```

## Escape

No 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
<?php
echo "test 'string' ";
// test 'string'
echo 'test "string" ';
// test "string"

// Escape
echo "test \"string\" ";
// test "string"
?>
```

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
<?php
echo "execute $test ";
// Notice: Undefined variable: test in ..........
?>
```

Com o `escape`, temos o resultado esperado.

```php
<?php
echo "execute \$test ";
// execute $test
?>
```

É 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
<?php
echo "line \n new line";
// line
// new line

echo 'line \n new line';
// line \n new line
?>
```

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
<pre>
<?php
echo "line \n new line ";
// line
// new line
?>
</pre>

<?php
echo "line new line ";
// line
// new line
?>
```

## Algumas funções de string

Vamos 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.

### ltrim

Retira espaço em branco (ou outros caracteres) do início de uma string.

```php
// string ltrim ( string $str [, string $character_mask ] )
<?php
$string = " Teste";
var_dump(ltrim($string));
?>

// string(5) "Teste"
```

### rtrim

Esta função retorna uma string com espaços em branco retirados do final da string.

```php
// string rtrim ( string $str [, string $character_mask ] )
<?php
$string = "Teste ";
var_dump(rtrim($string));
?>

// string(5) "Teste"
```

### trim

Esta 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" ] )
<?php
$string = " Teste ";
var_dump(trim($string));
?>

// string(5) "Teste"
```

### ucwords

Retorna 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" ] )
<?php
$string = "Teste para a função";
var_dump(ucwords($string));
?>

// string(21) "Teste Para A Função"
```

### srttoupper

Retorna 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 )
<?php
// setlocale(LC_CTYPE, 'C'); // C = padrão PHP
$string = "Teste para a função";
var_dump(strtoupper($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
<?php
setlocale(LC_ALL, 'pt_BR');
$string = "Teste para a função";
var_dump(strtoupper($string));
?>

// string(21) "TESTE PARA A FUNÇÃO"
```

### srttolower

Retorna 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 )
<?php
setlocale(LC_ALL, 'pt_BR');
$string = "TESTE PARA A FUNÇÃO";
var_dump(srttolower($string));
?>

// string(21) "teste para a função"
```

### ucfirst

Retorna uma string com o primeiro caractere em maiúscula, se o caractere for do alfabeto.

```php
// string ucfirst ( string $str )
<?php
$string = "teste";
var_dump(ucfirst($string));
?>

// string(5) "Teste"
```

### lcfirst

Retorna uma string com o primeiro caractere em letra minúscula se o caractere for alfabético.

```php
// string lcfirst ( string $str )
<?php
$string = "TESTE";
var_dump(lcfirst($string));
?>

// string(5) "tESTE"
```

### str_word_count

Conta 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 ]] )
<?php
$string = "TESTE de nada";
var_dump(str_word_count($string));
?>

// int(3)
```

### strlen

Retorna o tamanho da string.

```php
// int strlen ( string $string )
<?php
$string = "TESTE de nada";
var_dump(strlen($string));
?>

// int(13)
```

### strstr

Retorna 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 ] )
<?php
$string = "TESTE de nada";
var_dump(strstr($string, 'de'));
?>

// string(7) "de nada"
```

### stristr

Retorna tudo de haystack a partir da primeira ocorrência de needle até o final.

```php
// string stristr ( string $haystack , mixed $needle [, bool $before_needle ] )
<?php
$string = "TESTE de nada";
var_dump(stristr($string, 'de'));
?>

// string(7) "de nada"
```

### strpos

Retorna 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 ] )
<?php
$string = "TESTE de nada";
var_dump(strpos($string, 'de'));
?>

// int(6)
```

### substr

Retorna a parte de string especificada pelo parâmetro start e length.

```php
// string substr ( string $string , int $start [, int $length ] )
<?php
$string = "TESTE de nada";
var_dump(substr($string, 0, -1));
?>

// string(12) "TESTE de nad"
```

### str_replace

Esta 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 ] )
<?php
$string = "TESTE de nada";
var_dump(str_replace("nada","tudo", $string));
?>

// string(13) "TESTE de tudo"
```

### strip_tags

Esta 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 ] )
<?php
$string = "nada";
var_dump(strip_tags($string, ""));
?>

// string(11) "
//
// nada
// "
```

### addslashes

Retorna 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 )
<?php
$string = "d'agua";
var_dump(addslashes($string));
?>

// string(7) "d\'agua"
```

### stripslashes

Remove barras invertidas de uma string.

```php
// string stripslashes ( string $str )
<?php
$string = "d'agua";
var_dump(stripslashes($string));
?>

// string(6) "d'agua"
```

### htmlentities

Esta 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 ]]] )
<?php
$string = "'teste' de nada";
var_dump(htmlentities($string));
?>

// string(34) "'teste' de &lt;b&gt;nada&lt;/b&gt"
```

### html_entity_decode

html_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 ]] )
<?php
$string = "'teste' de &lt;b&gt;nada&lt;/b&gt";
var_dump(html_entity_decode($string));
?>

// string(23) "'teste' de nada"
```

### str_shuffle

str_shuffle() mistura uma string. Uma permutação de todas as possibilidades é criada.

```php
// string str_shuffle ( string $str )
<?php
$string = "abcdef";
var_dump(str_shuffle($string));
?>

// string(6) "fcebad"
```

### md5

Calcula 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 ] )
<?php
$string = "abcdef";
var_dump(md5($string));
?>

// string(32) "e80b5017098950fc58aad83c8c14978e"
```

### sha1

Calcula 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 ] )
<?php
$string = "abcdef";
var_dump(sha1($string));
?>

// string(40) "1f8ac10f23c5b5bc1167bda84b833e5c057a77d2"
```

## Conclusão

Há 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.

PHP - Trabalhando com string

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.
> <cite> -- PHP
>
> - [Wikipédia](https://pt.wikipedia.org/wiki/PHP) > </cite>

## O ambiente

Primeiramente 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/)

## Sintaxe

Já 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:

```
<!DOCTYPE html>
	<html lang="pt-br">
	<head>
		<meta charset="utf-8">
		<title>Document</title>
	</head>
	<body>
		<?php
			// script php
		?>

		">Esse parágrafo tem uma classe inserida via uma função php
	</body>
</html>
```

### Variável

Uma 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`

```
<?php
	$name = "Meu nome";
	$age = 29;
	$account_status = true;
?>
```

## Constante

També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.

```
<?php
	define("VALOR", "Esse é o valor");
	echo VALOR; // Esse é o valor
?>
```

## Echo ou Print

Para imprimir algo na tela, temos a função `echo` ou `print`.

```
//index.php

<?php
	echo "Esse texto vai aparecer na minha página inicial";
	echo("Esse texto vai aparecer na minha página inicial");

	print "Esse texto vai aparecer na minha página inicial";
	print("Esse texto vai aparecer na minha página inicial");

	// Retornará 4 vezes na tela a frase "Esse texto vai aparecer na minha página inicial"
?>
```

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:

```
<?php
 echo print('Teste');
 // Teste1

 $test = print("Teste");
 if ($test) echo 'entrou';
	// Testeentrou
?>
```

O `echo` tem um atalho.

```
<? echo "exemplo" ?>
// É o mesmo que
<?="exemplo" ?>
```

O `print` pode ser usado com ternários, já o `echo`, não.

```
$test = ($age < 18) ? print('menor') : print('maior'); //válido

$test = ($age < 18) ? echo('menor') : echo('maior'); //inválido,
Parse error: syntax error, unexpected T_ECHO
```

Utilizando o `echo`, estará economizando `1 byte` e precisando receber um valor de retorno ou utilizar com um ternário, temos o `print`.

## Estruturas condicionais

Temos o famoso `if/else` e o `switch/case`. Se já mexeu em outras linguagens de programação, já terá uma familiaridade. Se em um determinado trecho do seu código for necessário ter muitas condições em um mesmo ponto, o mais indicado é o `switch/case`, para que o seu código não tenha um `hadouken`. :)

```
<?php
// if/else
if ([condição]) {
	//seu código aqui
} else {
	//seu código aqui
}

if ([condição]) {
	//seu código aqui
} elseif([outra condição]) {
	//seu código aqui
} else {
	//seu código aqui
}

// swicth/case
$item = 3;

switch ($item) {
 case 1:
 echo "Item 1";
 break;
 case 2:
 echo "Item 2";
 break;
 case 3: // condição
 echo "Item 3"; // código que será executado
 break; // Finaliza a execução
 case 4:
 echo "Item 4";
 break;
 case 5:
 echo "Item 5";
 break;
 default:
 echo "Nenhum item";
 break;
}
?>
```

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.

## Loops

Sã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.

```
<?php
for ($i=0, $len = 5; $i < len; $i++) {
 echo $i;
}
// 01234

$value = 1;
$max = 5;
while ($value <= $max) {
	echo $value;
	$value++;
}
// 12345

$count = 1;
do{
 echo "Loop número $count";
} while ($count < 1);
// Loop número 1

$alpha = array('a', 'b', 'c', 'd');
foreach ($alpha as $key => $value) {
 echo $key." - ".$value." ";
}
// 0 - a
// 1 - b
// 2 - c
// 3 - d
?>
```

### Observações

1. Para concatenarmos no PHP, usamos `.` .

```
//index.php

<?php
	echo "Esse texto vai aparecer na minha página inicial. " . "E esse texto também.";
?>
```

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

<?php
	// sem
	define('PHP', 'de boas') echo PHP
	//Parse error: syntax error, unexpected T_ECHO

	// com
	define('PHP', 'de boas'); echo PHP;
	// de boas
?>
```

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ão

Essa foi uma pequena introdução ao PHP, nos próximos artigos mostrarei mais sobre a linguagem, frameworks e etc.

UI2CodeGo to Home Page

Php

Compartilhar

Compartilhar

Compartilhar

Compartilhar

Compartilhar

Compartilhar