Código Aula 2 curso PHP Básico

<?php

#Aula 2 curso PHP Básico


// OPERADORES  MATEMÁTICOS
// http://php.net/manual/pt_BR/language.operators.arithmetic.php

$a = 5;

$b = 3;

$c = $a * $b;

echo $c;

// ========================

$a = 10;

$b = 6;

$c = $a - $b;

echo $c;

// ========================

$a = 12;

$b = 2;

$c = $a / $b;

echo $c;

// ========================

$a = 1;

$a++;   // $a = $a + 1;

echo $a;

// ========================


$b = 7;

$b--;   // $b = $b - 1;

echo $b;

// ========================


$a = 75;

$b = 5;

$c = $a % $b;   // Resto da divisão de $a por $b

echo $c;

// ========================






// OPERADORES  LÓGICOS

// Operador "E":   &&
// CONDICAO1 && CONDICAO2   -> As duas condições precisam ser verdadeiras

// Operador "OU":  ||
// CONDICAO1 || CONDICAO2   -> Uma das condições precisa ser verdadeira


$idade_joao = 2;

$idade_ana = 5;

$idade_pedro = 10;

//             TRUE                         TRUE
if( ($idade_pedro > $idade_ana)  &&  ($idade_pedro > $idade_joao) )
{
    echo 'Pedro é mais velho que João e Ana.';
}

echo '<hr>';

//              FALSE                               TRUE
if( ($idade_joao + $idade_ana > 10)  ||   ( $idade_ana - $idade_joao < 5)  )
{
    echo 'Joaõ e Ana juntos são mais velhos que Pedro  OU  a idade de Ana menos a de João é menor que cinco.';
}
else
{
    echo 'Caiu no else pq as duas condições deram false';
}


// OPERADORES DE COMPARAÇÃO
//http://php.net/manual/pt_BR/language.operators.comparison.php

$a = 1;
$b = '1';

if($a == $b)
    echo ' $a e $b tem mesmo valor, ou seja são "iguais" ';

echo '<br>';

if($a === $b)
    echo 'Idêntico $a e $b, de mesmo valor e tipo';








// Revisão de IF / ELSE

$estaChovendo = true;

if($estaChovendo)
    echo 'Vou levar meu guarda-chuva';
else
    echo 'Está sol, vou deixar o guarda-chuva em casa';

// ===========================

// SWITCH - como se fosse um monte if else


$valor = 'a';

switch($valor)
{
    case 'a':
        echo 'O valor é A';
        break;

    case 'b':
        echo 'O valor é B';
        break;

    case 'c':
        echo 'O valor é C';
        break;

    default:
        echo 'Valor não é A nem B nem C';
        break;
}



// WHILE
//inicializando variável que será utilizada na condição
$i=0;

// enquanto condição é verdadeira executa o código entre chaves
while($i<10)
{
    echo $i . ' é menor do que 10<br>';

    //incrementa a variável -> isso é importante, caso contrário iria ficar preso no loop infinitamente
    $i++;
}

// ============================================



// mesmo exemplo acima com FOR
//   A  ;   B  ;  C
for($i=0; $i<10; $i++)
{
    echo $i . ' é menor do que 10<br>';
}

// A é a inicialização
// B é a condição, o loop funciona enquanto o resultado da comparação retornar true
// C é o incremento


// =============================================


// DO ... WHILE
$i=100;

do
{
    echo $i . ' ';

    //if($i%20==0) echo '<br>';

    $i--;
}
while($i>0);


// =============================================


// Revisão de array

$meuarray = array(); // Array vazio

// Documentação e funções de array:
//http://php.net/manual/pt_BR/language.types.array.php
//http://php.net/manual/pt_BR/ref.array.php


//Adicionando elementos no array
$meuarray[]='[email protected]';
$meuarray[]='[email protected]';
$meuarray[]='[email protected]';
$meuarray[]='[email protected]';

//Debug da variável

var_dump($meuarray);

// - - - - - - - - - - - - - - - - - - - - - - - - - - - -


//echo implode(", ",$meuarray);

$qtd_items_array = count($meuarray);

$output='';

$i = 0;
while( $i < $qtd_items_array)
{
    // Gera um array quebrando a string no caractere @ do elemento que está na posição $i do array $meuarray
    $tmp_arr = explode("@",$meuarray[$i]);

    // Adiciona texto na variável $output concatenando elementos do array gerado acima com strings literais
    $output.= 'Usuário: ' . $tmp_arr[0] . ' <br> Domínio: '. $tmp_arr[1] . '<br><br>';

    $i++;
}

echo $output;

//$output.= ' pedaço q vai ser adicionado na string';
// é a mesma coisa que:
//$output = $output . ' pedaço q vai ser adicionado na string';



// ==========================================================


// FOR - Um exemplo mais elaborado
$array_numeros = array(100,35,92,43,77,88,11,241,22,18,32);
$impares = array();
$pares = array();
                // as funções sizeof e count são a mesma coisa, sendo que uma é alias(apelido) da outra
$qtd_numeros = sizeof($array_numeros);

for( $i=0 ; $i<$qtd_numeros ; $i++)
{
    if($array_numeros[$i]%2==0)
    {
        echo $array_numeros[$i] . ' é par. <br>';
        $pares[]=$array_numeros[$i];
    }
    else
    {
        echo $array_numeros[$i] . ' é ímpar. <br>';
        $impares[]=$array_numeros[$i];
    }
}

sort($pares);
var_dump($pares);

sort($impares);
var_dump($impares);


// ===========================================================

$arr_cliente1 = array(
                        'id'        =>'1',
                        'nome'      =>'Alexandre',
                        'email'     =>'[email protected]',
                        'profissao' =>'Programador PHP e Java'
                    );

$arr_cliente2 = array(
                        'id'        =>'2',
                        'nome'      =>'Pedro',
                        'email'     =>'[email protected]',
                        'profissao' =>'Pescador de homens'
                    );

$arr_cliente3 = array(
                        'id'        =>'3',
                        'nome'      =>'João',
                        'email'     =>'[email protected]',
                        'profissao' =>'Agricultor'
                    );

// Adicionando elementos criados manualmente na matriz
$matriz = array();
$matriz[]=$arr_cliente1;
$matriz[]=$arr_cliente2;
$matriz[]=$arr_cliente3;

var_dump($matriz);


$tb_clientes_html='<table border="1" cellpadding="5">
                        <tr style="background-color:#ed0">
                            <td>Id</td>
                            <td>Nome</td>
                            <td>E-mail</td>
                            <td>Profissão</td>
                        </tr>';


// exemplo de FOREACH    +  forma de concatenar variáveis complexas usando chaves {}  em strings com aspas duplas
foreach($matriz as $cliente)
{
    $tb_clientes_html.="<tr>
                            <td>{$cliente['id']}</td>
                            <td>{$cliente['nome']}</td>
                            <td>{$cliente['email']}</td>
                            <td>{$cliente['profissao']}</td>
                        </tr>";

}
$tb_clientes_html.='</table>';

echo $tb_clientes_html;



// =========================================================


//Uma forma de ler arquivo inteiro para string
$lista_csv = file_get_contents("lista_emails.csv");

var_dump($lista_csv);


$lista_csv=trim($lista_csv);

$array_linhas = explode(PHP_EOL, $lista_csv);

var_dump($array_linhas);


$lista_emails_assoc = array();

foreach($array_linhas as $linha)
{
    list($tmp_nome,$tmp_email) = explode("," , $linha);

    $lista_emails_assoc[]=array(
                            'nome' =>$tmp_nome,
                            'email'=>$tmp_email
                        );
}

var_dump($lista_emails_assoc);

// Pega apenas a coluna email
$emails_arr = array_column($lista_emails_assoc, 'email');

var_dump($emails_arr);


// =========================================================



// Exemplo de ordenação manual simples sem usar funções nativas
// Exemplo usando while
$array_numeros  = array(100,35,92,43,77,88,11,241,22,18,32);
var_dump($array_numeros);

$i=0;
$total_numeros = sizeof($array_numeros);

while( $i < $total_numeros )
{
    $j = 0;
    while( $j < $total_numeros )
    {
        if($array_numeros[$j] > $array_numeros[$i])
        {
            $tmp_numero = $array_numeros[$i];

            $array_numeros[$i] = $array_numeros[$j];
            $array_numeros[$j] = $tmp_numero;
        }
        $j++;
    }
    $i++;
}

var_dump($array_numeros);

// ===================================================



// Exemplo de ordenação manual simples sem usar funções nativas
// Exemplo usando while
$array_numeros  = array(100,35,92,43,77,88,11,241,22,18,32);
var_dump($array_numeros);

$i=0;
$total_numeros = sizeof($array_numeros);

exibe_array_atual($array_numeros,-1,-1); // Não faz nada, apenas exibe array atual

while( $i < $total_numeros )
{
    $j = 0;
    while( $j < $total_numeros )
    {

        if($array_numeros[$j] > $array_numeros[$i])
        {
            exibe_array_atual($array_numeros,$i,$j);

            $tmp_numero = $array_numeros[$i];

            $array_numeros[$i] = $array_numeros[$j];
            $array_numeros[$j] = $tmp_numero;

            //exibe_array_atual($array_numeros,-1,-1);  // Novo array

        }
        $j++;
    }

    $i++;
}

var_dump($array_numeros);



function exibe_array_atual($array,$idx,$jdx)
{
    $c = count($array);
    $output='[';
    for($i=0;$i<$c;$i++)
    {
        $color='blue';

        if($i==$idx || $i==$jdx ) { $color = "red"; }


        $output.="&nbsp; $i <small>=&gt;</small> <span style=\"color:$color\"><b>{$array[$i]}</b></span>  ,";
    }
    $output = rtrim($output,",");
    $output.=']<br><br>';

    echo $output;
}



// ===================================================


//Mesmo exemplo anterior, só que usando for
$array_numeros  = array(103,35,92,43,77,89,11,241,22,18,32);
//var_dump($array_numeros);

$total_numeros = sizeof($array_numeros);

//$n_iteracoes = 0; //$n_iteracoes é um contador de iterações apenas para comparar com outros algoritmos
                  // $n_iteracoes não faz parte do algoritmo abaixo e sua retirada não interfere no código
                  //essa variável serve apenas como uma "medida de comparação" com os outros algoritmos que serão vistos em seguida

for( $i=0 ; $i<$total_numeros ; $i++ )
{
    for( $j=0; $j<$total_numeros; $j++ )
    {
        if($array_numeros[$j] > $array_numeros[$i])
        {
            $tmp_numero = $array_numeros[$i];

            $array_numeros[$i] = $array_numeros[$j];
            $array_numeros[$j] = $tmp_numero;
        }

        //$n_iteracoes++;
    }

    //$n_iteracoes++;
}

var_dump($array_numeros);
//echo 'Total: <b>'.$n_iteracoes.'</b> iterações';

// OBS: O algoritmo acima embora tenha muitas iterações, não utiliza nenhuma função de reordenação de índices
// e nem  funções de junção de arrays. Em questões de desafios ou provas de conhecimentos, essa seria uma boa resposta.


// ===================================================



//Outro exemplo com for, usando algoritmo de Quicksort
$array_numeros  = array(103,35,92,43,77,89,11,241,22,18,32);

$n_iteracoes = 0;

function quicksort( $array )
{
    global $n_iteracoes;

    if( count( $array ) < 2 )
    {
        return $array;
    }

    $left = $right = array( );

    reset( $array );

    $pivot_key  = key( $array );

    $pivot  = array_shift( $array );

    foreach( $array as $k => $v )
    {
        if( $v < $pivot )
            $left[$k] = $v;
        else
            $right[$k] = $v;

        $n_iteracoes++;
    }

    $n_iteracoes++;

    return array_merge(
                        quicksort($left),
                        array($pivot_key => $pivot),
                        quicksort($right)
                    );
}

//Using quicksort()
$array_ordenado  = quicksort( $array_numeros );

var_dump($array_ordenado);
echo 'Total: <b>'.$n_iteracoes.'</b> iterações';

// Lembrando que PHP já possui a função sort da linguagem pra esse tipo de ordenação
// Os algoritmos apresentados servem apenas para entendimento de como algoritmos de ordenação funcionam


// ===================================================



// Exemplo de Bubble sort
$array_numeros  = array(105,35,92,43,76,89,11,249,21,18,32);
$n_iteracoes=0;

function bubbleSort($array)
{
  global $n_iteracoes;

  for($i = 0; $i < count($array); $i++)
  {
    for($j = 0; $j < count($array) - 1; $j++)
    {
        if($array[$j] > $array[$j + 1])
        {
            $aux = $array[$j];
            $array[$j] = $array[$j + 1];
            $array[$j + 1] = $aux;
        }

        $n_iteracoes++;
    }

     $n_iteracoes++;
  }

  return $array;
}

$array_ordenado = bubbleSort($array_numeros);
var_dump($array_ordenado);

echo 'Total: <b>'.$n_iteracoes.'</b> iterações';



// ===================================================


// Ordenação de arrays usando funções do próprio PHP
/*
    //Básico
    sort() - Ordena um array
    rsort() - Ordena um array em ordem descrescente

    //Para valores em array associativo
    asort() - Ordena um array mantendo a associação entre índices e valores
    arsort() - Ordena um array em ordem descrescente mantendo a associação entre índices e valores

    //Para chaves em array associativo
    ksort() - Ordena um array pelas chaves
    krsort() - Ordena um array pelas chaves em ordem descrescente

    //Ordem natural - de teclado
    natsort() - Ordena um array utilizando o algoritmo da "ordem natural"
    natcasesort — Ordena um array utilizando o algoritmo da "ordem natural" sem diferenciar maiúsculas e minúsculas

    //Ordenação utilizando função definida pelo usuário
    usort() - Ordena um array pelos valores utilizando uma função de comparação definida pelo usuário
    uasort() - Ordena um array utilizando uma função de comparação definida pelo usuário e mantendo as associações entre chaves e valores
    uksort — Ordena um array pelas chaves utilizando uma função de comparação definida pelo usuário.

*/



echo '<hr>Sem ordenação';
$array_frutas = array("maçã","banana","pera","uva","morango","abacaxi","pêssego","melão","melancia","laranja","limão","maracujá");
var_dump($array_frutas);

echo '<hr>sort';
sort($array_frutas);
var_dump($array_frutas);

echo '<hr>rsort';
rsort($array_frutas);
var_dump($array_frutas);


// ===========================================



$array_frutas_assoc = array(
                    "a"=>"maçã",
                    "b"=>"banana",
                    "c"=>"pera",
                    "d"=>"uva",
                    "e"=>"morango",
                    "f"=>"abacaxi",
                    "g"=>"pêssego",
                    "h"=>"melão",
                    "i"=>"melancia",
                    "j"=>"laranja",
                    "k"=>"limão",
                    "l"=>"maracujá"
                    );


// Ao usar sort ou rsort puro em array associativo as chaves associativas são perdidas e substituídas por índices
// No array associativo para manter as associações após a ordenação usar asort ou arsort

echo '<hr>sort';
sort($array_frutas_assoc);
var_dump($array_frutas_assoc);

// Chaves se perdem ao se usar sort ou rsort em array associativo simples
foreach($array_frutas_assoc as $key=>$value)
{
    echo $key . '&raquo;' . $value . '<br>';
}

echo '<hr>rsort';
rsort($array_frutas_assoc);
var_dump($array_frutas_assoc);





// ===========================================
echo '<hr>Associativo sem ordenação 2';
$array_produtos = array(
                    array(
                            'nome'  =>'Laptop',
                            'preco' =>'3000'
                          ),
                    array(
                            'nome'  =>'Placa de Vídeo 3D',
                            'preco' =>'1500'
                          ),
                    array(
                            'nome'  =>'Mouse',
                            'preco' =>'200'
                          ),
                    array(
                            'nome'  =>'Teclado',
                            'preco' =>'150'
                          ),
                    array(
                            'nome'  =>'Monitor',
                            'preco' =>'800'
                          ),
                    array(
                            'nome'  =>'Computador Desktop',
                            'preco' =>'1500'
                          ),
                    array(
                            'nome'  =>'Memória 4GB',
                            'preco' =>'450'
                          ),
                    array(
                            'nome'  =>'HD 1TB',
                            'preco' =>'950'
                          )
                );
var_dump($array_produtos);

echo '<hr>Ordenado com asort';
asort($array_produtos);
var_dump($array_produtos);


echo '<hr>Ordenado com arsort';
arsort($array_produtos);
var_dump($array_produtos);




echo '<hr>Coluna preço na frente';
$coluna_nome  = array_column($array_produtos, 'nome');
$coluna_preco = array_column($array_produtos, 'preco');

$produtos_preco = array();

$i=0;
foreach($coluna_nome as $nome)
{
    $produtos_preco[] = array(
                            'preco'=>$coluna_preco[$i],
                            'nome'=>$nome,
                            );
    $i++;
}

var_dump($produtos_preco);


echo '<hr>Coluna preço na frente com asort';
asort($produtos_preco);
var_dump($produtos_preco);


echo '<hr>Coluna preço na frente com arsort';
arsort($produtos_preco);
var_dump($produtos_preco);




// ===================================================================



# CONSTANTES

define("NOMEDACONSTANTE","Aqui entra o valor da constante 123456"); // Nome da constante em maiúsculo. OK!
echo NOMEDACONSTANTE;

define("constanteemminusculo","o nome da constante pode ser em minúsculo mas fica zoado demais");   // <- Bacalhau
echo '<br>' . constanteemminusculo;

// embora a linguagem permita, POR CONVENÇÃO USE LETRA MAIÚScULA SEMPRE PARA NOMES DE CONSTANTES