Funciones PHP para arrays

Estas son algunas de las funciones de PHP utilizadas para los arrays:

• sort: Ordena un array.

• rsort: Ordena un array en orden inverso.

• ksort: Ordena un array por clave.

• krsort: Ordena un array por clave en orden inverso.

• array_slice: Extrae una parte de un array.

• array_chunk: Divide un array en fragmentos.

• array_shift: Quita un elemento del principio del array.

• array_pop: Extrae el último elemento del final del array.

• array_unshift: Añadir al inicio de un array uno a más elementos.

• array_push: Inserta uno o más elementos al final de un array.

• array_flip: Intercambia todas las claves de un array con sus valores asociados.

Interesante, esto es lo que amo de PHP, posee un arsenal de funciones muy útiles, al igual que en la clase de strings, les dejo ña página con más funciones útiles para php en este enlace

Recuerda que esta página en la biblia del programador de PHP, ahí está toda su documentación 😄

Reto cumplido, así quedaron los métodos. Todos funcionando.

  $courses = [
    'backend' =>'PHP', 
    'frontend' => 'Javascript', 
    'framework' => 'Laravel'
  ];
  
  echo "<pre>";
    var_dump(array_flip($courses));
    var_dump(array_slice($courses, 1));
    var_dump(array_chunk($courses, 1));
    
    $course = array_shift($courses);
    $data = array_pop($courses);
    print_r($data);

    array_unshift($courses, "vuejs", "css");
    print_r($courses);
    array_push($courses, "vuejs");

Mis apuntes

<?php

echo "<h1>Funciones PHP para arrays</h1>";
echo "---------------";

$courses = ['php', 'javascript', 'laravel'];
$course = [
	10 => 'php', 
	100 => 'javascript', 
	1000 => 'laravel'
];
//ordenar 
sort($courses);
#Ordenar de forma Recursiva
//rsort($courses);


#Ordenar por Key
ksort($course);
//krsort($course); //Ordenar de forma Recursiva

echo("<pre>");
var_dump($courses);
echo "<br>";
var_dump($course);

echo "<br>";
#array_slide array rebanada
//en este caso eliminamos el Key 1
array_slice($courses, 1);
var_dump(array_slice($course, 1));
//Resultado
/*
array(2) {
	[0]=>
	string(10) "javascript"
	[1]=>
	string(7) "laravel"
  }
*/

echo "<br>";
#array_chunk array pedazo
$courses_chunk = ['php', 'javascript', 'laravel'];
//en este caso crea un 2 arrays y uno de ellos contiene dos elementos de los 3 que cotiene el array principal
array_chunk($courses_chunk, 2);
var_dump(array_chunk($courses_chunk, 2));

echo "<br>";
#array_shift() 
$courses_shift = ['php', 'javascript', 'laravel'];
//Quita un elemento del principio del array
array_shift($courses_shift);
var_dump(array_shift($courses_shift));

echo "<br>";
#array_pop()
$courses_pop = ['php', 'javascript', 'laravel'];
//Extrae el último elemento del final del array
array_pop($courses_pop);
var_dump($courses_pop);

echo "<br>";
#array_unshift()
$courses_unshift = ['php', 'javascript', 'laravel'];
//Añadir al inicio de un array uno a más elementos
array_unshift($courses_unshift, 'laravel2', 'javascript2');
var_dump($courses_unshift);

echo "<br>";
#array_push()
$courses_push = ['php', 'javascript', 'laravel'];
//Inserta uno o más elementos al final de un array
array_push($courses_push, 'laravel1', 'javascript1');
var_dump($courses_push);

echo "<br>";
#array_flip()
$courses_flip = [
	'backend' => 'php', 
	'forntend' => 'javascript'
];
//Intercambia todas las claves de un array con sus valores asociados
$intercambio = array_flip($courses_flip);
var_dump($intercambio);

la r de rsort es de reverse, no recursivo.

Funciones PHP para arrays

Vamos ver funciones propias de PHP que nos servirán para manipular correctamente un Array, estas funciones nos permitirán manejar de mejor manera los Arrays, pero también los conceptos nos ayudarán cuando estemos trabajando con database.

<?php

$courses = [
    10 => 'php',
    100 => 'javascript',
    1000 => 'laravel'
];

ksort($courses);

var_dump($courses);

• sort($courses) → Ordena de forma alfabética.
• rsort($courses) → Ordena de forma alfabética pero en descendente.
• ksort($courses) → Ordena por la key.
• krsort($courses) → Ordena por la key pero en descendente.
• array_slice() → Nos deja quitar elementos del array.
• array_chunk() → Nos deja tomar diferentes pedazos de datos y los convierte en Arrays individuales.
• array_shift() → Nos retorna el primer valor y lo elimina del array.
• array_pop() → Nos retorna el último valor y lo elimina del array.
• array_unshift() → Agrega nuevos valores al array.
• array_push() → Inserta uno o más valores al final de un array.
• array_flip() → Nos deja intercambiar los keys por los valores y viceversa.

var_dump(array_unshift($courses, 'Ruby'));

✨ PHP tiene un stock completo de funciones para trabajar con arrays. Esto facilita en gran medida el desarrollo de nuestras aplicaciones.

Un pequeño error, la r es de reverse, no de recursivo.

Hola.
Al rededor del minuto 4:10 el elemento que se quita del array no es php sino laravel, esto es debido a que el array $courses está ordenado por sus claves de forma descendente, por lo tanto el primer elemento sería 1000 => ‘laravel’, es cual es el que se retira.

🎯 TIP: Para imprimir una array completo podemos usar la función print_r ($array)

La función sort() ordena de 2 dos manera:

• Alfabéticamente (a-z):

fruits[0] = apple
fruits[1] = banana
fruits[2] = lemon
fruits[3] = orange

• Numéricamente, (si tiene los mismos caracteres y se distinguen por algún numero):

fruits[0] = Orange1
fruits[1] = orange2
fruits[2] = Orange3
fruits[3] = orange20

• Si tiene muchos caracteres distintos, puede devolver errores

Para ordenar arrays complejos o asociativos, existen estas dos funciones:
asort()
arsort()
De esta forma se conserva la clave =>valor, pero se ordena por valor.

";
print_r($courses);
echo "

";
print_r($courses);
echo "

";
print_r($courses);
echo "

";
print_r(array_slice($courses, 1));
echo "

";
print_r(array_chunk($courses, 2));
echo "

";
print_r($courses);
echo "

";
print_r($courses);
echo "

";
print_r($courses);
echo "

";
print_r($courses);
echo "

";
print_r(array_flip($courses_tech));
echo "

";print\_r($courses);echo "\

";print\_r($courses);echo "\

";print\_r($courses);echo "\

";print\_r(array\_slice($courses, 1));echo "\

";print\_r(array\_chunk($courses, 2));echo "\

";print\_r($courses);echo "\

";print\_r($courses);echo "\

";print\_r($courses);echo "\

";print\_r($courses);echo "\

";print\_r(array\_flip($courses\_tech));echo "\

Confunde un poco usar el array_slice despues del krsort y luego marcar con comentarios que el que debía salir era el que tiene de valor “php”

les dejo mis apuntes por si los quieren guardar en un archivo php 😃

<?php

$courses = ['PHP', 'JavaScript', 'Laravel'];

$cursos = [
    10 => 'PHP',
    100 => 'JavaScript',
    1000 => 'Laravel'
];
sort($courses); 
echo "sort: Ordena el array <br>";
echo "<pre>";
var_dump($courses);
echo "<br>";

rsort($courses); 
echo "rsort: Ordena el arrayen orden inverso <br>";
var_dump($courses);
echo "<br>";


ksort($cursos);
echo "ksort: Ordena respecto a las llaves <br>";
var_dump($cursos);
echo "<br>";


krsort($cursos);
echo "krsort: Ordena en el orden inverso respecto a las llaves <br>";
var_dump($cursos);
echo "<br>";

echo "array_slice: Extrae una parte del array <br>";
var_dump(array_slice($cursos, 1));
echo "<br>";

echo "array_chunk: Divide el array en fragmentos <br>";
var_dump(array_chunk($courses, 2));
echo "<br>";

echo "array_shift: elimina el primer elemento del array y lo retorna <br>";
var_dump(array_shift($courses));
echo "<br>";

echo "array_pop: elimina el ultimo elemento del array y lo retorna <br>";
var_dump(array_pop($courses));
echo "<br>";

echo "array_unshift: agrega un elemento al incio del array y
retorna la cantidad de elementos <br>";
var_dump(array_unshift($courses, 'php'));
echo "<br>";

echo "array_push: agrega un elemento al incio del array y
retorna la cantidad de elementos <br>";
var_dump(array_push($courses, 'JavaScript'));
echo "<br>";

echo "array_flip: cambia los keys por los valores <br>";
var_dump(array_flip($cursos));
echo "<br>";

🍃Aquí está una lista de funciones para manipular arrays en PHP, con una breve explicación de su uso:

1. array_keys: Devuelve una matriz que contiene todas las claves de un array.
2. array_values: Devuelve una matriz que contiene todos los valores de un array.
3. array_merge: Combina varios arrays en uno solo.
4. array_diff: Devuelve una matriz que contiene las claves y valores que no están presentes en otro o más arrays.
5. array_intersect: Devuelve una matriz que contiene las claves y valores que están presentes en todos los arrays.
6. array_slice: Devuelve una porción de un array como una nueva matriz.
7. array_splice: Agrega o elimina elementos de un array y devuelve los elementos eliminados como una nueva matriz.
8. array_search: Devuelve la clave de un valor en un array o false si no se encuentra.
9. array_unique: Devuelve una matriz que contiene solo valores únicos.
10. array_reverse: Devuelve una matriz con los elementos en orden inverso.
11. array_map: Aplica una función a cada elemento de un array y devuelve una nueva matriz con los resultados.
12. array_reduce: Aplica una función acumuladora a cada elemento de un array y devuelve un valor único resultante.
13. array_filter: Filtra los elementos de un array según una condición y devuelve una nueva matriz con los elementos que cumplen la condición.
14. array_sum: Devuelve la suma de los valores de un array numérico.
15. sort: Ordena los elementos de un array.
16. array_pop: Elimina el último elemento de un array y devuelve su valor.
17. array_unshift: Agrega uno o más elementos al principio de un array.
18. array_push: Agrega uno o más elementos al final de un array.
19. array_flip: Invierte las claves con sus valores en un array.

Estas son solo algunas de las muchas funciones disponibles en PHP para manipular arrays. Es importante revisar la documentación de PHP para conocer todas las opciones disponibles y elegir la mejor solución para cada caso específico.
Les dejo la documentación oficial. https://www.php.net/manual/es/ref.array.php

• En esta clase vamos a ver funciones para PHP que me van a servir para manipular correctamente un array; ¿Qué se quiere decir con esto? que estas funciones me van a permitir manejar de mejor manera este tipo de datos, pero los conceptos nos van a ayudar muchisimo cuando estemos trabajando con bases de datos.

Funciones PHP para arrays

1. sort. Ordena un array.
2. rsort. Ordena un arrey en orden inverso.
3. Ksort. Ordena un array por clave.
4. krsort. Ordena un array por clave en orden inverso.
5. array_slice. Extrae una parte de un array.
6. array_chunk. Divide un array en fragmentos.
7. array_shift. Quita un elemento del principio del array.
8. array_pop. Extrae el último elemento del final del array.
9. array_unshift. Añadir al inicio de un array uno o más elementos.
10. array_push. Inserta uno o más elementos al final de un array.
11. array_flip. Intercambia todas las clases de un array con sus valores asociados.

Ejercicio 5 Funciones con arrays

Resumen de la clase

<?php
/* $courses =[
    10 =>'PHP',
    100 =>'JavaScript',
    1000 =>'Python',
    100000 =>'C#',
    1000000 => 'C++'];

krsort($courses);

echo '<pre>';
//var_dump($courses);

echo '<br>';

var_dump(array_slice($courses,1));
echo '</pre>';
 */

$courses=['PHP','JavaScript','Python','C#','C++'];
echo '<pre>';
var_dump(array_chunk($courses,2));
echo '</pre>';

array_shift($courses); //Elimina el primer elemento del array
array_pop($courses); //Elimina el ultimo elemento del array
array_unshift($courses,'PHP'); //Agrega un elemento al principio del array
array_push($courses,'C#'); //Agrega un elemento al final del array
array_flip($courses); //Invertir el orden de los elementos del array

Buenas! Comparto algunos ejercicios con las funciones para modificar los elementos de un array. Saludos!

<?php

$courses = [
    10 =>'php',
    100 =>'laravel',
    1000 =>'javascript'
];


//eliminar el primer elemento y retornarlo
var_dump(array_shift($courses));

<?php
//Eliminar y retornar el último elemento
var_dump(array_pop($courses));

//Agregar elemento en el índice 0
array_unshift($courses, 'Elemento');

echo "<pre>";
var_dump($courses);

//Agregar elemento al final del array
array_push($courses, 'Elemento');
var_dump($courses);
![Captura5.PNG](https://static.platzi.com/media/user_upload/Captura5-ca0737af-f84d-42e5-b589-7d8ee1352db0.jpg)

$courses = [
    'backend' =>'php',
    'framework' =>'laravel',
    'frontend' =>'javascript'
];

//Intercambiar las key por los valores de un array
var_dump(array_flip($courses));

Al ordenar al revés (rsort), el profesor dice que esa ‘r’ hace referencia al ‘orden recursivo’ (1:54)… ¿No será que hace referencia a ‘reverse’ sort? No veo nada de recursividad aquí.

Funciones para probar con sus resultados:

<?php

/* **CREDITOS DE LAS DESCRIPCIONES: Manuel Andrés Buriticá Yepes
*   sort: Ordena un array.
*   
*   rsort: Ordena un array en orden inverso.
*   
*   ksort: Ordena un array por clave.
*   
*   krsort: Ordena un array por clave en orden inverso.
*   
*   array_slice: Extrae una parte de un array.
*   
*   array_chunk: Divide un array en fragmentos.
*   
*   array_shift: Quita un elemento del principio del array.
*   
*   array_pop: Extrae el último elemento del final del array.
*   
*   array_unshift: Añadir al inicio de un array uno a más elementos.
*   
*   array_push: Inserta uno o más elementos al final de un array.
*   
*   array_flip: Intercambia todas las claves de un array con sus valores asociados.
*/

$courses = [
    10023 =>'C',
    10 =>'JS', 
    870=>'Java', 
    100 => 'Python', 
    210 =>'PHP'
    ];

    echo('<pre>');
    var_dump( sort($courses));
    var_dump( $courses);
    echo('</pre>');
    echo('<br>');
    echo('<pre>');
    var_dump( rsort($courses));
    var_dump( $courses);
    echo('</pre>');
    echo('<br>');
    $courses = [
        10023 =>'C',
        10 =>'JS', 
        870=>'Java', 
        100 => 'Python', 
        210 =>'PHP'
        ];
    echo('<br>');
    echo('<pre>');
    var_dump( ksort($courses));
    var_dump( $courses);
    echo('</pre>');
    echo('<br>');
    echo('<pre>');
    var_dump( krsort($courses));
    var_dump( $courses);
    echo('</pre>');
    echo('<br>');
    echo('<pre>');
    var_dump( array_slice($courses, 2));
    echo('</pre>');
    echo('<br>');
    echo('<pre>');
    var_dump( array_chunk($courses, 3));
    echo('</pre>');
    echo('<br>');
    echo('<pre>');
    var_dump( array_shift($courses));
    echo('</pre>');
    echo('<br>');
    echo('<pre>');
    var_dump( array_pop($courses));
    echo('</pre>');
    echo('<br>');
    echo('<pre>');
    var_dump( array_unshift($courses, ['data_base'=>'MySQL']));
    var_dump( $courses);
    echo('</pre>');
    echo('<br>');
    echo('<pre>');
    var_dump( array_push($courses, ['framework'=>'Laravel']));
    var_dump( $courses);
    echo('</pre>');
    $courses = [
        'estructurado' =>'C',
        'frontend' =>'JS', 
        'oo'=>'Java', 
        'ia' => 'Python', 
        'backend' =>'PHP'
        ];
    echo('<br>');
    echo('<pre>');
    var_dump( array_flip($courses)); //Funciona solo si las Key son números
    echo('</pre>');
    echo('<br>');```
>>
**Resultados:**
>

bool(true)
array(5) {
[0]=>
string(1) “C”
[1]=>
string(2) “JS”
[2]=>
string(4) “Java”
[3]=>
string(3) “PHP”
[4]=>
string(6) “Python”
}

bool(true)
array(5) {
[0]=>
string(6) “Python”
[1]=>
string(3) “PHP”
[2]=>
string(4) “Java”
[3]=>
string(2) “JS”
[4]=>
string(1) “C”
}

bool(true)
array(5) {
[10]=>
string(2) “JS”
[100]=>
string(6) “Python”
[210]=>
string(3) “PHP”
[870]=>
string(4) “Java”
[10023]=>
string(1) “C”
}

bool(true)
array(5) {
[10023]=>
string(1) “C”
[870]=>
string(4) “Java”
[210]=>
string(3) “PHP”
[100]=>
string(6) “Python”
[10]=>
string(2) “JS”
}

array(3) {
[0]=>
string(3) “PHP”
[1]=>
string(6) “Python”
[2]=>
string(2) “JS”
}

array(2) {
[0]=>
array(3) {
[0]=>
string(1) “C”
[1]=>
string(4) “Java”
[2]=>
string(3) “PHP”
}
[1]=>
array(2) {
[0]=>
string(6) “Python”
[1]=>
string(2) “JS”
}
}

string(1) “C”

string(2) “JS”

int(4)
array(4) {
[0]=>
array(1) {
[“data_base”]=>
string(5) “MySQL”
}
[1]=>
string(4) “Java”
[2]=>
string(3) “PHP”
[3]=>
string(6) “Python”
}

int(5)
array(5) {
[0]=>
array(1) {
[“data_base”]=>
string(5) “MySQL”
}
[1]=>
string(4) “Java”
[2]=>
string(3) “PHP”
[3]=>
string(6) “Python”
[4]=>
array(1) {
[“framework”]=>
string(7) “Laravel”
}
}

array(5) {
[“C”]=>
string(12) “estructurado”
[“JS”]=>
string(8) “frontend”
[“Java”]=>
string(2) “oo”
[“Python”]=>
string(2) “ia”
[“PHP”]=>
string(7) “backend”
}```

Arrays en php
https://www.codewall.co.uk/php-arrays-explained/

Pagina de consulta frecuente para conocer las funciones built-in del lenguaje en relacion a este tipo de dato (array) https://www.php.net/manual/es/ref.array.php

13. Funciones PHP para arrays:

Comparto el código visto en clase:

<?php

/**
 *sort($array); ordena un array
 *rsort($array); ordena un array de forma reversa
 *ksort($array); ordena un array en base a su key
 *krsort($array); ordena un array en base a su key de forma reversa
 *array_slice($array, n); quita el elemento n
 *array_chunk($array, n); parte un array en n pedazos
 *Lo curioso es que crea n arrays
 *
 *
 */

$courses = [
    'backend' => 'php',
    'frontend' => 'javascript',
    'framework' => 'laravel'
];
krsort($courses);

echo "<pre>";
//var_dump($courses);

//var_dump(array_chunk($courses, 2));

//El sistema retorna 'php', quitándolo del array
//Es decir borra el primer elemento
// array_shift($courses); ['javascript','laravel'];

//El sistema retorna 'laravel', quitándolo del array
//Es decir borra el último elemento
//array_pop($courses); ['php', 'javascript'];

//El sistema agrega uno o más elemento al inicio del array
//array_unshift($courses, 'python'); ['python', 'php', 'javascript','laravel'];

//El sistema agrega uno o más elemento al final del array
//array_push($courses, 'python'); ['php', 'javascript','laravel', 'python'];

//El sistema invierte entre keys y valores del array
var_dump(array_flip($courses));

Aporte de un compañero:

Estas son algunas de las funciones de PHP utilizadas para los arrays:

• sort: Ordena un array.
• rsort: Ordena un array en orden inverso.
• ksort: Ordena un array por clave.
• krsort: Ordena un array por clave en orden inverso.
• array_slice: Extrae una parte de un array.
• array_chunk: Divide un array en fragmentos.
• array_shift: Quita un elemento del principio del array.
• array_pop: Extrae el último elemento del final del array.
• array_unshift: Añadir al inicio de un array uno a más elementos.
• array_push: Inserta uno o más elementos al final de un array.
• array_flip: Intercambia todas las claves de un array con sus valores asociados.

<?php
// Your code here!
$courses = [
    'proyecto'=>'php',
    'general'=> 'js',
     'final'=>'laravel'
    ];
    
    
   array_shift($courses);
    echo "<pre>";
   // var_dump (array_chunk($courses, 3));
   
  var_dump($courses);
?>
<?php
// Your code here!
$courses = [
    'proyecto'=>'php',
    'general'=> 'js',
     'final'=>'laravel'
    ];
    
    
   array_pop($courses);
    echo "<pre>";
   // var_dump (array_chunk($courses, 3));
   
  var_dump($courses);
?>
<?php
// Your code here!
$courses = [
    'proyecto'=>'php',
    'general'=> 'js',
     'final'=>'laravel'
    ];
    
    
   array_unshift($courses,'react');
    echo "<pre>";
   // var_dump (array_chunk($courses, 3));
   
  var_dump($courses);
?>
<?php
// Your code here!
$courses = [
    'proyecto'=>'php',
    'general'=> 'js',
     'final'=>'laravel'
    ];

   array_push($courses,'react', 'python');
    echo "<pre>";
   // var_dump (array_chunk($courses, 3));
   
  var_dump($courses);
?>
<?php
// Your code here!
$courses = [
    'proyecto'=>'php',
    'general'=> 'js',
     'final'=>'laravel'
    ];
    
    
   array_flip($courses);
    echo "<pre>";
   // var_dump (array_chunk($courses, 3));
   
  var_dump($courses);
?>

Probando las funciones de arrays

<?php

$courses = [
  'php',
  'javascript',
  'laravel'
];

echo '<pre>';

echo "<h3>Original</h3>";
var_dump($courses);

echo "<h3>Array Shift</h3>";
$var_array_shift = $courses;
echo "Return:<br/><br/>";
var_dump(array_shift($var_array_shift));
echo "<br/>Result Array:<br/><br/>";
var_dump($var_array_shift);

echo "<h3>Array Pop</h3>";
$var_array_pop = $courses;
echo "Return:<br/><br/>";
var_dump(array_pop($var_array_pop));
echo "<br/>Result Array:<br/><br/>";
var_dump($var_array_pop);

echo "<h3>Array Unshift</h3>";
$var_array_unshift= $courses;
echo "Return:<br/><br/>";
var_dump(array_unshift($var_array_unshift,'html'));
echo "<br/>Result Array:<br/><br/>";
var_dump($var_array_unshift);

echo "<h3>Array Push</h3>";
$var_array_push= $courses;
echo "Return:<br/><br/>";
var_dump(array_push($var_array_push,'html'));
echo "<br/>Result Array:<br/><br/>";
var_dump($var_array_push);

echo "<h3>Array Flip</h3>";
$var_array_flip= $courses;
echo "Return:<br/><br/>";
var_dump(array_flip($var_array_flip));
echo "<br/>Result Array:<br/><br/>";
var_dump($var_array_flip);

Resultado

Original
array(3) {
[0]=>
string(3) “php”
[1]=>
string(10) “javascript”
[2]=>
string(7) “laravel”
}
Array Shift
Return:

string(3) “php”

Result Array:

array(2) {
[0]=>
string(10) “javascript”
[1]=>
string(7) “laravel”
}
Array Pop
Return:

string(7) “laravel”

Result Array:

array(2) {
[0]=>
string(3) “php”
[1]=>
string(10) “javascript”
}
Array Unshift
Return:

int(4)

Result Array:

array(4) {
[0]=>
string(4) “html”
[1]=>
string(3) “php”
[2]=>
string(10) “javascript”
[3]=>
string(7) “laravel”
}
Array Push
Return:

int(4)

Result Array:

array(4) {
[0]=>
string(3) “php”
[1]=>
string(10) “javascript”
[2]=>
string(7) “laravel”
[3]=>
string(4) “html”
}
Array Flip
Return:

array(3) {
[“php”]=>
int(0)
[“javascript”]=>
int(1)
[“laravel”]=>
int(2)
}

Result Array:

array(3) {
[0]=>
string(3) “php”
[1]=>
string(10) “javascript”
[2]=>
string(7) “laravel”
}

Apuntes–>

<?php
//
$courses = ["php","uno","dos","tres"];
sort($courses); // sort sirve para ordenar d forma descendente los elementos dentro de un array

echo "<pre>";
var_dump($courses);
//
//
$courses = ["php","uno","dos","tres"];
rsort($courses); // rsort sirve para ordenar d forma contraria los elementos dentro de un array

echo "<pre>";
var_dump($courses);
//
//
$courses = [
    1=> "php",
    10=> "uno",
    100=> "dos",
    1000=> "tres"];
ksort($courses); // ksort sirve para ordenar por el orden de los key los elementos dentro de un array

echo "<pre>";
var_dump($courses);
//
//
$courses = [
    1=> "php",
    10=> "uno",
    100=> "dos",
    1000=> "tres"];
krsort($courses); // krsort sirve para ordenar por el orden recursivo de los key los elementos dentro de un array

echo "<pre>";
var_dump($courses);
//
//
$courses = 
[
    1=> "php",
    10=> "uno",
    100=> "dos",
    1000=> "tres"
];

echo "<pre>";
var_dump(array_slice ($courses,2)); // array_slice te permite  llamar al array desde una posicion que le indiques
//
//
$courses = 
[
    "php",
    "uno",
    "dos",
    "tres"
];

echo "<pre>";
var_dump(array_chunk ($courses,1)); // array_chunk te permite organizar los datos en pedazos o es lo mismo que decir en diferentes arrays
//
//
$courses = 
[
    "php",
    "uno",
    "dos",
    "tres"
];

echo "<pre>";
var_dump(array_shift($courses)); // *array_shift* al igual que en javaScript llama al primer elemento del array y lo elimina del mismo
var_dump(array_pop($courses)); // *array_pop* hace la misma funcion que el shift a diferencia que este llama al ultimo elemento
//
//
$courses = 
[
    "php",
    "uno",
    "dos",
    "tres"
];

echo "<pre>";
var_dump(array_unshift($courses)); // *array_unshift* agrega un elemento al principio del array
var_dump(array_push($courses)); // *array_push* agrega un elemento al final del array
//
//
$courses = 
[
    "ejemplo1" => "php",
    "ejemplo2" => "uno",
    "ejemplo3" => "dos",
    "ejemplo4" => "tres"
];

echo "<pre>";
var_dump(array_flip($courses)); // sirve para remplazar la informacion de los array por la de los key
//

Los arreys se ordenan de la siguiente manera:

<?php

$juegos = ['Assasins_Creed', 'Halo', 'Cyberpunk2077'];

$juegos1 = [
     'Aventura' => 'Assasins_Creed', 
     'FPS' => 'Halo', 
     'RPG' => 'Cyberpunk2077'
];

echo '<pre>';
// echo '<h1>sort: Ordena un array por strings.</h1>';
// sort($juegos);
// var_dump($juegos);
// echo "<br>---------------------------------------------------------<br>";

// echo '<h1>rsort: Ordena un array por strings en orden inverso.</h1>';
// rsort($juegos);
// var_dump($juegos);
// echo "<br>---------------------------------------------------------<br>";

// echo '<h1>ksort: Ordena un array por clave.</h1>';
// ksort($juegos1);
// var_dump($juegos1);
// echo "<br>---------------------------------------------------------<br>";

// echo '<h1>krsort: Ordena un array por clave en orden inverso.</h1>';
// krsort($juegos1);
// var_dump($juegos1);
// echo "<br>---------------------------------------------------------<br>";

// echo '<h1>array_slice: Extrae una parte de un array.</h1>';
// var_dump(array_slice($juegos, 1));
// echo "<br>---------------------------------------------------------<br>";

// echo '<h1>array_chunk: Divide un array en fragmentos.</h1>';
// var_dump(array_chunk($juegos, 2));
// echo "<br>---------------------------------------------------------<br>";

// echo '<h1>array_shift: Quita un elemento del principio del array.</h1>';
// var_dump(array_shift($juegos));
// echo "<br>---------------------------------------------------------<br>";

// echo '<h1>array_unshift: Añadir al inicio de un array uno a más elementos.</h1>';
// // var_dump(array_unshift($juegos));
// array_unshift($juegos, 'Destiny');
// var_dump($juegos);

// echo "<br>---------------------------------------------------------<br>";

// echo '<h1>array_pop: Extrae el último elemento del final del array.</h1>';
// var_dump(array_pop($juegos));
// echo "<br>---------------------------------------------------------<br>";

echo '<h1>array_push: Inserta uno o más elementos al final de un array.</h1>';
// var_dump(array_push($juegos));
array_push($juegos, 'Ninja_GAiden');
var_dump($juegos);
echo "<br>---------------------------------------------------------<br>";

echo '<h1>array_flip: Intercambia todas las claves de un array con sus valores asociados.</h1>';
var_dump(array_flip($juegos1));
echo "<br>---------------------------------------------------------<br>";

Excelente clase, conocer las funciones nativas del código te evita reinventar la rueda, por eso siempre es bueno verificar en la documentación si ya existe una funcionalidad acorde a lo que intentas realizar, a la vez esto hace tu código mas legible

<?php

$course =['php','javascript','laravel'
];

echo "<pre>";
var_dump($course);

var_dump(array_chunk($course, 2));

echo "funcion shift";
var_dump(array_shift($course));

echo "funcion pop";
var_dump(array_pop($course));

echo "funcion unshift al inicio del arreglo";
array_unshift($course, 'apple');
var_dump($course);

echo "funcion push al final del arreglo";
array_push($course,'hola');
var_dump($course);


echo "funcion flip";
var_dump(array_flip($course));```

La forma de explicar de Italo ayuda a entender mucho los arrays

$courses3 = ['Framework' =>'Laravel',
           'Backend' =>'php', 
           'Lenguaje' =>'Python',
           'Frontend' =>'JavaScript'];

echo "</br> Sacar un objeto del array <pre>";
var_dump(array_slice($courses3, 2));

echo "</br> dividir el array <pre>";
var_dump(array_chunk($courses3,2));

echo "</br> Retirar el primer elemento del array e imprimirlo<pre>";
var_dump(array_shift($courses3));


echo "</br> Retirar el ultimo elemento del array e imprimirlo<pre>";
var_dump(array_pop($courses3));

echo "</br> Intercambiar los keys por los valores<pre>";
var_dump(array_flip($courses3));```

<?php

$frutas = array("limón", "naranja", "banana", "albaricoque");
sort($frutas);
foreach ($frutas as $clave => $valor) {
    echo "frutas[" . $clave . "] = " . $valor . "\n";
}

?>

El resultado del ejemplo sería:

frutas[0] = albaricoque
frutas[1] = banana
frutas[2] = limón
frutas[3] = naranja

Yo mis apuntes los llevo en archivos y los visualizo en sublimeText.
De todas formas les comparto los apuntes de esta clase, mediante un editor online en el que estuve curioseando.
Apuntes:
paiza.io/projects/funcionesPHPparaArrays
(Nota: no es necesario ejecutar el código)

Excelente!

RETOS

<?php 

$arreglo = [
    'uno' => 'one',
    'dos' => 'two',
    12 => 8,
    15 => 6.5
];

/**
 * array_shift() Quita el primer valor del array y lo devuelve, acortando el array 
 * un elemento y corriendo el array hacia abajo. Todas la claves del array numéricas 
 * serán modificadas para que empiece contando desde cero mientras que las claves 
 * literales no se verán afectadas.
*/

$arreglo_first = array_shift($arreglo);

echo "<pre><br>";
print_r($arreglo);

echo "<pre><br>";
var_dump($arreglo_first);

/**
 * array_unshift() añade los elementos pasados al inicio de array. Observe que la lista
 * de elementos se añade como un todo, por lo que los elementos añadidos permanecen en 
 * el mismo orden. Todas las claves numéricas del array serán modificadas empezando a 
 * contar desde cero mientras que las claves literales no serán cambiadas.
*/

array_unshift($arreglo,$arreglo_first);

echo "<pre><br>";
print_r($arreglo);


/**
 * array_pop() extrae y devuelve el último elemento del array, acortando el array 
 * con un elemento menos.
*/

$arreglo_last = array_pop($arreglo);

echo "<pre><br>";
print_r($arreglo); //imprime como queda el array después de pasar array_pop

echo "<pre><br>";
var_dump($arreglo_last);//imprime el elemento extraido

/**
 * array_push() trata array como si fuera una pila y coloca la variable que se le 
 * proporciona al final del array. El tamaño del array será incrementado por el 
 * número de variables insertados. Tiene el mismo efecto que:

<?php
$array[] = $var;
?>

*repetido por cada valor proporsionado
*/

array_push($arreglo,93,'hola',2.3);

echo "<pre><br>";
print_r($arreglo);

/**
 * array_flip() devuelve un array dado la vuelta, es decir, las claves de array 
 * se convierten en valores y los valores de array se convierten en claves.
 *
 * Observe que los valores de array tienen que ser ser claves válidas, es decir, 
 * que necesitan ser un valor de tipo integer o string. Se emitirá una advertencia 
 * si un valor tiene el tipo erróneo, por lo que el par clave/valor en cuestión no 
 * será incluido en el resultado
 * 
 * Si un valor tiene varias coincidencias, se usará la última clave como su valor, 
 * perdiéndose todas las demás.
*/

$intercambiada = array_flip($arreglo);
/**
 * Al momento de realizar el flip, uno de los valores es flotante, por lo tanto no
 * puede ser considerado como key, clave o índice. En este caso, el último valor
 * que es 2.3 se eliminará, y PHP enviará una alerta WARNING
*/

echo "<pre><br>";
print_r($intercambiada);
?>

Es importante no olvidar la documentación oficial, por que ayuda a despejar dudas sobre el uso e implementan de cada una de las funciones aquí descritas: https://www.php.net/manual/es/book.array.php

Saludos.

<?php
//Funciones PHP para Array
echo ‘<pre>’;
var_dump($listado).’<br>’;
//array_flip me cambia los key por los value y los value por los key :=)
$R=array_flip($listado);
var_dump($R);

// array_slice me borra los n iniciales que defina en la expresión

$s=array_slice($listado,2);
var_dump($s);

//array_chunk me parte el arreglo en dos dejando en un primer arreglo los primeros n que defina en la expresión

$t=array_chunk($listado,3);
var_dump($t);

//sort actua sobre la variable listado y me ordena los valores en orden alfabetico ascendente

sort($listado);
var_dump($listado);

//rsort actua sobre la variable listado y me ordena los valores en orden alfabetico pero descendente

rsort($listado);
var_dump($listado);

//ksort actua sobre la variable listado y me ordena las keys en orden alfabetico ascendente

ksort($listado);
var_dump($listado);

//krsort actua sobre la variable listado y me ordena las keys en orden

krsort($listado);
var_dump($listado);

//array_shift actua sobre la variable listado y me elimina el primer elemento del array

array_shift($listado);
var_dump($listado);

//array_pop actua sobre la variable listado y me elimina el ultimo elemento del array

array_pop($listado);
var_dump($listado);

//array_unshift nos agrega un elemento, solo el valor , no ingresa la clave

$nitem=“Link Sys”;
array_unshift($listado,$nitem);
var_dump($listado);

//array_push me agrega al final de la lista un nuvo valor; el key lo coloca automatico

$nele=“Radeon”;
array_push($listado,$nele);
var_dump($listado);

Aporte de la clase realizando los ejercicios y probando nuevos métodos 💚

La R es de reverso (inverso), no recursivo, recursivo es otra cosa, un concepto totalmente distinto que se usa mucho dentro de la programación, un profesor no debería confundir eso, que vergüenza, encima veo que el profesor defiende su error en uno de los comentarios, podría haber dicho que se equivocó, pero dice que es otra forma de decirlo. Son dos cosas completamente distintas. Una vergüenza

No me gusta usar vardump, y leyendo vi que array_chunk crea una matriz(Arreglo multidimiensional), asi que usando una etiqueta de lista ordenada de html y do foreach anidados, cree una forma, almenos para mi, más facil de verlo

$personas=['Francisco','Italo','Karla','Cecilia','Juan','Carlos'];
$n=2;
foreach (array_chunk($personas,$n) as $key => $arreglo) {
    echo '<ol>';
    foreach ($arreglo as $key => $value) {
        echo "<li>$value</li>";
    }
    echo '</ol>';
}

Solo hice un arreglo más grande y puse una variable $n para que cambiar los grupos sea más facil

Mis apuntes:

Detalles
1:50 - 2:50
La letra ‘r’ que antecede a ‘sort’, llama a la función 'rsort()'
que viene de ‘reverse order’ en array
y analogamente ocurre lo mismo usando ‘krsort()’ cuando son arrays asociativos.

https://www.php.net/manual/en/function.sort

$courses = [
    'frontend' => 'Javascript', 
    'backend' =>'PHP', 
    'framework' => 'Laravel'
  ];
  
  echo "<pre>";

    $course = array_shift($courses);
    $data = array_pop($courses);
    print_r($data);

    var_dump(array_flip($courses));
    var_dump(array_slice($courses, 1));
    var_dump(array_chunk($courses, 1));
    
    array_unshift($courses, "vuejs", "css");
    print_r($courses);
    array_push($courses, "vuejs");

Encontre la funcion Array_map me parecio muy util,
le asignas un metodo establecido o uno propio y te devuevle el resultado aplicado en el array.

function iva ($v){
return $v += $v*0.16;
}

$costos = [10, 15, 20, 55];

var_dump(array_map(“iva”, $costos));