Arrays complejos en PHP: creación e iteración eficiente

Los “arrays complejos” son llamados de igual forma “arrays asociativos”, donde prácticamente al valor le poner un nombre, eso es todo, y lo interesante de esto es que actúa de la misma forma que una lista, así como actúa de la misma forma de un objeto JSON, tiene en lista el atributo clave/valor, esta es la forma más cómoda de trabajar con objetos JSON desde PHP, y claro que existen funciones para transformar un array asociativo en objetos JSON y viceversa.

Por último, en la función array_walk fácilmente se pudo haber usado un Closure, lo menciono para que empiecen a darse una idea de cómo todo se conecta 😄

Mis apuntes

<?php

echo "<h1>Array Complejo</h1>";
echo "---------------";
echo "<br>";
#Array
//Es aquel elemento que no identificamos de manera directa.

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

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

echo "<br>";

foreach ($courses as $key => $value){
	echo "$key: $value <br>";
}

echo "<br>";

$contador = 1;
foreach ($courses as $course){
	echo "$contador.- $course <br>";
	$contador++; 
}

echo "<br>";
function upper($course){
	echo strtoupper("$course <br>");
}

array_walk($courses, 'upper');

echo "<br>";

function upper1($course, $key){
	echo strtoupper($course) . ": $key <br>";
}

array_walk($courses, 'upper1');

/*	
	//Existe un Key
	array_key_exists('frontend', $courses);
	//Existe un valor
	in_array('javascript', $courses);
	//Muestra todos los Key
	array_keys($courses);
	//Muestra todos los valores
	array_values($courses);
*/

Array complejo

Los datos de los Arrays son datos complejos por que nos permiten guardar varios datos dentro de una sola variable. Declaramos un array de la siguiente forma:

<?php

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

foreach ($courses as $key => $var) {
    echo "<h4> $key: $var <br><h4>";
}

function upper($course, $key)
{
    echo ucfirst($course) . "=> $key <br>";
}

array_walk($courses, 'upper');

• array_walk(‘key’, $array); → Nos ayuda a aplicar una función que le pasemos a cada miembro del array, es muy parecido a .maps() o .each() en JS o Ruby.
• array_key_exists(‘key’, $array); → Para saber si un key existe.
• in_array(‘valor’, $array); → Nos ayuda a buscar si existe un valor en el Array.
• array_keys($array); → Nos imprime todos los keys en pantalla.
• array_values($array); → Nos imprime todos los valores en pantalla.

muy buen uso de la función array_walk, no lo sabía.

🐱‍💻 Utilizando un array complejo para la siguiente implementación:

 <?php
$greets = [ 
   'normal' => 'Hello', 
   'contraction' => 'Hi'
];

foreach($greets as $greet){
    echo "$greet\n";
}

$result = array_key_exists('normal', $greets);

if($result == 1)
{
  echo 'Si';
}else
{
  echo 'No';
}

Había tomado cursos de PHP pero nunca los entendía, me frustraba y le agarraba miedo al lenguaje pero este profeso lo explica todo muy muy sencillo y explicito !!! gracias Patzi mas profesores como este

aporte: los corchetes funciona a partir de PHP 5.4 en versiones inferiores se debe usar array();

Mis apuntes y resultados con funciones con arrays:

<?php

// Array simple: solo valores y keys predeterminados
$courses = ['JS', 'Laravel', 'PHP', 'Vuejs'];

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

// Array complejo
$coursesKey = [
    'frontend' => 'JS',
    'framework' => 'Laravel',
    'backend' => 'PHP', 'framework2' => 'Vuejs'
];

foreach($coursesKey as $key => $value)
{
    echo "$key: $value <br>";
}


//funciones de php para arrays
function upperStringCourse($course)
{
    echo strtoupper($course). "<br>";
}

//Recorre toda la colección y llama a la función con cada elemento
array_walk($coursesKey,'upperStringCourse');

echo "array_key_exists <br>";
$existCourse = array_key_exists('framework', $coursesKey);
var_dump($existCourse);
echo "<br>";

echo "in_array <br>";
$inArrayCourse = in_array('JS', $coursesKey);
var_dump($inArrayCourse);
echo "<br>";

echo "array_values <br>";
$arrayValues = array_values($coursesKey);
var_dump($arrayValues);
echo "<br>";

echo "array_keys <br>";
$arrayKeys = array_keys($coursesKey);
var_dump($arrayKeys);

array_walk me voló la cabeza

<code>
$courses = [
    'frontend' => 'java', 
    'framework' => 'laravel', 
    'backend' => 'php' 
];

//devuelven 1 ó 0
echo array_key_exists('frontend', $courses);    
echo '<br>';
echo in_array('java', $courses);            

echo '<br>';

//imprime llaves y valores
print_r(array_keys($courses));
echo '<br>';
print_r(array_values($courses));

Para insertar valores a un array complejo/asociativo he utilizado el siguiente código:

 $numeros = [];

for ($i = 1; $i < 10; $i++) {
    $numeros[$i] = $i + 1;
}

//output

/*
array(9) {
    [1]=>
    int(2)
    [2]=>
    int(3)
    [3]=>
    int(4)
    [4]=>
    int(5)
    [5]=>
    int(6)
    [6]=>
    int(7)
    [7]=>
    int(8)
    [8]=>
    int(9)
    [9]=>
    int(10)
}
*/

<code> 
<?php

namespace App;

use Exception;

class LenguajesDeProgramacion
{
    private $lenguaje;
    private $extension;
    private $lenguajeyExtension = [];

    public function arrayLenguajes($lenguaje, $extension)
    {
        $this->lenguaje = $lenguaje;
        $this->extension = $extension;
        $this->lenguajeyExtension[$lenguaje] = $extension;
        return $this->lenguajeyExtension;
    }

    public function upperCase($lenguaje, $extension)
    {
        return strtoupper($lenguaje) . ": $extension <br>";
    }

    // array_walk
    public function convertirValoresAMayusculas()
    {
        $lenguajesMayusculas = $this->lenguajeyExtension;

        array_walk($lenguajesMayusculas, function (&$valor, $lenguaje) {
            $valor = $this->upperCase($lenguaje, $valor);
        });

        return $lenguajesMayusculas;
    }

    // array_key_exists
    public function buscarLenguaje($lenguaje)
    {
        if (array_key_exists($lenguaje, $this->lenguajeyExtension)) {
            return $this->lenguajeyExtension[$lenguaje];
        } else {
            throw new Exception('Lenguaje no encontrado');
        }
    }

    // in_array
    public function buscarExtension($extension)
    {
        if (in_array($extension, $this->lenguajeyExtension)) {
            return array_search($extension, $this->lenguajeyExtension);
        } else {
            throw new Exception('Extensión no encontrada');
        }
    }

    // array_values
    public function obtenerExtensiones()
    {
        return array_values($this->lenguajeyExtension);
    }

    public function getLenguajeyExtension()
    {
        return $this->lenguajeyExtension;
    }

    public function getLenguaje()
    {
        return $this->lenguaje;
    }

    public function getExtension()
    {
        return $this->extension;
    }

    public function setLenguaje($lenguaje)
    {
        $this->lenguaje = $lenguaje;
        return $this;
    }

    public function setExtension($extension)
    {
        $this->extension = $extension;
        return $this;
    }
}

<?php

use PHPUnit\Framework\TestCase;
use App\LenguajesDeProgramacion;

class LenguajesDeProgramacionTest extends TestCase
{
    public function test_arrayLenguajes()
    {
        $lenguajes = new LenguajesDeProgramacion();

        // Prueba la función arrayLenguajes
        $result = $lenguajes->arrayLenguajes('PHP', 'php');
        $this->assertEquals(['PHP' => 'php'], $result);

        // Agrega más lenguajes
        $result = $lenguajes->arrayLenguajes('JavaScript', 'js');
        $this->assertEquals(['PHP' => 'php', 'JavaScript' => 'js'], $result);

        $result = $lenguajes->arrayLenguajes('Python', 'py');
        $this->assertEquals(['PHP' => 'php', 'JavaScript' => 'js', 'Python' => 'py'], $result);

        $result = $lenguajes->arrayLenguajes('Java', 'java');
        $this->assertEquals(['PHP' => 'php', 'JavaScript' => 'js', 'Python' => 'py', 'Java' => 'java'], $result);
    }

    public function test_upperCase()
    {
        $lenguajes = new LenguajesDeProgramacion();

        // Prueba la función upperCase
        $result = $lenguajes->upperCase('PHP', 'php');
        $this->assertEquals('PHP: php <br>', $result);

        // Prueba con otro lenguaje
        $result = $lenguajes->upperCase('JavaScript', 'js');
        $this->assertEquals('JAVASCRIPT: js <br>', $result);
    }

    public function test_getters_and_setters()
    {
        $lenguajes = new LenguajesDeProgramacion();

        // Prueba los getters y setters
        $lenguajes->setLenguaje('PHP');
        $lenguajes->setExtension('php');

        $this->assertEquals('PHP', $lenguajes->getLenguaje());
        $this->assertEquals('php', $lenguajes->getExtension());
    }

    public function test_convertirValoresAMayusculas()
    {
        $lenguajes = new LenguajesDeProgramacion();
        $lenguajes->arrayLenguajes('PHP', 'php');
        $lenguajes->arrayLenguajes('JavaScript', 'js');

        $lenguajesMayusculas = $lenguajes->convertirValoresAMayusculas();

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

        $this->assertEquals([
            'PHP' => 'PHP: php <br>',
            'JavaScript' => 'JAVASCRIPT: js <br>'
        ], $lenguajesMayusculas);
    }

    public function test_buscarLenguaje()
    {
        $lenguajes = new LenguajesDeProgramacion();
        $lenguajes->arrayLenguajes('PHP', 'php');
        $lenguajes->arrayLenguajes('JavaScript', 'js');

        $lenguaje = $lenguajes->buscarLenguaje('PHP');

        $this->assertEquals('php', $lenguaje);
    }

    public function test_buscarExtension()
    {
        $lenguajes = new LenguajesDeProgramacion();
        $lenguajes->arrayLenguajes('PHP', 'php');
        $lenguajes->arrayLenguajes('JavaScript', 'js');

        $extension = $lenguajes->buscarExtension('js');

        $this->assertEquals('JavaScript', $extension);
    }

    public function test_obtenerExtensiones()
    {
        $lenguajes = new LenguajesDeProgramacion();
        $lenguajes->arrayLenguajes('PHP', 'php');
        $lenguajes->arrayLenguajes('JavaScript', 'js');

        $extensiones = $lenguajes->obtenerExtensiones();

        $this->assertEquals(['php', 'js'], $extensiones);
    }
}

más elementos que me permiten manipular el tema de los arrays:

• array_key_exists(); Podemos ver si un key existe.
• in_array(); Podemos buscar a nivel de valores,
• array_keys(); para imprimir todos los keys en pantalla.
• array_values(); Mostrar los valores de este array.

• Los array complejos son llamados de igual manera array asociativos, donde prácticamente al valor le poner un nombre; eso es todo. Lo más interesante de esto es que actúa de la misma forma que una lista.

Ejercicio 4 array complejo

Resumen de la clase

<?php
$courses =[
    'PHP'=>'PHP',
    'JavaScript'=>'JavaScript',
    'Python'=>'Python',
    'C#'=>'C#',
    'C++'=>'C++'];


foreach($courses as $course){
    echo "$course <br>";
}
echo '<br>';

function upper($course,$key){
    echo strtoupper($course) .": $key <br>";
}

array_walk($courses,'upper');


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

echo (bool) array_key_exists('PHP',$courses);
echo in_array('PHP',$courses);
array_keys($courses);
array_values($courses);

Buenas! Comparto algunas anotaciones y ejemplos de los métodos del final de la clase, saludos.

<?php 

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

//Podemos ver si existe un key
var_dump(array_key_exists('frontend', $courses));
echo "<br>";

//Si existe un elemento en el array
var_dump (in_array('laravel', $courses));
echo "<br>";

//Nos devuelve un array con las keys con su correspondiente índice 
var_dump(array_keys($courses));
echo "<br>";


//Nos devuelve un array con los elementos de un array 
var_dump(array_values($courses));

Resultado

Listos para ser probados

var_dump((bool) array_key_exists('objetos', $tecs)); //Verificar si la Key existe en el Array
echo '<br>';
var_dump((bool) in_array('objetos', $tecs)); //Verificar si existe el Valor en el Array
echo '<br>';
echo '<pre>';
var_dump(array_keys($tecs)); //Imprimir todos los keys en pantalla
echo '</pre>';
echo '<br>';
echo '<pre>';
var_dump(array_values($tecs)); //Imprimir todos los Valores en pantalla
echo '</pre>';

/*
* array_key_exists('Frontend', $courses); // Comprueba que exista el key en el array
* in_array('Javascript', $courses); // Comprueba si un valor existe en el array
* array_keys($courses); // Devuelve los keys del array
* array_values($courses); // Devuelve los values del array
* array_search('Laravel'); // Busca un valor en el array y devuelve su key
*/

No conocía la función array_walk.
Pero pinta muy interesante!

12. Array Complejo

Comparto el código de la clase:

<?php

/**
 * Si usamos foreach ($courses as $key => $value),
 * recorremos todas los valores en base a sus keys
 * siendo $key una palabra reservada que se refiere a la "key"
 * de cada elemento en el array
 */

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

// foreach ($courses as $key => $value)
// foreach ($courses as $course)
// {
//     echo "$key: $value <br>";
//     echo "$course <br>";
// }

/**
 * array_walk, recorre todos los elementos, ejecutando la
 * función que está como segundo parámetro, y que necesariamente
 * debe estar su nombre entre comillas simples
 */
function upper($course, $key)
{
    echo strtoupper($course) . ": $key <br>";
}
array_walk($courses, 'upper');

/**
 * Esto busca si existe una key en un array:
 * array_key_exists('frontend', $courses);
 * Esto busca si existe un elemento dentro de un array
 * in_array('javascript', $courses);
 * Esto imprime todos los keys en pantalla:
 * array_keys($courses);
 * Esto imprime solo los valores de un array:
 * array_values($courses);
 */

<?php

    // Create an associative array
    echo "<h3>Create an associative array</h3>";

    $person = [
        'name' => 'Brad',
        'surname' => 'Traversy',
        'age' => 30,
        'hobbies' => ['Tennis', 'Video Games'],
    ];



    // Get element by key
    echo $person['name'] . '<br>';
    var_dump($person);

    $person['channel'] = 'TraversyMedia';

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



    //Null coalescing assignment operator. Since PHP 7.4
    if (!isset($person['address'])) {
        $person['address'] = 'Unknown';
    }
    $person['address'] ??= 'Unknown';

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

    echo "<li>" . $person['address'] . '</li><br>';



    // Check if array has specific key
    echo '<pre>';
    var_dump(isset($person['age']));  // Change age into "location"
    echo '</pre>';



    // Print the keys of the array
    echo '<pre>';
    var_dump(array_keys($person));      # array_keys — Devuelve todas las claves de un array o un subconjunto de claves de un array
    echo '</pre>';

    /** otras funciones similares a array_keys:
     * 
     * array_values() - Devuelve todos los valores de un array
     * array_combine() - Crea un nuevo array, usando una matriz para las claves y otra para sus valores
     * array_key_exists() - Verifica si el índice o clave dada existe en el array
     * array_search() - Busca un valor determinado en un array y devuelve la primera clave correspondiente en caso de éxito
     */

    // Print the values of the array
    echo '<pre>';
    var_dump(array_values($person));    # array_values() - Devuelve todos los valores de un array
    echo '</pre>';



    // Sorting associative arrays by values, by keys
    ksort($person); // ksort, krsort, asort, arsort

    /** funciones de ordenamiento de arrays:
     * ksort — Ordena un array por clave
     * krsort — Ordena un array por clave en orden inverso
     * asort() - Ordena un array y mantiene la asociación de índices
     * arsort() - Ordena un array en orden inverso y mantiene la asociación de índices
     */

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



    // Two dimensional arrays:
    echo "<h3>Two dimensional arrays</h3>";

    $todos = [
        ['title' => 'Todo title 1', 'completed' => true],
        ['title' => 'Todo title 2', 'completed' => false],
    ];

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

Mi practica de algunas funciones de arrays en PHP,
impresionante lo array_wal( )

$users = [
    'name' => 'Christian',
    'lastName' => 'Vargas',
    'email' => '[email protected]',
    'age' => 27
];

function lower($user, $value)
{
    $valueNew = strtoupper($value);
    echo "$valueNew: $user  <br/>";

}

echo '<pre>';
array_walk($users, 'lower');
echo '<hr/>';

var_dump(array_key_exists('lastName', $users));
echo '<hr/>';

var_dump(in_array('30', $users));
var_dump(in_array('Christian', $users));
echo '<hr/>';

var_dump(array_keys($users));
echo '<hr/>';

var_dump(array_values($users));

Mi ejemplo uwu

<code> 
/*--------------------------ARRAYS---------------------------- */

$cursitos=[
    'Iwa'=> 'PHP',
    'Kim'=> 'Diseño',
];

foreach($cursitos as $key=>$value){
    echo "\n$key: $value";
}

foreach($cursitos as $cursos){
    echo "\n$cursos";
}


$alumnos=[
    'Iwa'=>'Wordpress',
    'Kim'=> 'Patrones de diseño',

];

foreach($alumnos as $alumno => $materias){
    echo "\nEl alumno $alumno se encuentra estudiando:$materias";
}
 

function materiaUpper($alumno){
    echo "\n".mb_strtoupper($alumno)."\n";
}

array_walk($alumnos, 'materiaUpper');

var_dump (array_key_exists('Iwa',$alumnos));
var_dump (in_array('Patrones de diseño',$alumnos));
var_dump (array_keys($alumnos)); 
var_dump (array_values($alumnos));

OUTPUT
Iwa: PHP
Kim: Diseño

PHP
Diseño

El alumno Iwa se encuentra estudiando:Wordpress
El alumno Kim se encuentra estudiando:Patrones de diseño

WORDPRESS

PATRONES DE DISEÑO

bool(true)
bool(true)

array(2) {
[0]=>
string(3) “Iwa”
[1]=>
string(3) “Kim”
}

array(2) {
[0]=>
string(9) “Wordpress”
[1]=>
string(19) “Patrones de diseño”
}

Les comparto lo aprendido

<?php

$courses = [
    'frontend'  => 'javascript',
    'backend'   => 'PHP',
    'para_android'   => 'Java',
    'multiproposito'    => 'Python'
];

Después de esto me di a la tarea de buscar en la documentación oficial de php que hacía cada función.

//verifica si existe un key dentro de un array
echo array_key_exists('para_android', $courses);

echo '<br>';

//verifica si existe un valor "x" dentro de un array
echo in_array('PHP', $courses, true);

echo '<br>';

//devuelve todas las keys del array
print_r(array_keys($courses));

echo '<br>';

//devuelve todos los valores del array
print_r(array_values($courses));

Apuntes de esta clase, estan geniales las ultimas funciones

/**
 * Arrays complejos
 * 
 */

$cursosC = [
    'frontend'=> 'javascript',
    'framework'=> 'Laravel',
    'backend'=> 'php'
];


/**
 * Array walk, es una funcion predeterminada de php que nos ayuda a recorrer un array
 * y ademas de eso podemos asignarle  una funcion, para que en cada recorrido, cumpla algo
 * 
 */

foreach ($cursosC as $key => $value) {
    echo "$key: $value <br>";
}


function upper($curso)
{
    echo strtoupper($curso) . "<br>";
}
array_walk($cursosC, 'upper');

# Funciones interesantes con arrays

# array_key_exists(str key, var array) = esta funcion busca en nuestro array una llave y nos dice si existe

var_dump(array_key_exists('frontend', $cursosC));

# in_array(srt valor, var array) = esta funcion busca en nuestro array un valor y nos dice si existe

var_dump(in_array('javascript', $cursosC));

# array_keys(var array) = esta funcion muestra todas las llaves de un array

var_dump(array_keys($cursosC));

# array_values(var array) = esta funcion muestra todos los valores de un array

var_dump(array_values($cursosC));```

Mis prácticas:

<?php 
$arreglo = [
    'primero' => 'alfa',
    'segundo' => 'beta',
    6 => 16,
];

//array_key_exists: devuelve true si el indice buscado existe
if (array_key_exists('primero',$arreglo)) {
    echo "<pre>el indice 'primero' existe <br />";
} else {
    echo "<pre>el indice 'primero' NO existe <br />";
}

//in_array: devuekve true si se encontró la aguja en el pajar
if(in_array('alfa',$arreglo)) {
    echo "<pre>existe el elemento 'alfa' <br />";
} else {
    echo "<pre>NO existe el elemento 'alfa' <br />";
}

if (in_array('16',$arreglo, true)) {
    echo "<pre>existe el elemento 16";
} else {
    echo "<pre>NO existe el elemento 16 <br />";
}

//array_keys: devuelve un array con los indices
echo "<pre>";
print_r(array_keys($arreglo));

//array_values: devuelve todos los valores del array
echo "<pre>";
print_r(array_values($arreglo));
?>

Resultado:

se puede ser explicito al momento de declarar un array con el constructor (aunque no es necesario)

$courses = array(
	'frontend' => 'js'
);

Arreglo Complejo o Asociativo es aquel al que se le declara de manera explicita la dupla clave=>valor

Usando las ultimas funciones que dejo el profesor:

$courses = [
    'frontend' => 'JavaScript',
    'framework' => 'Laravel',
    'backend' => 'php'
];

array_walk($courses, 'upper');
if (array_key_exists('frontend', $courses)) {
    echo ' Si existe frontend en el arreglo';
}

if (in_array('JavaScript', $courses)) {
    echo 'Si existe JavaScript en el arreglo';
}

var_dump(array_keys($courses));
var_dump(array_values($courses));```

poco a poco me empieza a gustar mas PHP.

Excelente

La verdad que se ve muy bien la función array_walk, pero…es más optima que un foreach con una llamada interna a esa función??

<?php
echo ‘<!DOCTYPE html>
<html lang=“es”>
<head>
<meta charset=“utf-8” />
<title>Funciones de Array</title>
</head>
<body>
’;
$listado=[
1=>‘Hewler Packard’,
2=>‘Acer’,
3=>‘Lenovo’,
4=>‘Alienwere’,
5=>‘Samgsung’
];

/foreach($listado as $key=>$valor){
echo “$key:$valor”."</br>";
}/

/*
function iniciales($lis,$k){
echo substr($lis,0,3).’ : '.substr($k,0,1)."</br>";
}
//me recibe un Array y una función y da pasos sobre el array
array_walk($listado,‘iniciales’);
*/

// Buscando la clave array_key_exist
/* $x=5;
if(array_key_exists($x,$listado)==’’){
echo “No esta en la Lista”;
}elseif(array_key_exists($x,$listado)==1){
echo “Existe”;
}
*/
//Existe un valor en el Array in_array, es un buscador, reporta 1 si lo encuentra

//echo in_array(‘Samgsung’,$listado);

//Guarda en un array todos los Keyses de un Array Complejo o asociativo

/$y=array_keys($listado);
var_dump($y);/

//Guarda en un array todos los values de un array complejo
/*
$n=array_values($listado);
var_dump($n);
*/

Apuntes y ejercicio de la clase 💚

Esta pagina me fue útil para complementar la clase 😄
https://diego.com.es/arrays-asociativos-en-php

https://diego.com.es/arrays-asociativos-en-php

$course = [
    'FrontEnd'=>'JavaScript',
    'Framewrok'=>'Laravel',
    'BackEnd'=>'PHP'
];

echo '<pre>';
var_dump($course);
echo'<br>';

foreach($course as $key => $value){
    echo "$key: $value <br>";
}
echo '<br>';

function upper($course, $key)
{
    echo strtoupper($course). ": $key <br>";
}

array_walk($course, 'upper');

echo '<br>';

print_r (array_values($course));

echo '<br>';

print_r(array_keys($course));

Se puede hacer un proyecto web grade solo con PHP? O es mejor usar algun framework?

Para los que como a mi, le quedaron dudas sobre el funcionamiento de array_walk

<?php

$empleados = ['operario'=>'kevin',
			  'team leader'=>'karla',
			  'supervisor'=>'Juan',
			  'gerente'=>'veronica'];


function mostrar($empleados){

	echo ucfirst($empleados)."<br>";
}

array_walk($empleados, "mostrar"); //recorre el array_walk


//evalua si existe un key dentro del array

if(array_key_exists('gerente', $empleados)){
	echo "El key ". strtoupper('gerente')."si existe";
}

//evalua si existe un value dentro del array

if(in_array('Juan',$empleados)){	
	echo "El empleado Juan si existe";
}

//imprime todos los keys
print_r(array_keys($empleados));

//imprime todos los values del in_array

print_r(array_values($empleados));```

Veo los arrays complejos como un hash o diccionario que hay en otros lenguajes de programación, ¿mi conclusión es correcta? Corríjanme si estoy mal por favor.

array_walk — Aplicar una función proporcionada por el usuario a cada miembro de un array

Hice un ejercicio extra de array walk basado en el de un compañero que lo hizo con shows de television

 $alumnos=[
     [
         'pronombre-s'=>'El',
         'nombre'=>'Francisco Valle',
         'nota'=>9
     ],
     [
         'pronombre-s'=>'La',
         'nombre'=>'Karla Ramos',
         'nota'=>7
     ],
     [
         'pronombre-s'=>'El',
         'nombre'=>'Linus Torvald',
         'nota'=>4
     ]
 ];

 function Aprobacion($alumnos){
     //Se usan corchetes por tener una capa de complejidad mayor
     if ($alumnos['nota']>=6) {
         echo "<p>{$alumnos['pronombre-s']} alumn@ {$alumnos['nombre']} ha aprobado</p>";
     } else {
        echo "<p>{$alumnos['pronombre-s']} alumn@ {$alumnos['nombre']} ha reprobado</p>";
     }
 }

 array_walk($alumnos,'Aprobacion');

 /**
  * OUTPUT:
  * El alumn@ Francisco Valle ha aprobado
  * La alumn@ Karla Ramos ha aprobado
  * El alumn@ Linus Torvald ha reprobado
  */```

Para las funciones de array complejos hice lo siguiente

//Existe cierta llave?
 if (array_key_exists('frontend', $courses)) {
     echo '<p>La llave existe</p>';
 } else {
    echo '<p>La llave no existe</p>';
 }

 //Existe cierto valor?
 if (in_array('javascript', $courses)) {
    echo '<p>El valor existe</p>';
} else {
   echo '<p>El valor no existe</p>';
}

//Que llaves hay?
echo '<ul>';
foreach (array_keys($courses) as $key => $curso) {
    echo "<li>$curso</li>";
}
echo '</ul>';

//Que valores hay?
echo '<ul>';
foreach (array_values($courses) as $key => $curso) {
    echo "<li>$curso</li>";
}
echo '</ul>';

<?php 
    $courses =[
        'fronted'=> 'javascript',
        'framework' =>  'laravel',
        'backend '=> 'php',
        ];


function upper($course, $key){
    echo strtoupper($course). ": $key<br>";
}

array_walk($courses, 'upper');

$a= array_key_exists('fronted', $courses);
echo $a. "Si existe fronted";

$b=in_array('javascript', $courses);
echo "<pre> $b";
$c= array_keys($courses);
echo "<pre>";
var_dump($c);

$d=array_values($courses);
var_dump($d);```

Creo que es importante conocer que existe una función reservada de PHP la cual nos permite construir un array asociativo a través de un objeto, esa es stdClass. PAra usar esta clase podemos instaciarla como si fuera un objecto y posterior a ello llamar ese objeto y luego asignarle la llave que queremos y después el valor.

Ejemplo

// Instaciamos la clas stdClass()
<?php
$asignaturas = new stdClass();

// Creamos las llaves para el objeto, sabiendo o teniendo en cuenta que lo estamos visualizando como un array.
$asignaturas->matematicas = “A”;
$asignaturas->historia = “F”;`

var_dump($asignaturas);
?>

Como ven, llamamos la variable $asignaturas y “llamamos” a matematicas e historia cómo si fueran parte de asignaturas, pero en realidad no lo son, lo que estamos haciendo es creando las llaves de un objeto que posteriormente veremos como un array, array asociativo o JSON con otras funciones de conversión. Al nombrar estas llaves, podemos pasarle un valor que este caso son las notas.

También conocidos como array asociativo

Un apunte que enlaza con las funciones anónimas es que en este caso de array_walk podríamos hacer lo siguiente:

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

array_walk($cursos, function($curso){
    echo strtoupper($curso) . "<br>";
});

Esto funcionaria igual pero haciendo uso de una función anónima como parámetro, se suele usar cuando la función solo se va a usar en estas iteraciones.

<?php
$frutas = array("d" => "limón", "a" => "naranja", "b" => "banana", "c" => "manzana");

function test_alter(&$elemento1, $clave, $prefijo)
{
    $elemento1 = "$prefijo: $elemento1";
}

function test_print($elemento2, $clave)
{
    echo "$clave. $elemento2<br />\n";
}

echo "Antes ...:\n";
array_walk($frutas, 'test_print');

array_walk($frutas, 'test_alter', 'fruta');
echo "... y después:\n";

array_walk($frutas, 'test_print');
?>

Imprime:
Antes …:
d. limón
a. naranja
b. banana
c. manzana
… y después:
d. fruta: limón
a. fruta: naranja
b. fruta: banana
c. fruta: manzana

en un tiempo he usado las otras pero para mi es nuevo esta función: array_walk y es bastante útil para reducir código