Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Comparación

14/16
Recursos

Aportes 33

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Mis apuntes

<?php

echo "<h1>Comparación</h1>";
echo "---------------";
echo "<br>";
$courses = ['php', 'javascript'];
$wishes = ['php', 'javascript', 'laravel', 'vuejs'];

#array_diff();
//Calcula la diferencia entre arrays
echo "<pre>";
var_dump(array_diff($wishes, $courses));
//Por ejemplo, tengo dos cursos(PHP y JS) pero quisiera saber que otros cursos le gustaría a mis estudiantes
//Con esto comparo los array y descarto los cursos que yo ya tengo.

echo "<br>";
$arrayA = [1, 2, 3, 4, 5];
$arrayB = [3, 4, 5, 6, 7];

var_dump(array_diff($arrayA, $arrayB));
//Evalua depende al orden que coloquemos
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']

Lo bueno es que, al ser funciones pre implementadas del lenguaje, son más eficientes, de igual manera no estaría mal ponerse como reto desarrollar el código para esas funciones, a modo de práctica 😄

👾 La comparación en PHP nos permiten crear selecciones de manera dinámica.

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

Comparación


Con la función array_diff() nos muestra las diferencias entre dos Arrays, los valores que son diferentes son los que va a imprimir. Es importante estar pendiente que orden la pones.

<?php

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

$wishes = [
    'php',
    'laravel',
    'javascript',
    'react.js'
];

var_dump(array_diff($wishes,$courses));

Si necesitamos hacerlo con los arrays complejos tenemos la función array_diff_assoc().

Definitivamente, este es un corso de 1 o 2 horas, pero es de aquellos que uno no puede poner a 1,5x porque son de mucho contenido de asimilar, así que en ultimas y con las prácticas se vuelve mas largo que uno de 3 o 4 horas jeje bueno al menos así me pasa a mi. Excelente docente!

PHP tiene muchas funciones para trabajar con arreglos, les recomiendo leerlas todas en el manual, les comparto el link:
https://www.php.net/manual/es/ref.array.php

Con el array_diff_asoc he comprobado que con tal que cualquiera de las dos partes (El valor y la clave) sean distintas, es suficiente para marcar todo el conjunto como distinto

echo '<h1>Diferencia entre arrays y sus claves</h1>';

$colores1=[
    'a'=>'amarillo',
    'v'=>'verde',
    'az'=>'azul',
    'r'=>'rojo'
];

$colores2=[
    'a'=>'anaranjado',
    'v'=>'verde',
    'b'=>'blanco',
    'o'=>'rojo',
    'n'=>'negro'
];

echo '<ul>';
foreach (array_diff_assoc($colores2,$colores1) as $key => $value) {
    echo "<li>$value</li>";
}
echo '</ul>';

Amarillo y anaranjado comparten llave pero no valor y rojo tiene distintas llaves en ambos, sin embargo al ejecutar sale:

  • anaranjado
  • blanco
  • rojo
  • negro

Experimentando con array_diff_assoc()

 <?php
//array_diff_assoc() //similar a array_diff() pero toma en cuenta los KEY
$conjunto1 = ['a'=>3,'b'=>5,'c'=>9,'d'=>6];
$conjunto2 = ['a'=>3,'b'=>6,'c'=>9,'e'=>6];
$soloConj1 = array_diff_assoc($conjunto1, $conjunto2);
var_dump($soloConj1);
//array(2) { ["b"]=> int(5) ["d"]=> int(6) }
//Por lo visto deben tener la misma llave:valor en ambos conjuntos, si alguno es diferente no se sustrae

Este es mi ejercicio con el uso de diff_assoc()

$meses = [
    1 => 'Enero',
    2 => 'Febrero',
    3 => 'Marzo',
    4 => 'Abril',
    5 => 'Mayo',
    6 => 'Junio'
];
$mes_= ['Enero', 'Mayo', 'Febrero', 'Marzo']; 

var_dump(array_diff_assoc($meses, $mes)); /*debería mostrar Enero, Abril Mayo y Junio ya que son los que no están o si están no comparten el mismo key*/

Una de las caracteristicas de esta funcion es que nos ayuda a crear selects en html de manera dinamica.

Buenas! Comparto un ejercicio realizado con array_diff_assoc().


<?php
//array_diff_assoc() Vemos las diferencias en keys

$courses_1 = [
    'backend' =>'php',
    'framework' =>'laravel',
    'frontend' =>'javascript'
];
$courses_2 = [
    10 =>'php',
    100 =>'laravel',
    1000 =>'javascript'
];

var_dump(array_diff_assoc($courses_1, $courses_2));
var_dump(array_diff_assoc($courses_2, $courses_1));

Mis apuntes

14. Comparación

Comparación de arrays, comparto el código:

<?php

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

/**
 * array_diff($array1, $array2); devuelve todos los elementos
 * que están en el array1 pero no están en el array2
 * lo devuelve en forma de array
 */

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

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

var_dump(array_diff($arrayB, $arrayA));
<?php
// Your code here!
$courses1 = [
    'proyecto'=>'php',
    'general'=> 'js',
     'final'=>'laravel'
    ];
    
$courses2 = [
    'proyecto'=>'php',
    'general'=> 'js',
     'final'=>'laravel',
     'frontend' = 'css'
    ];    
   //array_diff_assoc($courses1, $courses2);
    echo "<pre>";
   // var_dump (array_chunk($courses, 3));
   
  var_dump(array_diff_assoc($courses1, $courses2);
?>

<?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

Estas clases me han ayudado mucho a perderle el temor a php, ahora se como investigar lo que no entiendo, partiendo de si es una función, y si es así si es interna del sistema o es creada, etc.
Muchas gracias Italo!

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


array_diff_assoc(arrayA, arrayB);

Output:

array(5) {
	0 => 1,
	1 => 2,
	2 => 3,
	3 => 4,
	4 => 5
}

Por que nos regresa 1,2,3,4,5? Siendo que 3,4,5 si se encuentran en el segundo array?
La explicacion es que array_diff_assoc compara primero los values de las keys segun sea el orden, es decir en la posicion 0 del array A esta el numero 1, pero en el B hay un 3, en la posicion 1 del array A, hay un 2, pero en el B hay un 4 y asi sucesivamente, por eso nos muestra 1,2,3,4,5 ya que hay una diferencia… no por que no se encuentre el valor como tal… sino que compara en la estructura de “key:value”, compara el key 0 del array A, con el key 0 del array B, y si no son iguales, nos lo retorna como que hay una diferencia…
Por ejemplo:

arrayA = [0,1,2,3,4,5];
arrayB = [1,2,3,4,5,0];
array_diff_assoc(arrayA,arrayB);

nos sigue mostrando de diferencia [0,1,2,3,4,5] a pesar de que todos los valores esten en ambos arrays… por que no compara valores en general sino por keys
Esto tambien aplica para keys que agregemos nosotros les dejo este enlace por si quieren echarle un vistazo ya que esto da mucho juego con bases de datos
https://www.php.net/manual/en/function.array-diff-assoc.php

Aquí les dejo un ejemplo bastante curioso que se me ocurrió xd

CONTEXTO: La candidata por la presidencia del Perú Keiko Fujimori viene participando 3 veces seguidas y este 6 de julio se definirá el futuro de un pais bastante “chancado por la corrupción y la delincuencia” .
No les aburro mas les dejo con el código del ejemplo.

<code> 
$segundaVueltaPeru2021=[
    'Peru Libre'=> 'Pedro Castillo',
    'Fuerza Popular'=> 'Keiko Fujimori',
];

$segundaVueltaPeru2016=[
    'Peruanos por el Kambio'=> 'Pedro Pablo Kuczynski',
    'Fuerza Popular'=> 'Keiko Fujimori',
];

$segundaVueltaPeru2011=[
    'PNP - Gana Peru'=> 'Ollanta Humala',
    'Fuerza 2011'=> 'Keiko Fujimori',
];

var_dump(array_diff($segundaVueltaPeru2011,$segundaVueltaPeru2016,$segundaVueltaPeru2021));

var_dump(array_diff_assoc($segundaVueltaPeru2011,$segundaVueltaPeru2016,$segundaVueltaPeru2021));

$ganador2021= implode('',array_diff($segundaVueltaPeru2021,$segundaVueltaPeru2016));

echo "FLASH ELECTORAL: El ganador de las elecciones Peru 2021 es el Sr. $ganador2021";

/* array(1) {
    ["PNP - Gana Peru"]=>
    string(14) "Ollanta Humala"
}

array(2) {
    ["PNP - Gana Peru"]=>
    string(14) "Ollanta Humala"
    ["Fuerza 2011"]=>
    string(14) "Keiko Fujimori"
} 

FLASH ELECTORAL: El ganador de las elecciones Peru 2021 es el Sr. Pedro Castillo

*/

<?php
echo ‘<!DOCTYPE html>
<html lang=“es”>
<head>
<meta charset=“utf-8” />
<title>Funciones de Array</title>
</head>
<body>
’;
//Comparando Listados

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

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

/*
var_dump($listaA);

var_dump($listaB);
*/

//array_diff listaA, listaB obtiene la resta de listaA-listaB, osea los que estan en listaA pero no en listaB

/*var_dump(array_diff($listaA,$listaB));

var_dump(array_diff($listaB,$listaA));
*/

//Comparando Array Asociativos
$listado=[
‘1’=>‘Hewler Packard’,
‘3’=>‘Acer’,
‘2’=>‘Lenovo’,
‘5’=>‘Alienwere’,
‘4’=>‘Samgsung’
];

$listaPhone=[
“1”=>“Samgsung”,
“3”=>“Xiaomi”,
“2”=>“Lenovo”,
“4”=>“Huawei”,
“5”=>“Apple”,
“6”=>“LG”,
“7”=>“HTC”,
“8”=>“nokia”
];

//array_dif_assoc hace una resta A-B pero debe coincidir la Key y el Value

var_dump(array_diff_assoc($listaPhone,$listado));
//el resultado es el siguiente
array(7) {
[1]=>
string(8) “Samgsung”
[3]=>
string(6) “Xiaomi”
[4]=>
string(6) “Huawei”
[5]=>
string(5) “Apple”
[6]=>
string(2) “LG”
[7]=>
string(3) “HTC”
[8]=>
string(5) “nokia”
}

El método **array_diff **se puede considerar como una intersección.

Notas:

Excelente

Buena clase

array_diff_assoc($array1, array2, $array3, …);

Devuelve todos los valores del $array1 que no estén presentes en ninguno de los otros arrays 😄

<?php

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

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

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

Les comparto un pequeño ejercicio:


$monedas1 = [
  'mx' => 'Peso Mexicano',
  'us' => 'Dollar',
  'eu' => 'Euro',
  'cop' => 'Peso Colombiano',
  'btc' => 'Bitcoin'
];

$monedas2 = [
  'mx' => 'Peso Mexicano',
  'usd' => 'Dollar',
  'eur' => 'Euro',
  'cop' => 'Peso Colombiano',
  'xrp' => 'Ripple',
  'lib' => 'Libras'
];

echo "<pre>";
var_dump(array_diff_assoc($monedas2, $monedas1));

El resultado es:

array(4) {
  ["usd"]=>
  string(6) "Dollar"
  ["eur"]=>
  string(4) "Euro"
  ["xrp"]=>
  string(6) "Ripple"
  ["lib"]=>
  string(6) "Libras"
}

Como veo este metodo es que segundo argumento es la base del arreglo, y los elementos del segundo arreglo que no coincidan tanto el key y value, serán retornados por el mismo.

No se si alguien lo vio de la misma forma, el array_diff es como la diferencia en conjuntos.
A diff B = son todos los elementos de A que no están en B

EJERCICIO:

$Ax = ["a"=>"laravel", "b"=>"php", "c"=>"javascript"];
$Az = ["a"=>"laravel", "b"=>"php", "d"=>"html"];

var_dump(array_diff_assoc($Az, $Ax));
Pantalla: array(1) {
  ["d"]=>
  string(4) "html"
}
__________________
var_dump(array_diff_assoc($Ax, $Az));
Pantalla:
array(1) {
  ["c"]=>
  string(10) "javascript"
}

mi ejercicio

<?php

$canasta1 = [
	"bebida" => "7up",
	"snacks" => "Doritos",
];

$canasta2 = [
	"bebida" => "cola",
	"snacks" => "Doritos",
	"postre" => "galletas"
];

$result=array_diff_assoc($canasta1, $canasta2);
print_r($result);    // Array ( [bebida] => 7up )

Me gusto mucho esto, ahorra impresionantemente código, mi reflexión es estudiar mas sobre las funciones propias de php para el manejo de arrays

Gracias!

Reto completado 😄