No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Unión

15/16
Recursos

Aportes 23

Preguntas 2

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

La función array_merge_recursive es super útil cuando tenemos arrays con datos desordenados y queremos ordenarlos, pues como se muestra en la clase, junta ambos arrays y los agrupa, excelente curso, creo que se enseñaron muchas cosas interesantes, incluso aprendí algunas nuevas 😄

Mis Apuntes

<?php

echo "<h1>Unión</h1>";
echo "---------------";
echo "<br>";

$frontent = [
	'frontend' => 'javascript'
];

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

echo "<pre>";
var_dump($frontent + $backend);

#array_merge()
//Combina dos o más arrays
$frontent1 = ['javascript'];
$backend1 = ['php', 'laravel'];

echo "<pre>";
var_dump(array_merge($frontent1, $backend1));

echo "<br>";
//Ejemplo con los mismo key
#array_merge_recursive
//Une dos o más arrays recursivamente
$frontent3 = [
	'a' => 'javascript'
];

$backend3 = [
	'a' => 'php', 
	'b' => 'laravel'
];

echo "<pre>";
var_dump(array_merge_recursive($frontent3, $backend3));
//Esto crea un array "a" donde mete unos elementos y otro "b" que mete los demás
//resultado
/* 
array(2) {
  ["a"]=>
  array(2) {
    [0]=>
    string(10) "javascript"
    [1]=>
    string(3) "php"
  }
  ["b"]=>
  string(7) "laravel"
}
*/

echo "<br>";
//Ejemplo con los mismo key
#array_combine
//Crea un nuevo array, usando una matriz para las claves y otra para sus valores
$courses = ['javascript', 'php', 'laravel'];
$categories = ['frontend', 'backend', 'framework'];

var_dump(array_combine($categories, $courses));

Que gran explicación el curso debería llamarse PHP for Dummies (sin ofender). Extremadamente sencillo aprender de esta forma. Gracias Maestro

Unión


Podemos unir diferentes Arrays mediante la siguientes formas:

<?php

$frontend = [
    'html',
    'javascript',
    'react.js'
];

$backend = [
    'php',
    'laravel'    
];

$frontend2 = [
    'structure' => 'html',
    'frontend' => 'javascript',
    'framework' => 'react.js'
];

$backend2 = [
    'backend' => 'php',
    'framework bk' => 'laravel'    
];
// Podemos unir dos arryas así, pero terminaría borrando algunos valores. Sí
// queremos evitarlo debemos poner keys
var_dump($frontend + $backend);
var_dump($frontend2 + $backend2);

// Podemos usar una función también, pero solo con aquellos que tengan keys númericos
var_dump(array_merge($frontend, $backend));

// Si nuestros keys son letras debemos usar la siguiente función
var_dump(array_merge_recursive($frontend2, $backend2));

// Y si queremos combinar dos arrays,así creamos arrays complejos y lo hacemos con la función array_combine
$cursos = ['JS', 'php', 'laravel'];
$categorias = ['front', 'back', 'framework'];

var_dump(array_combine($cursos, $categorias));

Existe una función llamada print_r() que permite dar una visualización “atractiva” a los arreglos, les muestro un ejemplo:

De todos los métodos disponibles, me agrado bastante el método array_combine, ya que considero que puede ser muy útil para implementarlo en el desarrollo de cualquier software:

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

echo "<pre>";
print_r(array_combine($categories, $courses));

👾 La unión en PHP nos permiten unir elementos de selecciones.

<?php
$greets = ['Hello', 'Hi'];
$presentations = ['Good morning', 'Good afternoon', 'Good evening'];
 var_dump($presentations + $greets);

Me encanto poder expandir un poco más el repertorio de las funciones con php que conocía, ya que muchas veces en la práctica o en el trabajo olvidamos lo básico y andamos reinventando la rueda. Con esto daré uno o dos vistazos a la documentación y a mis apuntes antes de tocar código. Gracias profesor.

Aporte de la clase 💚

notas:

array_combine($array1, $array2): si queremos combinar dos arrays** creando un array complejo** quedando el $array1 como keys y el $array2 como values.

tambien existe esta forma de unir arreglos


$array1 = [1,2,3];

$array2 = [2,3,4];

//convertir 2 arreglos en uno solo

$array3 = [...$array1, ...$array2];

print_r($array3);

// otra forma

$array4 = array_merge($array1, $array2);

print_r($array4);


?>

15. Unión

Cómo unir diferentes arrays, le comparto el código de la clase:

<?php

/**
 * array_merge($array1, $array2);
 * Une dos arrays, pero si las keys de los elementos
 * son strings iguales, pues prevalece el elemento más reciente
 * Para evitar esto se debe usar una función especial
 * array_merge_recursive($array1, $array2);
 * Pero crear un subarray que tiene todos los elementos que
 * comparten una misma key (en string)
 * array_combine($categories, $courses);
 * Lo que hace es combinar keys y valores en un solo
 * array de keys y valores, siendo el primer parámetro las keys
 * y el segundo los valores
 */

$courses = ['javascript', 'php', 'laravel'];
$categories = ['front', 'back', 'framework'];

echo "<pre>";
var_dump(array_combine($categories, $courses));
//var_dump(array_merge_recursive($frontend, $backend));
<?php

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

var_dump(array_diff($wishes, $course));     # array_diff — Calcula la diferencia entre arrays

$arrayA = [1, 2, 3, 4, 5];
$arrayB = [1, 6, 3, 7, 5];

var_dump(array_diff($arrayA, $arrayB));
var_dump(array_diff($arrayB, $arrayA));


// array_diff_assoc — Calcula la diferencia entre arrays con un chequeo adicional de índices
$arrayA = array("a" => "JavaScript", "b" => "PHP", "c" => "Golang", "d" => "Ruby");
$arrayB = array("a" => "JavaScript", "d" => "Haskell", "Assembler");
var_dump(array_diff_assoc($arrayA, $arrayB));       //output: ['PHP', 'Golang', 'Ruby']
var_dump(array_diff_assoc($arrayB, $arrayA));       //output: ['Haskel', 'Assembler']



// Clase 15
$front = array('frontend' => 'javascript');
$backend = array('backend' => 'php', 'framework' => 'laravel');

echo "<pre>";
var_dump($front + $backend);    // uniomn de 2 arrays por concatenación


$front = array('javascript');
$back = array('php', 'laravel');

echo "<pre>";
var_dump(array_merge($front, $backend));    // array_merge — Combina dos o más arrays


$front = array('a' => 'javascript');
$backend = array('a' => 'php', 'b' => 'laravel');

echo "<pre>";
var_dump(array_merge_recursive($front, $backend));    // array_merge_recursive — Une dos o más arrays recursivamente


$couorses = array('javascript', 'php', 'laravel');
$categories = array('front', 'back', 'framework');

echo "<pre>";
var_dump(array_combine($couorses, $categories));    # array_combine — Crea un nuevo array, usando una matriz para las claves y otra para sus valores

Excelente docente!.

Esto me recuerda a los hash table de js.
Recomiendo ver el curso de Estrucutra de datos para entender mas sobre estos temas.

$frontent = [
	'frontend' => 'javascript'
];

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

echo "<pre>";
var_dump($frontent + $backend);

#array_merge()
//Combina dos o más arrays
$frontent1 = ['javascript'];
$backend1 = ['php', 'laravel'];

echo "<pre>";
var_dump(array_merge($frontent1, $backend1));```

Excelente curso.

Excelente

  1. array_merge() une dos arrays pero puede sustituir elementos que compartan el mismo key.

  2. array_merge_recursive() une dos arrays agrupando aquellos elementos que compartan un mismo key.

  3. array_combine() va a fusionar arrays donde el primer parámetro será un array que terminará siendo keys y el segundo los values

<?php

$courses = array(
    'frontend'  => array('javascript', 'react'),
    'backend'   => 'php',
    'startups'  => 'liderazgo'
);

$wishes = array(
    'backend'       => 'php',
    'frameworks'    => array(
        'laravel',
        'vuejs'
    ),
    'frontend'      => 'javascript vanilla',
    'css'           => 'tailwind'
);

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

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

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

$arrayA = ['hola', 'adios'];
$arrayB = ['saludo', 'despedida'];

echo '<pre>';
var_dump(array_combine($arrayB, $arrayA));
echo '</pre>';

//array_combine: Los tamaños de los array simples deben ser iguales para tomar el primer array como key y el segundo como values:

//var_dump(array_combine($listaA,$listaB));

$listaA=[
“Samgsung”,
“Xiaomi”,
“Lenovo”,
“Huawei”,
“Apple”,
“LG”,
“HTC”,
“Nokia”
];

$listaB=[
“AOC”,
“Asus”,
“Avvio”,
“Azumi”,
“Apple”,
“Amigoo”,
“LG”,
“Aiek”,
“HTC”,
“Axgio”,
“Nokia”
];

/var_dump($listaB+$listaA);
Resultado ListaB+ListaA (Se logran ver solo los elementos de ListaB por ser el Array mas largo).
Si la suma fuera invertida osea var_dump($listaA+$listaB)
se podria ver que se ven todos los elementos de listaA y cuando se termina,empieza lo que queda de listaB
/
/

array(11) {
[0]=>
string(3) “AOC”
[1]=>
string(4) “Asus”
[2]=>
string(5) “Avvio”
[3]=>
string(5) “Azumi”
[4]=>
string(5) “Apple”
[5]=>
string(6) “Amigoo”
[6]=>
string(2) “LG”
[7]=>
string(4) “Aiek”
[8]=>
string(3) “HTC”
[9]=>
string(5) “Axgio”
[10]=>
string(5) “Nokia”
}
/

//llave con el elemento que tiene es llave
/*
arreglo llave[1,2,3];
aareglo elemento[casita, edificio, negocio]

*/
array_combine($llave, $elmento);