# PHP para Iniciantes: Tipos de Dados Primitivos - Arrays

**Array** é uma das estruturas mais interessantes nas linguagens de computação. Amplamente utilizada para listar estruturas semelhantes, `array` é o primeiro tipo de dados que imaginamos quando precisamos criar conjuntos, matrizes e outras formas semelhantes. Mas sua usabilidade no PHP vai muito além!

Primeiro que todo array em PHP é definido como um *mapa ordenado*, onde, basicamente, todo valor é associado a uma chave. Não importa se você vai usar como **lista** ou **dicionário**. Absolutamente todos - eu disse TODOS - os casos serão valores atrelados a chaves.

> Como assim "chaves", Kiko?

![Depósito da Amazon](https://cdn.hashnode.com/res/hashnode/image/upload/v1628561540378/LB8YsvpMD.png)
<center>*(depósito da Amazon)*</center>

Imagine que cada caixa desse depósito é um "valor" e cada um possui uma etiqueta para auxiliar a identificar onde está. Essa etiqueta seria sua "chave". Da mesmíssima forma, temos o conceito de arrays: você precisa saber as chaves se quiser encontrar os valores. E se você não tiver a chave, você precisará percorrer por todos os elementos até encontrar alguma outra informação que identifique o item desejado.

Os valores podem ser... qualquer coisa. Qualquer tipo de dado, sério.
Já as chaves só tem duas opções: inteiros (`int`) ou textos (`string`), onde a preferência é sempre do inteiro.

> Como assim, preferência, Kiko?

Bem, a essa altura você já sabe o que é um `int` e uma `string`, certo? E se eu te falasse que existe também um `string int`? Hehe. Calma, não é um tipo de dado de verdade. É apenas uma forma de dizer que `'1' = 1`, por exemplo. O PHP consegue detectar que sua string é numérica e fazer a conversão para inteiro quando você atribuir isso como uma chave de array. Mas isso só irá acontecer se a string for numérica no domínio dos inteiros. No caso de `string float`, não fará nenhuma conversão (permanecerá `string`).

> E se for `float`, Kiko?

Aí o PHP irá arredondar para o número inteiro mais próximo. Se for `boolean`, será convertido para inteiro baseado no valor binário (`false = 0`, `true = 1`). Caso seja `null`, vira uma string vazia (`''`). Já outros tipos de dados, não podem ser inseridos em chaves ou teremos um belíssimo erro.

## Como escrever um array?

A notação do array é simples: `array()`, parecendo uma função (mas até aqui preciso presumir que você não sabe o que é uma função ainda, então considere apenas um spoiler). Há uma notação ainda mais simples: `[]`.

E no caso de criar um array previamente alimentado, basta inserir os elementos separados por vírgulas, podendo ter uma vírgula no final (opcional). Por exemplo:

```php
<?php
$array = array(1,2,3,4);
$array = [1,2,3,4];
$array = [
    1,
    2,
    3,
    4,
];
```

Todos os arrays mencionados acima são iguais, todos possuem quatro elementos, sendo eles os inteiros `1`, `2`, `3` e `4`.

> Ué, Kiko, cadê as chaves? Só vejo valores.

Quando você não informa nenhuma chave, o PHP atribui automaticamente um valor inteiro de acordo com a maior chave numérica **que já existiu no array** + 1. O primeiro índice numérico, caso não tenha um, será sempre a partir de 0. Mas você também pode informar índices negativos se quiser **¯\\\_(ツ)_/¯**

> Tá, mas como atribuímos uma chave?

```php
<?php
$array = [
    0 => 1,
    1 => 2,
    2 => 3,
    3 => 4,
];
```
A notação `algumacoisa => outracoisa` dentro da notação de arrays é pré-definição `chave => valor`. Isso também é algo encontrado na notação de `foreach`, mas não vamos falar sobre isso agora.

E sobre o exemplo citado agora, também é igual aos outros arrays.

Que tal explorarmos mais algumas loucuras? Considere o array abaixo:

```php
<?php
$array = [
    1 => 'um',
    1.5 => 'dois',
    '1' => 'tres',
    true => 'quatro',
];
echo $array[1];
```

Qual é o valor impresso?

**Re: `quatro`**

> QUÊ?!

É verdade. Na hora da construção do array, acontecem os seguintes passos:

1. Primeiramente, o array é inicializado sem nenhum dado;
2. Depois, o array recebe a linha `1 => 'um'` e atribui o valor string `'um'` à chave int `1`;
3. Então, o array recebe a linha `1.5 => 'dois'`. Sendo um valor do tipo `float`, ele arredonda para o número inteiro mais próximo, que é o `1`. Com isso, atribui o valor string `'dois'` à chave int `1` - que já existe, então ele sobreescreve o valor que estava antes;
4. Daí, o array recebe a linha `'1' => 'tres'`. Sendo um valor do tipo `string` e sendo numérico do domínio de inteiros, o interpretador converte para `int`, ficando `1`. Com isso, atribuo o valor string `'tres'` à chave int `1` - que já existe, logo sobreescreve.
5. Por fim, o array recebe a linha `true => 'quatro'`. Sendo um valor do tipo `boolean`, o interpretador usa seu valor binário para converter para inteiro, que é, mais uma vez, `1`. Logo atribui o valor string `'quatro'` à chave int `1` - que já existe, portanto sobreescreve.

Por isso, no final, o único dado que existe é a string `'quatro'` na chave int `1`.

Além disso, tem casos mais hilários, como:

```php
<?php

$array = [
     'um',
     6 => 'dois',
     'tres',
     7 => 'quatro',
];
```

Nesse caso, temos no final:
```
0 => 'um'
6 => 'dois'
7 => 'quatro'
```

> Ué, cadê o `'tres'`, Kiko?

**Re: O `'quatro'` sobreescreveu!**

## Acessando valores

Se você sabe a chave que deseja acessar, a sintaxe que você pode utilizar para resgatar o valor é com os colchetes `[` e `]`. Lembra que mencionei isso lá no artigo sobre `strings`? A forma de resgatar um caractere de um texto é similar a resgatar um valor de um `array`.

Dito e feito:

```php
<?php
$array = [1, 2, 3, 4];
echo $array[3]; // o primeiro índice é o 0, portanto, irá imprimir 4
```

> Mas Kiko, e se o valor acessado for um array?

Então você poderá acessar o valor desse array sabendo a chave dele também!

```php
<?php
$array = [array(1, 2, 3, 4)];
echo $array[0][3]; // vai imprimir 4
```

Por sinal, essa é uma estrutura de matrizes.

## Alterando valores

Para alterar, iremos usar a mesma sintaxe acima, exceto que, ao invés de apenas obtermos um dado, iremos atribuir o valor da mesma forma que atribuímos em **variáveis**. Como, teoricamente, você ainda não sabe o que é uma variável, vamos tentar uma explicação na base dos exemplos:

```php
<?php
$array = [1, 2, 3, 4]; // sim, eu gosto desse exemplo
$array[3] = 5; // sobreescrevemos o valor do índice 3 por 5
$array[] = 6; // adicionamos o valor 6 ao final do array, baseado no índice numérico mais alto (que é o 3, portanto, o valor foi atribuído à chave int 4)
```

No exemplo acima, temos, ao final:

``` 
0 => 1
1 => 2
2 => 3
3 => 5
4 => 6
```

Algumas observações interessantes:

- Se você inserir um valor numa chave que não existe, ela será criada;
- Se você usar a sintaxe de `append` (`$array[] = `) numa variável que não foi definida, ela será inicializada como array. **Apesar de saber que isso é possível, eu espero com todas as forças da minha consciência que você não faça isso. Sempre declare o array antes!**

## Removendo valores

Infelizmente não há uma forma tão prática de remover arrays. Porém, há uma função nativa que faz isso pra gente, que é a função `unset`. Se você passar o array inteiro, ela irá "*apagar*" tudo. Se você passar um array consultando um índice, ela irá "*apagar*" aquele índice específico. Por exemplo:

```php
<?php
$array = [1, 2, 3, 4];
unset($array[3]); // remove o índice 3, ficando [1, 2, 3]
unset($array); // remove todo o array
```

Mais observações interessantes:

- Remover um array inteiro (`unset($array)`) não irá apenas remover seus elementos. Irá desconstruir toda a variável, deixando, inclusive, de ser um array;
- Ao fazer o `unset` de um índice numérico e fazer um novo `append`, se o índice removido era o maior, então o `append` irá continuar a partir do número removido. Isso significa que o que vale pro `append` é a maior chave `int` que já **existiu** e não a que existe no momento. Por exemplo:
    ```php
    <?php
    $array = [1, 2, 3, 4];
    unset($array[3]); // remove o 4
    $array[] = 5; // adiciona o 4 => 5
    ```

E por enquanto é só! Tem muito mais conteúdo na [documentação oficial sobre arrays no PHP.net](https://www.php.net/manual/pt_BR/language.types.array.php), mas, na minha visão, não são assuntos adequados para iniciantes. Já mencionam funções e informações depreciadas de arrays em versões mais antigas do PHP. Faz sentido mostrar coisas de versões antigas para quem tá começando agora? **Eu acho que não**. Espero que concordem comigo, rs.

Se restou alguma dúvida, não hesite em perguntar nos comentários! Irei responder assim que possível, beleza?

**Inté!**