Array

Description

Programação PHP Array
André Custódio
Mind Map by André Custódio, updated more than 1 year ago
André Custódio
Created by André Custódio almost 7 years ago
24
1

Resource summary

Array
  1. Criando Array
    1. Sintaxe 01
      1. $meuArray[0] = “valor1”
        1. $meuArray[1] = “valor2”
        2. Sintaxe 02
          1. $meuArray = array(“valor1”, “valor2”)
          2. Sintaxe 03
            1. $meuArray[nome] = “André”
              1. $meuArray[idade] = “38”
              2. Sintaxe 04
                1. $meuArray = array(“nome”=>”André”, “idade”=>38)
              3. Populando
                1. range(int low, int higt [,int step])
                  1. cria e preeche um array com limite
                    1. $meuArray = range(0,10)
                    2. range(início, fim [,incremento])
                    3. Micelandia
                      1. is_array
                        1. Verifica de é array
                          1. is_array(nome_da_variável_ou_do_array);
                        2. Adicionando e Removendo elementos
                          1. array_unshift
                            1. Adiciona no início do array
                              1. array_unshift($meuArray,"maça","banana");
                              2. array_push
                                1. Adiciona no final do array
                                  1. array_push($meuArray,"maça","banana");
                                  2. array_shift
                                    1. Remove o primeiro elemento e retorna o item encontrado
                                      1. $item = array_shift($meuArray);
                                        1. $item = primeiro elemento
                                          1. $meuArray = elementos com exceção do primeiro
                                        2. array_pop
                                          1. Remove o ultimo elemento e retorna o item encontrado
                                            1. $item = array_pop($meuArray);
                                              1. $meuArray = elementos com exceção do ultimo
                                                1. $item = ultimo elemento
                                            2. Localizando elementos
                                              1. in_array
                                                1. Busca um elemento dentro de Array, True se encontrar
                                                  1. $tem = in_array("pera",$meuArray);
                                                    1. $tem = True
                                                  2. array_key_exists
                                                    1. Busca uma chave específica dentro do array
                                                      1. $tem = array_key_exists("NomeChave",$meuArray);
                                                        1. $tem = True
                                                      2. array_search
                                                        1. Busca no array um valor específico e retorna a chave se encontrar
                                                          1. $chave = array_search("NomeValue",$meuArray);
                                                            1. $chave = nomeChave
                                                          2. array_keys
                                                            1. Retornar um array com todas as chaves localizados em outro array
                                                              1. $chaves = array_keys($clientes);
                                                                1. $chaves = array("chave1","chave2","chave3")
                                                              2. array_values
                                                                1. Retornar um array com todas as valores localizados em outro array
                                                                  1. $valores = array_values($clientes);
                                                                    1. $valores = array("valor1","valor2","valor3")
                                                                2. Percorrendo Array
                                                                  1. key
                                                                    1. Retorna a chave da posição atual do Array
                                                                      1. while($chave = key($cliente){echo $chave; next($cliente)}
                                                                      2. current
                                                                        1. Retorna o elemento corrente em um array
                                                                          1. while($valor = key($cliente){echo $valor; next($cliente)}
                                                                          2. each
                                                                            1. Retorna o par chave/valor corrente de um array e avança seu cursor
                                                                              1. $par = each($cliente);
                                                                                1. Retorno
                                                                                  1. [1] = 120
                                                                                    1. [value] = 120
                                                                                      1. [0] = id
                                                                                        1. [key] = id
                                                                                      2. Cursor no final retorna False
                                                                                    2. Movendo o ponteiro no array
                                                                                      1. next
                                                                                        1. Avança o ponteiro interno de um array
                                                                                          1. $proximo = next($meuArray); retorna o próximo elemento
                                                                                          2. prev
                                                                                            1. Retrocede o ponteiro interno de um array
                                                                                              1. $anterior = prev($meuArray); retorna o elemento anterior do array
                                                                                              2. reset
                                                                                                1. Faz o ponteiro interno apontar para o primeiro elemento
                                                                                                  1. $primeiro = reset($meuArray); vai direto par o primeiro elemento
                                                                                                  2. end
                                                                                                    1. Faz o ponteiro interno apontar para o último elemento
                                                                                                      1. $ultimo = end($meuArray); vai direto par o ultimo elemento
                                                                                                    2. Determinando o tamanho do array
                                                                                                      1. count
                                                                                                        1. Retorna o número total valores de um array
                                                                                                          1. $quant = count($meuArray);
                                                                                                            1. Retorna um número inteiro representando a quantidade de elementos
                                                                                                          2. array_count_values
                                                                                                            1. Retorna um array que indica a frequência que aparecem os valores
                                                                                                              1. $frequencia = array_count_values($meuArray);
                                                                                                                1. $frequencia = array("elemento1" => 3, "elemento2" => 1, "elemento3" => 5, )
                                                                                                              2. array_unique
                                                                                                                1. retorna um array apenas com os valores únicos
                                                                                                                  1. $unico = array_unique($meueArray);
                                                                                                                    1. $unico = array(...valores unicos...)
                                                                                                                2. Classificando o array
                                                                                                                  1. array_reverse
                                                                                                                    1. Retorna um array com os elementos em ordem iversa
                                                                                                                      1. $inverso = array_reverse($meuArray);
                                                                                                                      2. array_flip
                                                                                                                        1. Troca os valores para chave e as chaves para valores
                                                                                                                          1. $troca = array_flip($meuArray);
                                                                                                                          2. sort
                                                                                                                            1. Ordena um array, não retorna nada apenas ordena.
                                                                                                                              1. $troca = array_sort($meuArray[, flags]);
                                                                                                                                1. problema: chave trocada
                                                                                                                                2. Flags
                                                                                                                                  1. sort_regular
                                                                                                                                    1. compara os tipos normalmente (não altera o tipo)
                                                                                                                                    2. sort_numeric
                                                                                                                                      1. compara os tipos numericamente
                                                                                                                                      2. sort_string
                                                                                                                                        1. compara os itens como texto
                                                                                                                                        2. sort_locate_string
                                                                                                                                          1. compara os itens como texto, utilizando o local atual
                                                                                                                                          2. sort_natural
                                                                                                                                            1. compara os itens como texto, utilizando ordenação natural
                                                                                                                                            2. sort_flag_case
                                                                                                                                              1. pode ser combinado (bitwise OR) com sort_string
                                                                                                                                              2. sort_natural
                                                                                                                                                1. para ordenar string sem considerar maiúsculas e minúsculas
                                                                                                                                            3. rsort
                                                                                                                                              1. ordena o array em ordem decrescente
                                                                                                                                                1. rsort($meuArray);
                                                                                                                                                2. asort
                                                                                                                                                  1. ordena o array em ordem crescente sem trocar as chaves
                                                                                                                                                    1. asort($meuArray);
                                                                                                                                                    2. arsort
                                                                                                                                                      1. ordena o array em ordem decrescente sem trocar as chaves
                                                                                                                                                        1. arsort($meuArray);
                                                                                                                                                      2. Unindo, dividindo e combinando
                                                                                                                                                        1. array_marge
                                                                                                                                                          1. combina um ou mais array, retornando um único array
                                                                                                                                                            1. $unindo = array_marge($meuArray, $letras);
                                                                                                                                                            2. array_combine
                                                                                                                                                              1. mistura dois arrays sendo o primeiro as chaves e o segundo os valores
                                                                                                                                                                1. array_combine($letras, $meusArray);
                                                                                                                                                                2. array_slice
                                                                                                                                                                  1. extrai uma parte de um array
                                                                                                                                                                    1. $valores = array_slice($meuArray, 2);
                                                                                                                                                                      1. Pula o valor 0 e 1, pega do valor 2 em diante
                                                                                                                                                                      2. $valores = array_slice($meuArray, -2, 1);
                                                                                                                                                                        1. o sinal negatigo indica que a varredura é de traz para frente
                                                                                                                                                                          1. o último é o índice zero, o penúltimo é o índice 1; pega do antepenúltimo para frente
                                                                                                                                                                            1. o número 1 indica que só sera pego um valor
                                                                                                                                                                          2. array_splice
                                                                                                                                                                            1. Remove uma parcela do array e substitui com outros elementos
                                                                                                                                                                              1. sintaxe => array_splice(array, onde_começa, quant_elementos, array)
                                                                                                                                                                                1. $valores = array_splice($meses,1,3, $semana);
                                                                                                                                                                                  1. $semana = array("seg","ter","qua","qui","sex","sab","dom");
                                                                                                                                                                                    1. $meses = array("janeiro","fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro");
                                                                                                                                                                                      1. Retorna no print_r: Array ( [0] => fevereiro [1] => março [2] => abril )
                                                                                                                                                                                        1. print_r($meses): Array ( [0] => janeiro [1] => seg [2] => ter [3] => qua [4] => qui [5] => sex [6] => sab [7] => dom [8] => maio [9] => junho [10] => julho [11] => agosto [12] => setembro )
                                                                                                                                                                                      2. array_intersect
                                                                                                                                                                                        1. Retorna a intersecção entre array's com a chave do segundo array
                                                                                                                                                                                          1. $interseccao = array_intersect($primeiroArray,$SegundoArray);
                                                                                                                                                                                          2. array_intersect_assoc
                                                                                                                                                                                            1. Retorna a intersecção entre array's chave e elemento, com a chave do segundo array
                                                                                                                                                                                              1. $interseccao = array_intersect_assoc($primeiroArray,$SegundoArray);
                                                                                                                                                                                              2. array_diff_assoc
                                                                                                                                                                                                1. Retorna os valores que estão localizados no primeiro array (valores e chaves) e não estão em nenhum outro.
                                                                                                                                                                                                  1. array_diff_assoc($primeiroArray,$SegundoArray);
                                                                                                                                                                                                  2. array_diff
                                                                                                                                                                                                    1. Retorna os valores que estão localizados no primeiro array e não estão em nenhum outro.
                                                                                                                                                                                                      1. array_diff($primeiroArray,$SegundoArray);
                                                                                                                                                                                                    2. Outras funções
                                                                                                                                                                                                      1. array_rand
                                                                                                                                                                                                        1. Retorna um ou mais elementos de um array
                                                                                                                                                                                                          1. array_rand($meses , 2);
                                                                                                                                                                                                          2. shuffle
                                                                                                                                                                                                            1. Mistura os elementos de um array
                                                                                                                                                                                                              1. shuffle($meses);
                                                                                                                                                                                                                1. No próprio array $meses, após o comando os elementos estarão misturados
                                                                                                                                                                                                              2. array_sum
                                                                                                                                                                                                                1. Retaorna o cálcula da soma dos elementos de array
                                                                                                                                                                                                                  1. $total= Array_sum($numeros);
                                                                                                                                                                                                                  2. array_product
                                                                                                                                                                                                                    1. array_product($numeros);
                                                                                                                                                                                                                      1. array_chunk
                                                                                                                                                                                                                        1. Divide um array em pedaços
                                                                                                                                                                                                                              Show full summary Hide full summary

                                                                                                                                                                                                                              Similar

                                                                                                                                                                                                                              PHP e Laravel
                                                                                                                                                                                                                              Danilo Righetto
                                                                                                                                                                                                                              Curso Básico I PHP & MYSQL
                                                                                                                                                                                                                              Silvio H Fleming
                                                                                                                                                                                                                              GMUD - Gestão de mudança
                                                                                                                                                                                                                              Welingson Santos
                                                                                                                                                                                                                              Laravel
                                                                                                                                                                                                                              Rafael Gibam
                                                                                                                                                                                                                              Organizando Estudos de Férias.
                                                                                                                                                                                                                              Ronald SS
                                                                                                                                                                                                                              Sistema Eventos
                                                                                                                                                                                                                              Victor Braun
                                                                                                                                                                                                                              Esquema do CRUD WEBSERVICE PHP
                                                                                                                                                                                                                              Alex Silva
                                                                                                                                                                                                                              Valodando formulario login
                                                                                                                                                                                                                              Daniel Souza7582
                                                                                                                                                                                                                              PHP - Escopo e Visibilidade
                                                                                                                                                                                                                              Vinícius Rezendrix
                                                                                                                                                                                                                              Esquema de Pastas Laravel 6.2
                                                                                                                                                                                                                              Vinícius Rezendrix
                                                                                                                                                                                                                              Introdução à Linguagem PHP 7
                                                                                                                                                                                                                              Kelvin Renan Santos de Lira krsdl