https://github.com/monicaquintal/estudandophp

Estudo da Seção 11: PHP, do Curso de Desenvolvimento Web Completo.
https://github.com/monicaquintal/estudandophp

php

Last synced: about 1 month ago
JSON representation

Estudo da Seção 11: PHP, do Curso de Desenvolvimento Web Completo.

• Host: GitHub
• URL: https://github.com/monicaquintal/estudandophp
• Owner: monicaquintal
• Created: 2023-01-08T01:29:44.000Z (almost 2 years ago)
• Default Branch: main
• Last Pushed: 2023-01-26T01:19:21.000Z (almost 2 years ago)
• Last Synced: 2024-04-18T03:19:47.795Z (8 months ago)
• Topics: php
• Language: PHP
• Homepage:
• Size: 75.2 KB
• Stars: 2
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: readme.md

Awesome Lists containing this project

README

        


Estudando PHP 🐘

Seção 11: PHP

Curso Desenvolvimento Web Completo 2022.





## Introdução ao PHP

Aula 01: O que é PHP?


Aula 02: Embutindo blocos PHP em páginas HTML


Aula 03: Habilitando e testando tags curtas (short_open_tag)


Aula 04: Saída de dados com echo() e print()


Aula 05: Funcionamento do PHP um pouco mais a fundo (páginas estáticas x dinâmicas)


Aula 06: Comentários


Aula 07: Variáveis - introdução


Aula 08: Variáveis - prática


Aula 09: Alterando valores de variáveis


Aula 10: Concatenação


Aula 11: Variáveis constantes


Aula 12: If/else parte 1 - Introdução


Aula 13: Operadores de comparação (condicionais)


Aula 14: If/else parte 2 - Praticando com operadores de comparação


Aula 15: Operadores lógicos


Aula 16: If/else parte 3 - Praticando com operadores lógicos


Aula 17: If/else parte 4 - Praticando um pouco mais


Aula 18: If/else parte 5 - Condições encadeadas


Aula 19: Operador ternário


Aula 20: Atividades para fixação do conteúdo


Aula 21: Switch


Aula 22: Switch na prática


Aula 23: Casting de tipos com (int), (bool), (float) e (string)


Aula 24: Operadores aritméticos


Aula 25: Praticando com operadores aritméticos


Aula 26: Operações aritméticas na atribuição de valores


Aula 27: Operadores de incremento/decremento


Aula 28: Praticando com operadores de incremento/decremento


Aula 29: Funções - Introdução


Aula 30: Funções - Prática


Aula 31: Atividades para fixação do conteúdo


Aula 32: Funções nativas para manipular strings


Aula 33: Funções nativas para tarefas matemáticas


Aula 34: Funções nativas para manipular datas


Aula 35: Array básico - Introdução


Aula 36: Array básico - Prática


Aula 37: Array multidimensional


Aula 38: Array - Métodos de pesquisa


Aula 39: Extra - False, Null e Empty


Aula 40: Funções nativas para manipular arrays


Aula 41: Loops parte 1 - Introdução


Aula 42: Loops parte 2 - While


Aula 43: Loops parte 3 - Do while


Aula 44: Loops parte 4 - For


Aula 45: Praticando um pouco - Percorrendo arrays


Aula 46: Loops parte 5 - Foreach


Aula 47: Praticando um pouco - Foreach em arrays associativos e Foreach encadeados


Aula 48: Atividades para fixação de conteúdo


## Extra:

[Aplicação desenvolvida ao término do módulo](https://github.com/monicaquintal/app-help-desk).

[Continuação do estudo, com PHP e Orientação a Objetos](https://github.com/monicaquintal/estudandoPHP-orientacao-a-objetos).





Aula 01: O que é PHP?



PHP = "Hypertext Preprocessor"; seu uso é livre.

É uma linguagem de programação focada na criação de aplicações do lado do servidor.

Pode ser utilizado:

- diretamente na linha de comando (scripts de linha e comando, que podem ser executados diretamente pelo shell do SO);

- aplicações desktop (PHP - GTK);

- aplicações server-side (scripts).

É uma linguagem de programação interpretada e não compilada; ou seja, os scripts da aplicação não serão submetidos a uma compilação prrévia a fim de gerar um executável; serão interpretados em tempo de requisição das páginas.

É compatível com diversos SOs, e acrita tanto paradigma estrutural quanto orientado a objeto.

Tem suporte a diversos BDs, e tem vasto suporte a diversos protocolos de comunicação.

[Documentação PHP!](https://www.php.net/)





Aula 02: Embutindo blocos PHP em páginas HTML



Formas de inclusão do PHP em arquivos HTML:



|       NOME       |             TAG              |          STATUS           |

| :--------------: | :--------------------------: | :-----------------------: |

|    Tag padrão    |  <?php código aqui ?>  |        Habilitada         |

| Tag de impressão | <?= php código aqui ?> |        Habilitada         |

|    Tag curta     |   <? código aqui ?>    |       Desabilitada        |

|    \*Asp tag     |   <% código aqui %>    | Descontinuada na versão 7 |







Aula 03: Habilitando e testando tags curtas (short_open_tag)



A tag curta não está mais disponível na versão 8 do PHP! Utilizar a tag padrão:

```php

```





Aula 04: Saída de dados com echo() e print()



Ambos possuem o objetivo de imprimir conteúdos advindos do bloco de código PHP dentro do arquivo HTML que é entregue ao usuário.

Podemos utilizar aspas simples ou duplas.

A última instrução não precisa de ";".

Echo é um construtor de linguagem, enquanto o print inicialmente era uuma função.

```php

';

  print 'Comando print
';

?>

```


> arquivo echo_print.php





Aula 05: Funcionamento do PHP um pouco mais a fundo (páginas estáticas x dinâmicas)



Páginas estáticas são arquivos HTML com codificação hardcode, sem tratativas no arquivo, enquanto páginas web dinâmicas são páginas produzidas no intervalo entre a requisição e a resposta que é recebida e devolvida pelo servidor HTTP (nesse caso, o Apache).

Se a solicitação recebida for um arquivo PHP, então repassa a solicitação para o interpretador do PHP. Isso faz com que abra o script solicitado, interprete e devolva o retorno (uma página HTML) ao Apache.





Aula 06: Comentários



Importante para manutenção de estruturas e documentação.

```php

// comentário de uma linha

# comentário de uma linha no estilo shell

/*

  Comentário de

  múltiplas linhas

*/

```

> arquivo comentarios.php





Aula 07: Variáveis - Introdução



**Variáveis** são utilizadas para armazenamento de dados. Em PHP, há tipos específicos de variáveis (que definem o tipo de dado que está presente na variável): string, int, float, boolean, array, ...

Regras para declaração de variáveis em PHP:

- deve obigatoriamente iniciar com o caractere **$**.

- não pode conter espaços ou caracteres especiais (com exceção do underline).

Não requer (ou suporte) a definição explícita de tipo. O PHP tem a inteligência para identificar o tipo de variável no momento da atribuição do valor (a tipagem é dinâmica).

Case sensitive!!!

Exemplos: $nome, $fone1, $endereco_2





Aula 08: Variáveis - Prática (string, int, float e boolean).



> arquivo variaveis.php

```php

Ficha cadastral

Nome: = $nome ?>

Idade: = $idade ?>

Altura: = $altura ?>

Fumante? = $fumante ?>

```






Aula 09: Alterando valores de variáveis.



> arquivo variaveis.php

Em qualquer momento da lógica do script poderemos alterar os valores das variáveis. A alteração também pode ocorrer a nível de tipo (característico de linguagens de tipagem fraca).





Aula 10: Concatenação.



> arquivo concatenacao.php

A concatenação é realizada a partir do operador "**.**"!

Também podemos utilizar aspas duplas para fazer a concatenação de cadeias de caracteres com valores de variáveis.

(não se aplica a aspas simples!!!)

Como aspas simples não dão margem pra concatenação em seu interior (apenas com .), são mais rápidas que as duplas (que sempre serão verificadas)!

```php

$nome = "Mônica";

$idade = 31;

$cor = "rosa";

// para concatenação, usar o operador "."

echo "Olá, meu nome é " . $nome . "! Tenho " . $idade . " anos e minha cor favorita é " . $cor . ". :)";

echo "
";

// utilização de aspas duplas para concatenação

echo "Olá, $nome! Tudo bem?"

```





Aula 11: Variáveis constantes.



São variáveis cujos valores não podem ser modificados (não podem ser sobrepostos). Geralmente são utilizadas para parametrização de informações de ambiente da aplicação (ambiente de desenvolvimento). Dão uma maior segurança ao código (quando migramos ao ambiente de produção, por exemplo).

> arquivo variaveis_constantes.php

Para criação de variáveis constantes, utilizar a função **define()**, que tem dois parâmetros:

- nome da variável (em formato de string);

- e valor!

Sempre utilizar _caracteres maiúsculos_ (boas práticas)!

Não é necessário utilizar $.

```php

define('BD_URL', 'endereco_bd_dev');

define('BD_USUARIO', 'usuario_dev');

define('BD_SENHA', 'senha_dev');

echo BD_URL . '
';

echo BD_USUARIO . '
';

echo BD_SENHA;

```





Aula 12: If/else parte 1 - Introdução.



É uma estrutura de controle, que permite definir o fluxo que a aplicação tomará, a partir de uma determinada condição.

A instrução else é opcional.

Sintaxe:

```

if (condição) {

  // trecho de código que será executado

} else {

  // trecho de código que será executado

}

```

Encadeado:

```

if (condição) {

  // trecho de código que será executado

} else if (condicão) {

  // trecho de código que será executado

} else {

  // trecho de código que será executado

}

```





Aula 13: Operadores de comparação (condicionais).



Também conhecidos como operadores relacionais, são capazes de formar as expressões condicionais, que serão colocadas dentro dos comandos if.

São eles (9):

| OPERADOR     | REPRESENTAÇÃO | SIGNIFICADO                                                            |

| ------------ | :-----------: | ---------------------------------------------------------------------- |

| Igual        |      ==       | Verifica se os valores comparados são iguais                           |

| Idêntico     |      ===      | Verifica se os valores comparados são iguais e do mesmo tipo           |

| Diferente    |      !=       | Verifica se os valores comparados são diferentes                       |

| Diferente    |   <>    | Verifica se os valores comparados são diferentes                       |

| Não idêntico |      !==      | Verifica se os valores comparados são diferentes e de tipos diferentes |

| Menor        |     <      | Verifica se o valor da esquerda é menor que o da direita               |

| Maior        |     >      | Verifica se o valor da esquerda é maior que o da direita               |

| Menor igual  |     <=     | Verifica se o valor da esquerda é menor ou igual ao da direita         |

| Maior igual  |     >=     | Verifica se o valor da esquerda é maior ou igual ao da direita         |





Aula 14: If/else parte 2: Praticando com operadores de comparação.



> arquivo ifelse_operadores_condicionais.php

Aplicação dos operadores de comparação apresentados na aula anterior.

Podemos omitir as chaves, caso o if possua apenas uma instrução. Entretanto, recomenda-se sempre abrir e fechar as chaves (para definir o bloco de código explicitamente).





Aula 15: Operadores lógicos.



Operadores lógicos permitem conectar operações de comparação, a fim de criar condições mais exigentes.

| OPERADOR |   REPRESENTAÇÃO    | SIGNIFICADO                                         |

| :------: | :----------------: | --------------------------------------------------- |

|    E     |     AND ou &&      | V se todas as expressões forem V                    |

|    OU    | OR ou || | V se pelo menos uma das expressões for V            |

|   Xor    |        XOR         | V apenas se uma das expressões for V, mas não ambas |

| Negação  |         !          | Inverte o resultado da expressão                    |





Aula 16: If/else parte 3 - Praticando com operadores lógicos.



> arquivo ifelse_operadores_logicos.php

Operadores lógicos podem conectar de 2 a n operações de comparação!

Os parênteses permitem estabelecer precedência (o interpretador lerá primeiro o que está nos parênteses, e inicialmente os mais internos).

```php

// E - && (retorna V se todos os resultados forem V)

if(5 == 3 && 10 > 3) {

  echo 'Verdadeiro';

} else {

  echo 'Falso';

}

```

```php

// OU - || (retorna V se pelo menos um dos resultados for V)

if(5 == 5 || 10 < 3) {

  echo 'Verdadeiro';

} else {

  echo 'Falso';

}

```

```php

// XOR - XOR (V se uma das expressões for V e a outra F, ou vice-versa).

if(5 == 5 XOR 10 > 3) {

  echo 'Verdadeiro';

} else {

  echo 'Falso';

}

```

```php

// negação - ! (inverte o resultado da expressão)

if(!('a' == 'b')) {

  echo 'Verdadeiro';

} else {

  echo 'Falso';

}

```





Aula 17: If/else parte 4 - Praticando um pouco mais.



> arquivo ifelse_praticando_mais_um_pouco.php

Exemplo de uma situação em um e-commerce, onde: é dado frete gratuito se o usuário possuir o cartão da loja E se o valor da compra for maior que 100 reais.

Obs: se for testar variável do tipo booleana dentro de um operador lógico, não precisamos compararcom "==", apenas indicar a variável.

```php

= 100) {

  $valor_frete = 0;

  $recebeu_desconto_frete = true;

}

?>

Detalhes do pedido

Possui cartão da loja?



Valor da compra: = $valor_compra?>


Recebeu desconto no frete?



Valor do frete: = $valor_frete?>

```






Aula 18: If/else parte 5 - Condições encadeadas.



> arquivo ifelse_praticando_mais_um_pouco.php

```php

= 400) {

      $valor_frete = 0;

  } else if ($usuario_possui_cartao_loja  && $valor_compra >= 300) {

      $valor_frete = 10;

  } else if ($usuario_possui_cartao_loja  && $valor_compra >= 100) {

      $valor_frete = 25;

  } else {

      //...

      $recebeu_desconto_frete = false;

  }

?>

Detalhes do pedido

Possui cartão da loja?

    



Valor da compra: = $valor_compra ?>


Recebeu desconto no frete?

    



Valor do frete: = $valor_frete ?>

```






Aula 19: Operador ternário.



Permite, com base em determinada condição, seguir ou não um fluxo. É mais limitado, pois retorna apenas uma instrução quando V ou F. Entretanto, são menos verbosos.

Sintaxe:

```

//  ? true : false

```

Exemplo (aplicando com base no exercício da aula anterior):

```php

Detalhes do pedido

Possui cartão da loja? = $usuario_possui_cartao_loja ? 'SIM' : 'NÃO'; ?>

    // ou $usuario_possui_cartao_loja == true ?  'SIM' : 'NÃO';


Valor da compra: = $valor_compra ?>


Recebeu desconto no frete?

    



```


Apesar de não ser uma prática recomendada, há a possibilidade de utilizar operadores ternários encadeados (com parênteses).





Aula 20: Atividades para fixação do conteúdo.



> arquivo atividade_fixacao_1.php

Enunciado:

"Crie uma aplicação capaz de identificar se uma determinada pessoa pode ou não doar sangue. Utilize as variáveis $idade e $peso no processo. Neste primeiro momento, faca a atribuição de valores às variáveis de forma estática, ou seja, no processo de atribuição.

Se a idade informada estiver entre (e inclusive) 16 e 69 anos e o peso for igual ou superior a 50kg, então o sistema deve imprimir a mensagem "Atende aos requisitos", caso contrário o sistema deve imprimir a mensagem "Não atende aos requisitos".

Resolução:

```php

$idade = 90;

$peso = 45;

if ($peso >= 50 && ($idade >= 16 && $idade <= 69)) {

  echo 'Atende aos requisitos!';

} else {

  echo 'Não atende aos requisitos...';

}

```





Aula 21: Switch.



É um condicional; visa, com base em determinada condição, seguir determinado fluxo dentro da aplicação.

É mais restrito, pois permite apenas comparar idênticos. Bom em caso de organização de um meno, por exemplo.

Exemplo:

```php

$opcao = 2

switch ($opcao) {

  case 1:

    // trecho de código que será executado

    break;

  case 2:

    // trecho de código que será executado

    break;

  default:

    // trecho de código que será executado

    break;

}

```





Aula 22: Switch na prática.



> arquivo switch.php

A comparação é por **igualdade**, e não por identidade (diferente do JS)!!! Faz um casting de tipos, podendo comparar o int 2 com string '2', por exemplo.

Nos cases, podemos utilizar valores que não são numéricos (como strings) - há flexibilidade no PHP.

```php

$parametro = 'Mônica';

switch ($parametro) {

case 1:

  echo 'Entrou no case 1';

  break;

case 2:

  echo 'Entrou no case 2';

  break;

case 3:

  echo 'Entrou no case 3';

  break;

default:

  echo 'Entrou no default!';

  break;

  }

```

OBS: quando o valor booleano é true, o PHP retorna o resultado "1".





Aula 23: Casting de tipos com (int), (bool), (float) e (string).



Casting de tipos consiste na conversão de uma determinada variável de um tipo para outro.

A variável pode ter seu tipo modificado ou no processo de atribuição ou no contexto em que está sendo interpretada pelo PHP.

> arquivo casting_tipos.php

A função gettype() espera um parâmetro e retorna o seu tipo. É importante para debug.

Para realizar o casting:

```

$variável_que_queremos_converter = (tipo de variável esperada) $nova_variavel

```

O tipo "real" não é mais suportado no PHP; utilizar double ou float.

```php

//gettype() - retorna o tipo de uma variável

$valor = 10;

echo $valor . ', ' . gettype($valor);

echo '
';

// para converter de int para float

$valor2 = (float)$valor;

echo $valor2 . ', ' . gettype($valor2);

echo '
';

// para converter para string

$valor3 = (string)$valor;

echo $valor3 . ', ' . gettype($valor3);

```





Aula 24: Operadores aritméticos.



Operadores matemáticos que permitem efetuar cálculos.

|   OPERADOR    | REPRESENTAÇÃO | FUNÇÃO                                     |

| :-----------: | :-----------: | ------------------------------------------ |

|    Adição     |       +       | Soma valores                               |

|   Subtração   |       -       | Diferença entre valores                    |

| Multiplicação |      \*       | Produto dos valores                        |

|    Divisão    |       /       | Quociente dos valores                      |

|    Módulo     |       %       | Resto existente em uma operação de divisão |





Aula 25: Praticando com operadores aritméticos.



> arquivo operadores_aritmeticos.php

```php

$num1 = 12;

$num2 = 6;

// adição

echo "A soma entre $num1 e $num2 é " . ($num1 + $num2) . '!';

echo '
';

// subtração

echo "A subtração entre $num1 e $num2 é " . ($num1 - $num2) . '!';

echo '
';

// divisão

echo "A divisão entre $num1 e $num2 é " . ($num1 / $num2) . '!';

echo '
';

// muntiplicação

echo "A multiplicação entre $num1 e $num2 é " . ($num1 * $num2) . '!';

echo '
';

// módulo

echo "O módulo entre $num1 e $num2 é " . ($num1 % $num2) . '!';

```





Aula 26: Operações aritméticas na atribuição de valores.



> arquivo operadores_atribuicao_aritmeticos.php

Podemos combinar o operador aritmético com a atribuição: primeiro vem o operador (à esquerda), em seguida a atribuição (+=, por exemplo). Isso deixa a sintaxe mais enxuta!





Aula 27: Operadores de incremento/decremento.



|    OPERADOR    | REPRESENTAÇÃO | FUNÇÃO                                   |

| :------------: | :-----------: | ---------------------------------------- |

| Pré-incremento |     ++$a      | Add uma unidade antes de retornar $a     |

| Pós-incremento |     $a++      | Retorna $a e depois adiciona uma unidade |

| Pré-decremento |     --$a      | Diminui uma unidade antes de retornar $a |

| Pós-decremento |     $a--      | Retorna $a e depois diminui uma unidade  |





Aula 28: Praticando com operadores de incremento/decremento.



> arquivo operadores_incremento_decremento.php

```php

Pós-incremento

";

echo 'O valor contido em a após o incremento (a++) ' . $a++ . ' 
';

echo "O atualizado é  $a 
";

?>


Pré-incremento

";

echo 'O valor contido em a pré incremento (++a) ' . ++$a . ' 
';

echo "O atualizado é  $a 
";

?>


Pós-decremento

";

echo 'O valor contido em a após o decremento (a--) ' . $a-- . ' 
';

echo "O atualizado é  $a 
";

?>


Pré-decremento

";

echo 'O valor contido em a pré decremento (--a) ' . --$a . ' 
';

echo "O atualizado é  $a 
";

?>

```






Aula 29: Funções - Introdução.



As funções permitem estabelecer subprogramas com objetivos específicos, que podem ser chamados sempre que necessários dentro da lógica, evitando redundâncias no código!

Tem a função de encapsular um bloco de códigos com um objetivo definido.

As funções podem ser do tipo void ou com retorno!

Exemplos:

```php

function exibirBoasVindas () {

  echo "Bem-vindo ao Curso de PHP";

}

function calcularAreaTerreno ($largura, $comprimento) {

  $area = $largura * $comprimento;

  return $area;

}

```





Aula 30: Funções - Prática.



> arquivo funcoes.php

(aplicação dos exemplos da aula anterior)





Aula 31: Atividade para fixação de conteúdo.



Enunciado:

Crie uma função para calcular o imposto de renda a ser pago com base em um salário passado por um parâmetro.

| BASE DE CÁLCULO                | ALÍQUOTA |

| ------------------------------ | -------- |

| Até 1903,98                    | Isento   |

| De 1903,99 até R$ 2.826,65     | 7,5%     |

| De R$ 2.826,66 até R$ 3.751,05 | 15%      |

| De R$ 3.751,06 até R$ 4.664,68 | 22,5%    |

| Acima de 4.664,68              | 27,5%    |

Resolução:

```php

function calcularImposto ($salario) {

$imposto = 0;

if ($salario <= 1903.98) {

  $imposto = 0;

} else if ($salario >= 1903.99 && $salario <= 2826.65) {

  $imposto = ($salario * 7.5)/100;

} else if ($salario >= 2826.66 && $salario <= 3751.05) {

  $imposto = ($salario * 15)/100;

} else if ($salario >= 3751.06 && $salario <= 4664.08) {

  $imposto = ($salario * 22.5)/100;

} else {

  $imposto = ($salario * 27.5)/100;

}

return $imposto;

}

echo "O imposto será de R$ " . calcularImposto(2000) . ",00.";

```





Aula 32: Funções nativas para manipular strings.



> arquivo funcoes_strings.php

Funções estudadas em aula:

- strtolower($texto): transforma todos os caracteres da string em minúsculos.

- strtoupper($texto): transforma todos os caracteres da string em maiúsculos.

- ucfirst($texto): transforma o primeiro caracter da string em maiúsculo.

- strlen($texto): conta a quantidade de caracteres de uma string.

- str_replace(<procura por>, <substitui por>, $texto): substitui uma cadeia de caracteres por outra dentro de uma string.

- substr($texto, <posição inicial>, <qtde caracteres>): retorna parte de uma string.

```php

$texto = "monica QUINTAL";

echo $texto;

echo "
";

// string to lower:

echo strtolower($texto);

echo "
";

// string to upper

echo strtoupper($texto);

echo "
";

// uppercase first

echo ucfirst($texto);

echo "
";

// string length - conta n° de caracteres (incluindo espaços em branco)

echo strlen($texto);

echo "
";

// string replace - é case sensitive.

echo str_replace("QUINTAL", "zungalo", $texto);

echo "
";

// substr (sub string)

echo substr($texto, 0, 6);

```





Aula 33: Funções nativas para tarefas matemáticas.



> arquivo funcoes_matematicas.php

Funções estudadas em aula:

- ceil($numero): arredonda o valor para cima.

- floor($numero): arredonda o valor para baixo.

- round($numero): arredonda o valor com base nas casas decimais.

- rand(): gera um número aleatório.

- sqrt($numero): retorna a raiz quadrada.

```php

$numero = 9.999;

// ceil() - arredonda para cima

echo "ceil(9.999) = " . ceil($numero);

// floor() - arredonda para baixo

echo "floor(9.999) = " . floor($numero);

/* round() - arredonda c/ base na fração:

  de .0 a .4 - p/ bx

  de .5 pra cima - p/ cima */

echo "round(9.999) = " . round($numero);

/* rand() - gera valor aleatorio (de 0 até randmax)

  *** a função nativa getrandmax() retorna esse valor máximo! */

echo "rand(): " . rand();

echo "getrandmax(): " . getrandmax();

// podemos passar como parâmetros para rand(, )

echo "rand(10, 20): " . rand(10, 20);

echo "getrandmax(): " . getrandmax();

// sqrt() - retorna raiz quadrada

echo "sqtr(121) = " . sqrt(121);

```





Aula 34: Funções nativas para manipular datas.



> arquivo funcoes_data.php

Observação importante: O PHP possui uma configuração de timezone (zona) que define a aplicação do tempo sobre a data previamente carregada do sistema operacional!

Funções estudadas em aula:

- date(formato): recupera a data atual. Verificar na [documentação](https://www.php.net/manual/en/datetime.format.php) a forma correta de indicar os parâmetros/fomato.

```php

echo "F (mês), " . "d (dia), " . "o (ano) e " . "D (dia)";

echo "
";

echo date('F d o D');

echo "(dia)/" . "(mês)/" . "(ano)" . " " . " hora:" . "minutos";

echo "
";

echo date('d/m/Y H:i');

```

- date_default_timezone_get(timezone): recupera o timezone default da aplicação.

```php

echo "timezone: ";

echo date_default_timezone_get();

echo "
";

echo date('d/m/Y H:i');

```

- date*default_timezone_set(timezone): atualiza o timezone default da aplicação.

  (podemos fazer a modificação de timezone diretamente no ambiente em que o PHP está instalado OU no tempo de execução, utilizando a instrução acima)

  Acessar a [documentação](https://www.php.net/manual/en/timezones.php) para verificar as timezones possíveis.

  \_America/Sao_Paulo* é o timezone oficial do BR.

```php

date_default_timezone_set('America/Sao_Paulo');

echo "timezone set: ";

echo date_default_timezone_get();

echo "
";

echo date('d/m/Y H:i');

```

- strtotime(data): transformar datas textuais em segundos.

```php

// padrão computacional: ano-mês-dia

$data_inicial = '2023-01-01';

$data_final = '2023-01-15';

// descobrir quantos dias há entre a data inicial e a final

//timestamp = 01/01/1970 (início da era Unix)

$time_inicial = strtotime($data_inicial);

$time_final = strtotime($data_final);

// calcula tempo entre data inicial e 01/01/1970

// JS retorna milissegundos; php retorna segundos!!!

echo $data_inicial . " - " . $time_inicial . " segundos." . "
";

echo $data_final . " - " . $time_final . " segundos." . "
";

$diferenca_times = abs($time_final - $time_inicial);

// função abs: converte o resultado em seu respectivo valor absoluto (positivo), caso necessário

echo "A diferença em segundos entre a data inicial e final é: " . $diferenca_times . "
";

// 1 dia = 24 horas * 60 minutos * 60 segundos

// um dia possui 86400 segundos!

$diferenca_em_dias = $diferenca_times / 86400;

echo "A diferença em segundos entre a data inicial e final é: " . $diferenca_em_dias;

```





Aula 35: Array básico - Introdução.



Arrays são listas ordenadas; são variáveis que nos permitem relacionar itens associados a índices.

Uma única variável armazena diversos valores!

Exemplo:

```php

$lista_frutas[1] = 'Banana';

$lista_frutas[2] = 'Maçã';

$lista_frutas[3] = 'Morango';

$lista_frutas[4] = 'Uva';

```





Aula 36: Array básico - Prática.



> arquivo array_basico.php

Importante:

- "array()" com a minúsculo!

- itens separados por vírgulas.

- cada item do array recebe uma chave numérica (ou índice), que vai de 0 a n!

Para fazer testes e debugar, podemos utilizar duas funções:

- **var_dump(<array>)**

  - dá detalhes adicionais;

  - dá acesso ao tipo de dado que é representado em cada índice.

- **print_r(<array>)**

Utilizar echo "<pre>" para auxiliar na formatação do conteúdo do array e facilitar na visualização!

Para **incluir novos índices em um array já criado**:

- abrir e fechar colchetes;

- na sequência, atribuir novo valor.

Em vez de indicar a palavra "array", podemos apenas abrir e fechar colchetes! Exemplo:

```php

    $lista_frutas = ['Banana', 'Maçã', 'Morango', 'Uva'];

```

Para **recuperar um item específico** do array:

- recuperar a variável que contém o array e imprimir o valor contido em determinado índice; exemplo:

```php

echo $lista_frutas[2];

```

Praticando:

```php

// Arrays sequenciais (numéricos)

$lista_frutas = array('Banana', 'Maçã', 'Morango', 'Uva');

$lista_frutas[] = 'Abacaxi';

echo '
';

var_dump($lista_frutas);

echo '
';

echo '
';

print_r($lista_frutas);


// Para impromir um item específico:

echo '
';

echo $lista_frutas[2];

echo '
';


// Arrays associativos - a diferença é que os indices serão explícitos (nós os definiremos!!!)

$lista_frutas_associativo = array('a' => 'Banana', 'b' => 'Maçã', 'x' => 'Morango', '2' => 'Uva');

$lista_frutas_associativo[] = 'Abacaxi';

echo '
';

var_dump($lista_frutas_associativo);

echo $lista_frutas_associativo['x'];

```






Aula 37: Array multidimensional.



Sâo arrays de arrays!

Através de uma variável i ou índice, podemos acessar outro array (encadear no índice outros arrays, criando quantas dimensões forem necessárias para atender às necessidades)!

> arquivo array_multidimensional.php

Praticando:

```php

    // array $lista_coisas

    $lista_coisas = array();

    // arrays associativos frutas e pessoas

    $lista_coisas['frutas'] = array('1' => 'Banana', '2' => 'Maçã', '3' => 'Morango', '4' =>  'Uva');

    $lista_coisas['pessoas'] = array('1' => 'João', '2' => 'José', '3' => 'Maria');

    // imprimindo o array $lista_coisas

    echo '
';

    print_r($lista_coisas);

    echo '
';


    echo '
';

    // para recuperar valores específicos

    echo $lista_coisas['frutas'][3];

    echo '
';

    echo $lista_coisas['pessoas'][2];

```






Aula 38: Array - Métodos de pesquisa.



> arquivo array_pesquisa.php

1. Método in_array():

Retorna **true ou false** para a existência do que está sendo procurado!

```php

in_array(, );

```

**Importante:**

- Se o retorno for true: texto impresso será 1;

- Se o retorno for falso: texto impresso será 'vazio'.

  Podemos criar uma lógica que garante um retorno mais intuitivo, atribuindo o método in_array() a uma ariável, e associá-la a uma estrutura if/else, por exemplo, como abaixo:

```php

$lista_frutas = array('Banana', 'Maçã', 'Morango', 'Uva');

$existe = in_array('Laranja', $lista_frutas);

if ($existe) { //true

  echo 'Sim, o valor pesquisado existe no array! :)';

} else { // false

  echo 'Não, o valor pesquisado não existe no array! :(';

}

```

2. Método array_search():

Retorna o **índice** do valor pesquisado, caso ele exista.

```php

array_search(, );

```

**Importante:**

- Se o item existir no array: retorna o índice;

- Se não existir: retorna null (não é necessariamente o valor false!!!). A representação textual é vazio.

  Podemos também utilizar if/else para apresentar um texto mais intuitivo ao usuário, como abaixo:

```php

$lista_frutas = array('Banana', 'Maçã', 'Morango', 'Uva');

$existe = array_search('Laranja', $lista_frutas);

if ($existe != null) {

  echo 'Sim, o valor pesquisado existe no array! :)';

} else {

  echo 'Não, o valor pesquisado não existe no array! :(';

}

```

3. Para arrays multidimensionais:

Na essência, trata-se de um array normal para a pesquisa, pois o método atuará sobre um array específico!

Exemplo:

```php

$lista_frutas = array('Banana', 'Maçã', 'Morango', 'Uva');

$lista_coisas = [

  'frutas' => $lista_frutas,

  'pessoas' => ['João', 'Maria']

];

echo '
';

print_r($lista_coisas);

echo '
';


echo in_array('Uva', $lista_coisas['frutas']);

```





Aula 39: Extra - False, Null e Empty.



São valores especiais, que possuem diferenças sutis entre si, sendo fatores potenciais de bugs!

- false (true/false) - tipo de variável boolean;

- null e empty - são valores especiais.

> arquivo false_null_empty.php

1. null:

Para verificar se o valor é null, podemos utilizar a função nativa **is_null(<variável>)**, como abaixo:

```php

$funcionario1 = null;

$funcionario2 = '';

// valores null

if (is_null($funcionario1)) {

  echo 'Sim, a variável é null.';

} else {

  echo 'Não, a variável não é null.';

}

echo '
';

if (is_null($funcionario2)) {

  echo 'Sim, a variável é null.';

} else {

  echo 'Não, a variável não é null.';

}

```

Nos casos acima, temos o retorno de que $funcionario1 é null, e $funcionario2, não.

1. empty (vazio):

Para verificar se o valor é empty, podemos utilizar a função nativa **empty(<variável>)**, como abaixo:

```php

$funcionario1 = null;

$funcionario2 = '';

// valores vazio?

if (empty($funcionario1)) {

  echo 'Sim, a variável está vazia.';

} else {

  echo 'Não, a variável não está vazia.';

}

echo '
';

if (empty($funcionario2)) {

  echo 'Sim, a variável está vazia.';

} else {

  echo 'Não, a variável não está vazia.';

}

```

Nos casos acima, temos o retorno de ambas as variáveis estão vazias!!!

Ou seja, no empty, o valor null também é considerado vazio. **_Portanto, null é exclusivamente null, enquanto empty pode ser vazio ou null!_**

3. false:

False não é considerado null, mas é considerado vazio.





Aula 40: Funções nativas para manipular arrays.



> arquivo funcoes_arrays.php

Algumas das principais:

- is_array(array): verifica se o parâmetro é um array - retorna true/false.

~~~php

$array = array();

$retorno = is_array($array);

if ($retorno) {

  echo 'Sim, é um array!';

} else {

  echo 'Não, não é um array.';

}  

~~~

- array_keys(array): retorna todas as chaves de um array.

~~~php

$array = [1 => 'a', 7 => 'b', 18 => 'c'];

$chaves_array = array_keys($array);

echo '
';

print_r ($chaves_array);

echo '
';

~~~


- sort(array): ordena um array e reajusta seus índices (sequência alfabética). Retorna true/false para a tentativa de ordenação!

~~~php

$array = array('notebook', 'teclado', 'mouse', 'cabo hdmi', 'gabinete', 'fonte');

sort($array);

echo '
';

print_r ($array);

echo '
';

~~~


- asort(array): ordena um array preservando os índices. Retorna true/false para a tentativa de ordenação! Coloca em ordem alfabética, mas reserva a relação índice-valor!

~~~php

$array = array('notebook', 'teclado', 'mouse', 'cabo hdmi', 'gabinete', 'fonte');

//asort(array)

asort($array);

echo '
';

print_r ($array);

echo '
';

~~~


- count(array): conta a quantidade de elementos de um array.

~~~php

$array = array('notebook', 'teclado', 'mouse', 'cabo hdmi', 'gabinete', 'fonte');

echo '
';

print_r ($array);

echo count($array);

echo '
';

~~~


- array_merge(array): funde um ou mais arrays.

~~~php

$array1 = ['osx', 'windows'];

$array2 = ['linux'];

$array3 = ['solaris'];

$novo_array = array_merge($array1, $array2, $array3);

echo '
';

print_r ($novo_array);

echo '
';

~~~


- explode(array): divide uma string baseada em um delimitador. O retorno é dado em um array. Nesse caso '/' é o delimitador.

~~~php

$string = '29/12/1991';

$array_retorno = explode('/', $string);

echo '
';

print_r ($array_retorno);

echo '
';

~~~


- implode(array): junta elementos de um array em uma string.

~~~php

$array = ['a', 'b', 'x', 'y'];

$string_retorno = implode(',', $array);

echo '
';

print_r ($string_retorno);

echo '
';

~~~






Aula 41: Loops parte 1 - Introdução.



Estruturas de repetição (também chamadas loops ou laços) são estruturas que permitem a repetição de um comando ou bloco de código até atender determinada condição!

São utilizadas para recuperar informações contidas em arquivos, para exibir informações recuperadas em BDs, realizar cálculos, etc!

Tornam os códigos menos verbosos, pois modificaremos apenas os valores dinâmicos.

Laços, de modo geral, esperam um comando de parada, indicando que devem ser interrompidos, o que evita o looping infinito!

São elas:

- while;

- do while;

- for;

- foreach.





Aula 42: Loops parte 2 - While.



> arquivo loops_while.php

Sintaxe:

~~~php

while (condição) {

  bloco de código

  comando de parada

}

~~~

Exemplo:

~~~php

while ($num < 10) {

  echo "$num 
";

  $num++; // critério de parada

}

~~~

Podemos também utilizar os comandos:

- break: interrompe a execução do laço, independente do critério estabelecido.

~~~php

$num = 1;

echo "Início do loop 
";

while ($num < 50) {

  $num += 5; // critério de parada

  echo "$num 
";

  break;

}

echo "Fim do loop";

~~~

- continue: não interrompe a repetição do laço, apenas pula para a próxima iteração do laço (descarta o que está a seguir até o fechamento do bloco)!

~~~php

$num = 1;

echo "Início do loop 
";

while ($num < 10) {

  $num += 1;

  

  if($num == 2 || $num == 6) {

    continue;

  }

  echo "$num 
";

}

echo "Fim do loop";

~~~





Aula 43: Loops parte 3 - Do while.



> arquivo loops_do_while.php

Sintaxe:

~~~php

do {

  //bloco de códigos

} while(condição de parada);

~~~

Exemplo:

~~~php

$x = 10;

do {

  echo 'Entrou no do while';

} while($x < 9);

~~~

A diferença em relação ao "while" é que, no caso do "do while", a condição é validada apenas ao término da execução do bloco (é executado pelo menos uma vez).

Podemos também utilizar o "continue" e o "break". Atentar-se à questão do incremento do critério de parada.





Aula 44: Loops parte 4 - For.



> arquivo loops_for.php

Sintaxe:

~~~php

for (; ; ) {

  // bloco de código

}

~~~

Exemplo:

~~~php

for ($x = 1; $x <= 10; $x++) {

  echo "$x 
";

}

~~~

Podemos omitir o segundo parâmetro (ou passar true), e estabelecer o critério de parada dentro do laço for, usando break, por exemplo.





Aula 45: Praticando um pouco - Percorrendo arrays com While, Do whule e For.



> arquivo loops_pratica_1.php

Percorrendo arrays - no exemplo, trata-se de um site de notícias.

1. While:

Imprimindo apenas títulos (sem conteúdos das notícias):

~~~php

$registros = array('Título notícia 1', 'Título notícia 2', 'Título notícia 3');

$idx = 0;

while($idx < 3) {

  echo "$registros[$idx] 
";

  $idx++;

}

~~~

Imprimindo títulos COM conteúdos, como arrays associativas (e recuperando cada um dos itens):

~~~php

$registros = array(

  array('titulo' => 'Título notícia 1', 'conteudo' => 'Conteudo Noticia 1'),

  array('titulo' => 'Título notícia 2', 'conteudo' => 'Conteudo Noticia 2'),

  array('titulo' => 'Título notícia 3', 'conteudo' => 'Conteudo Noticia 3')

  );

echo '
';

print_r($registros);

echo '
';

echo '
';


$idx = 0;

while($idx < 3) {

  print_r ($registros[$idx]);

  echo "
";

  $idx++;

}

~~~

Acessando valores de título e conteúdo separadamente, a partir dos índices associativos, e atribuindo tags HTML para cada um deles.

~~~php

$registros = array(

  array('titulo' => 'Título notícia 1', 'conteudo' => 'Conteudo Noticia 1'),

  array('titulo' => 'Título notícia 2', 'conteudo' => 'Conteudo Noticia 2'),

  array('titulo' => 'Título notícia 3', 'conteudo' => 'Conteudo Noticia 3')

  );

echo '
';

print_r($registros);

echo '
';

echo '
';


$idx = 0;

while($idx < 3) {

  echo '
' . $registros[$idx]['titulo'] . '
';

  echo '
' . $registros[$idx]['conteudo'] . '
';

  echo "
";

  $idx++;

}

~~~


Podemos, ainda, utilizar a **função nativa count()**, que conta a quantidade de elementos de um array.

Portanto, ao invés de "engessar" o valor do índice, podemos utilizar a função count(array) para torná-lo dinâmico! 

Ou seja, a cada notícia adicionada, não precisaremos alterar o índice.

~~~php

$registros = array(

  array('titulo' => 'Título notícia 1', 'conteudo' => 'Conteudo Noticia 1'),

  array('titulo' => 'Título notícia 2', 'conteudo' => 'Conteudo Noticia 2'),

  array('titulo' => 'Título notícia 3', 'conteudo' => 'Conteudo Noticia 3'),

  array('titulo' => 'Título notícia 4', 'conteudo' => 'Conteudo Noticia 4')

  );

echo '
';

print_r($registros);

echo '
';

echo '
';


$idx = 0;

// função count()

echo 'O array possui ' . count($registros) . ' registros.';

echo "
";


while($idx < count($registros)) {

  echo '
' . $registros[$idx]['titulo'] . '
';

  echo '
' . $registros[$idx]['conteudo'] . '
';

  echo "
";

  $idx++;

}

~~~


Podemos, também, implementar a mesma lógica com Do while:

~~~php

<...>

do {

  echo '
' . $registros[$idx]['titulo'] . '
';

  echo '
' . $registros[$idx]['conteudo'] . '
';

  echo "
";

  $idx++;

} while ($idx < count($registros));

~~~


Podemos, ainda, implementar a mesma lógica com For:

~~~php

<...>

for ($idx = 0; $idx < count($registros); $idx++) {

  echo '
' . $registros[$idx]['titulo'] . '
';

  echo '
' . $registros[$idx]['conteudo'] . '
';

  echo "
";

}

~~~






Aula 46: Loops parte 5 - Foreach.



O comando de repetição Foreach é especializado para arrays e objetos; ou seja, **o controle de finalização das interações está intrínseca ao comando!!!** Automaticamente finalizará quando chegar ao final do array, não sendo necessário definir parâmetros (não é necessário estabelecer condições de parada e variáveis de controle)!

> arquivo loops_foreach.php

Sintaxe:

~~~php

foreach($array as $variavel) {

  /* conteúdo a ser executado para cada um dos elementos percorridos dentro do array*/

}

~~~

Exemplo:

~~~php

$itens = array('Sofá', 'Mesa', 'Cadeira', 'Fogão', 'Geladeira');

echo '
';

print_r($itens);

echo '
';

echo '
';


foreach($itens as $item) {

  echo "$item";

  if ($item == 'Mesa') {

    echo '(*Compre uma mesa e ganhe 25% de desconto na compra de 4 cadeiras*)';

  } 

  echo '
';

}

~~~





Aula 47: Praticando um pouco - Foreach em arrays associativos e Foreach encadeados.



Há alguns contextos mais complexos em que o Foreach pode ser aplicado, que serão abordados nessa aula.

> arquivo loops_pratica_2.php

Podemos incluir entre o valor e o array, uma outra variável, que receberá o índice em cada uma das iterações. Dessa forma, o foreach saberá que o índice deve ser associado à variável. Devemos separar os valores por um token (=>). Exemplo:

~~~php

foreach ($array as $chave => $item) {

  //bloco de códigos

}

~~~

Exemplo:

~~~php

$funcionarios = array('João', 'Maria', 'Júlia');

foreach ($funcionarios as $idx => $nome_funcionario) {

  echo "ID $idx - Nome: $nome_funcionario 
";

}

~~~

Para atribuir mais informações, incluindo array associativa, podemos também utilizar a estrutura de foerach encadeada!

Exemplo:

~~~php

$funcionarios = array(

  array('nome' => 'João', 'salario' => 2500), 

  array('nome' => 'Maria', 'salario' => 3000),  

  array('nome' => 'Julia', 'salario' => 2200), 

);

foreach ($funcionarios as $idx => $funcionario) {

  

  foreach($funcionario as $idx2 => $valor) {

    echo "$idx2 - $valor 
";

  }

  echo '
';

}

~~~


Caso adicionamos novas indormações (como data de nascimento dos funcionários), a estrutura os interpretará e exibirá, a partir da estrutura acima!





Aula 48: Atividades para fixação de conteúdo.



> arquivo atividade_fixacao_3.php

Enunciado:

Crie um script capaz de produzir, através de um laço de repetição, um array com 6 elementos numéricos aleatórios entre 1 e 60, simulando o sorteio da mega sena.

Atente-se ao fato de que os números aleatórios contidos dentro do array não podem ser repetidos.

Solução:

~~~php

$numeros = [];

for ($i = 0; $i < 6; $i++) {

  $num = rand(1, 60);

  if (!in_array($num, $numeros)) {

    $numeros[] = $num;

  }

}

echo '
';

print_r($numeros);

echo '
';

~~~


Solução do professor, utilizando while:

~~~php

$numeros = array();

while (count($numeros) <= 5) {

  $num = rand(1, 60);

  if (!in_array($num, $numeros)) {

    $numeros[] = $num;

  }

}

print_r($numeros);

~~~

---

[Aplicação desenvolvida ao término do módulo](https://github.com/monicaquintal/app-help-desk).

[Continuação do estudo, com PHP e Orientação a Objetos](https://github.com/monicaquintal/estudandoPHP-orientacao-a-objetos).