PHP matriz eliminar por valor (no clave)

Tengo una matriz PHP de la siguiente manera:

$messages = [312, 401, 1599, 3, ...];

Quiero eliminar el elemento que contiene el valor $del_val(por ejemplo, $del_val=401), pero no sé su clave. Esto podría ayudar: cada valor solo puede estar allí una vez .

Estoy buscando la función más simple para realizar esta tarea, por favor.

Usando array_search()y unset, intente lo siguiente:

if (($key = array_search($del_val, $messages)) !== false) {
    unset($messages[$key]);
}

array_search()devuelve la clave del elemento que encuentra, que puede usarse para eliminar ese elemento de la matriz original usando unset(). Volverá FALSEen caso de falla, sin embargo, puede devolver un valor falso y en caso de éxito (su clave puede ser, 0por ejemplo), razón por la cual se utiliza el !==operador de comparación estricto .

La if()declaración verificará si array_search()devolvió un valor y solo realizará una acción si lo hizo.

Bueno, eliminar un elemento de la matriz es básicamente establecer la diferencia con un elemento.

array_diff( [312, 401, 15, 401, 3], [401] ) // removing 401 returns [312, 15, 3]

Se generaliza muy bien, puede eliminar tantos elementos como desee al mismo tiempo, si lo desea.

Descargo de responsabilidad: tenga en cuenta que mi solución produce una nueva copia de la matriz mientras mantiene intacta la anterior en contraste con la respuesta aceptada que muta. Elige el que necesitas.

Una forma interesante es mediante el uso de array_keys():

foreach (array_keys($messages, 401, true) as $key) {
    unset($messages[$key]);
}

La array_keys()función toma dos parámetros adicionales para devolver solo claves para un valor particular y si se requiere una verificación estricta (es decir, usar === para la comparación).

Esto también puede eliminar múltiples elementos de la matriz con el mismo valor (por ejemplo [1, 2, 3, 3, 4]).

Si sabe con certeza que su matriz contendrá solo un elemento con ese valor, puede hacer

$key = array_search($del_val, $array);
if (false !== $key) {
    unset($array[$key]);
}

Sin embargo, si su valor puede aparecer más de una vez en su matriz, puede hacer esto

$array = array_filter($array, function($e) use ($del_val) {
    return ($e !== $del_val);
});

Nota: La segunda opción solo funciona para PHP5.3 + con cierres

$fields = array_flip($fields);
unset($fields['myvalue']);
$fields = array_flip($fields);

Echa un vistazo al siguiente código:

$arr = array('nice_item', 'remove_me', 'another_liked_item', 'remove_me_also');

Tu puedes hacer:

$arr = array_diff($arr, array('remove_me', 'remove_me_also'));

Y eso te dará esta matriz:

array('nice_item', 'another_liked_item')

La mejor manera es array_splice

array_splice($array, array_search(58, $array ), 1);

Reason for Best está aquí en http://www.programmerinterview.com/index.php/php-questions/how-to-delete-an-element-from-an-array-in-php/

O simplemente, de forma manual:

foreach ($array as $key => $value){
    if ($value == $target_value) {
        unset($array[$key]);
    }
}

Este es el más seguro de ellos porque tienes control total sobre tu matriz

Mediante el siguiente código, los valores repetitivos se eliminarán de los mensajes $.

$messages = array_diff($messages, array(401));

Si tiene PHP 5.3+, existe el código de una línea:

$array = array_filter($array, function ($i) use ($value) { return $i !== $value; }); 

function array_remove_by_value($array, $value)
{
    return array_values(array_diff($array, array($value)));
}

$array = array(312, 401, 1599, 3);

$newarray = array_remove_by_value($array, 401);

print_r($newarray);

Salida

Array ( [0] => 312 [1] => 1599 [2] => 3 )

tu puedes hacer:

unset($messages[array_flip($messages)['401']]);

Explicación : elimine el elemento que tiene la clave 401después de voltear la matriz.

Para eliminar varios valores, pruebe este:

while (($key = array_search($del_val, $messages)) !== false) 
{
    unset($messages[$key]);
}

Tomó prestada la lógica de subrayar.JS _.reject y creó dos funciones (¡la gente prefiere las funciones!)

array_reject_value: esta función simplemente rechaza el valor especificado (también funciona para PHP4,5,7)

function array_reject_value(array &$arrayToFilter, $deleteValue) {
    $filteredArray = array();

    foreach ($arrayToFilter as $key => $value) {
        if ($value !== $deleteValue) {
            $filteredArray[] = $value;
        }
    }

    return $filteredArray;
}

array_reject: esta función simplemente rechaza el método invocable (funciona para PHP> = 5.3)

function array_reject(array &$arrayToFilter, callable $rejectCallback) {

    $filteredArray = array();

    foreach ($arrayToFilter as $key => $value) {
        if (!$rejectCallback($value, $key)) {
            $filteredArray[] = $value;
        }
    }

    return $filteredArray;
}

Entonces, en nuestro ejemplo actual, podemos usar las funciones anteriores de la siguiente manera:

$messages = [312, 401, 1599, 3, 6];
$messages = array_reject_value($messages, 401);

o incluso mejor: (ya que esto nos da una mejor sintaxis para usar como el array_filter )

$messages = [312, 401, 1599, 3, 6];
$messages = array_reject($messages, function ($value) {
    return $value === 401;
});

Lo anterior se puede usar para cosas más complicadas, como digamos que nos gustaría eliminar todos los valores que son mayores o iguales a 401, simplemente podríamos hacer esto:

$messages = [312, 401, 1599, 3, 6];
$greaterOrEqualThan = 401;
$messages = array_reject($messages, function ($value) use $greaterOrEqualThan {
    return $value >= $greaterOrEqualThan;
});

$array = array("apple", "banana",'mango');
$array = array_filter($array, function($v) { return $v != "apple"; });

Pruebe esto, esta es la mejor y más rápida forma de eliminar elementos por valor

La respuesta de @Bojangles me ayudó. Gracias.

En mi caso, la matriz podría ser asociativa o no, así que agregué la siguiente función

function test($value, $tab) {

 if(($key = array_search($value, $tab)) !== false) {
    unset($tab[$key]); return true;

 } else if (array_key_exists($value, $tab)){
        unset($tab[$value]); return true;

 } else {
    return false; // the $value is not in the array $tab
 }

}

Saludos

código de línea único (gracias a array_diff () ), use lo siguiente:

$messages = array_diff($messages, array(401));

La respuesta aceptada convierte la matriz en una matriz asociativa, por lo tanto, si desea mantenerla como una matriz no asociativa con la respuesta aceptada, es posible que también deba usarla array_values.

if(($key = array_search($del_val, $messages)) !== false) {
    unset($messages[$key]);
    $arr = array_values($messages);
}

La referencia está aquí

Según su requisito, " cada valor solo puede estar allí por una vez " si solo está interesado en mantener valores únicos en su matriz, entonces elarray_unique() podría ser lo que está buscando.

Entrada:

$input = array(4, "4", "3", 4, 3, "3");
$result = array_unique($input);
var_dump($result);

Resultado:

array(2) {
  [0] => int(4)
  [2] => string(1) "3"
}

Si los valores que desea eliminar están o pueden estar en una matriz. Use la función array_diff . Parece funcionar muy bien para cosas como esta.

array_diff

$arrayWithValuesRemoved = array_diff($arrayOfData, $arrayOfValuesToRemove);

Sé que esto no es eficiente en absoluto, pero es simple, intuitivo y fácil de leer.
Entonces, si alguien está buscando una solución no tan elegante que se pueda extender para trabajar con más valores o condiciones más específicas ... aquí hay un código simple:

$result = array();
$del_value = 401;
//$del_values = array(... all the values you don`t wont);

foreach($arr as $key =>$value){
    if ($value !== $del_value){
        $result[$key] = $value;
    }

    //if(!in_array($value, $del_values)){
    //    $result[$key] = $value;
    //}

    //if($this->validete($value)){
    //      $result[$key] = $value;
    //}
}

return $result

Obtenga la clave de matriz con array_search().

Si no conoce su clave, significa que no importa.

Puede colocar el valor como clave, significa que encontrará el valor instantáneamente. Mejor que usar la búsqueda en todos los elementos una y otra vez.

$messages=array();   
$messages[312] = 312;    
$messages[401] = 401;   
$messages[1599] = 1599;   
$messages[3] = 3;    

unset($messages[3]); // no search needed

Una línea usando el oroperador:

($key = array_search($del_val, $messages)) !== false or unset($messages[$key]);

puedes referir esta URL : para la función

array-diff-key()

<?php
$array1 = array('blue'  => 1, 'red'  => 2, 'green'  => 3, 'purple' => 4);
$array2 = array('green' => 5, 'blue' => 6, 'yellow' => 7, 'cyan'   => 8);

var_dump(array_diff_key($array1, $array2));
?>

Entonces la salida debería ser,

array(2) {
  ["red"]=>
  int(2)
  ["purple"]=>
  int(4)
}

Otra idea para eliminar el valor de una matriz, use array_diff. Si yo quiero

$my_array = array(1=>"a", "second_value"=>"b", 3=>"c", "d");
$new_array_without_value_c = array_diff($my_array, array("c"));

(Doc: http://php.net/manual/fr/function.array-diff.php )

Creo que la forma más sencilla sería utilizar una función con un bucle foreach:

//This functions deletes the elements of an array $original that are equivalent to the value $del_val
//The function works by reference, which means that the actual array used as parameter will be modified.

function delete_value(&$original, $del_val)
{
    //make a copy of the original, to avoid problems of modifying an array that is being currently iterated through
    $copy = $original;
    foreach ($original as $key => $value)
    {
        //for each value evaluate if it is equivalent to the one to be deleted, and if it is capture its key name.
        if($del_val === $value) $del_key[] = $key;
    };
    //If there was a value found, delete all its instances
    if($del_key !== null)
    {
        foreach ($del_key as $dk_i)
        {
            unset($original[$dk_i]);
        };
        //optional reordering of the keys. WARNING: only use it with arrays with numeric indexes!
        /*
        $copy = $original;
        $original = array();
        foreach ($copy as $value) {
            $original[] = $value;
        };
        */
        //the value was found and deleted
        return true;
    };
    //The value was not found, nothing was deleted
    return false;
};

$original = array(0,1,2,3,4,5,6,7,4);
$del_val = 4;
var_dump($original);
delete_value($original, $del_val);
var_dump($original);

La salida será:

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

Con PHP 7.4 usando funciones de flecha:

$messages = array_filter($messages, fn ($m) => $m != $del_val);

Para mantenerlo en una matriz no asociativa, envuélvalo con array_values():

$messages = array_values(array_filter($messages, fn ($m) => $m != $del_val));