Exclusão da matriz PHP por valor (não chave)

Eu tenho uma matriz PHP da seguinte maneira:

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

Quero excluir o elemento que contém o valor $del_val(por exemplo $del_val=401), mas não sei sua chave. Isso pode ajudar: cada valor pode estar lá apenas uma vez .

Estou procurando a função mais simples para executar esta tarefa, por favor.

Usando array_search()e unset, tente o seguinte:

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

array_search()retorna a chave do elemento encontrado, que pode ser usado para remover esse elemento da matriz original usando unset(). Ele retornará FALSEem caso de falha, mas poderá retornar um valor falso-y em caso de sucesso (sua chave pode ser, 0por exemplo), razão pela qual o !==operador de comparação estrita é usado.

A if()instrução verificará se array_search()um valor retornou e só executará uma ação se o fizer.

Bem, excluir um elemento da matriz é basicamente definir a diferença com um elemento.

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

Ele generaliza bem, você pode remover quantos elementos quiser ao mesmo tempo, se desejar.

Isenção de responsabilidade: observe que minha solução produz uma nova cópia da matriz, mantendo a antiga intacta, em contraste com a resposta aceita que sofre mutação. Escolha o que você precisa.

Uma maneira interessante é usar array_keys():

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

A array_keys()função utiliza dois parâmetros adicionais para retornar apenas chaves para um valor específico e se é necessária uma verificação rigorosa (por exemplo, usando === para comparação).

Isso também pode remover vários itens da matriz com o mesmo valor (por exemplo [1, 2, 3, 3, 4]).

Se você souber com certeza que sua matriz conterá apenas um elemento com esse valor, poderá fazer

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

Se, no entanto, seu valor puder ocorrer mais de uma vez em sua matriz, você poderá fazer isso

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

Nota: A segunda opção funciona apenas para PHP5.3 + com Closures

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

Veja o seguinte código:

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

Você pode fazer:

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

E isso lhe dará essa matriz:

array('nice_item', 'another_liked_item')

A melhor maneira é array_splice

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

Razão para Melhor está aqui em http://www.programmerinterview.com/index.php/php-questions/how-to-delete-an-element-from-an-array-in-php/

Ou simplesmente, de maneira manual:

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

Este é o mais seguro deles, porque você tem controle total sobre sua matriz

Pelo código a seguir, os valores repetitivos serão removidos das $ messages.

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

Se você possui PHP 5.3+, existe o código de uma linha:

$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);

Resultado

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

você pode fazer:

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

Explicação : Exclua o elemento que possui a chave 401depois de virar a matriz.

Para excluir vários valores, tente este:

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

Emprestou a lógica de underscore.JS _.reject e criou duas funções (as pessoas preferem funções !!)

array_reject_value: Esta função está simplesmente rejeitando o valor especificado (também 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 função está simplesmente rejeitando o método que pode ser chamado (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;
}

Portanto, em nosso exemplo atual, podemos usar as funções acima, da seguinte maneira:

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

ou ainda melhor: (como isso nos dá uma sintaxe melhor para usar como a matriz array_filter )

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

O exemplo acima pode ser usado para coisas mais complicadas, como, digamos, que gostaríamos de remover todos os valores maiores ou iguais a 401. Podemos simplesmente fazer o seguinte:

$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"; });

Tente isso, esta é a melhor e mais rápida maneira de remover elemento por valor

A resposta @Bojangles me ajudou. Obrigado.

No meu caso, a matriz pode ser associativa ou não, então eu adicionei a seguinte função

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
 }

}

Saudações

código de liner único (graças a array_diff () ), use o seguinte:

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

A resposta aceita converte a matriz em matriz associativa; portanto, se você deseja mantê-la como uma matriz não associativa com a resposta aceita, talvez seja necessário usar array_valuestambém.

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

A referência está aqui

Conforme sua exigência " cada valor pode estar lá apenas uma vez " se você estiver apenas interessado em manter valores exclusivos em sua matriz, então array_unique()pode ser o que você está procurando.

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"
}

Se os valores que você deseja excluir estiverem ou puderem estar em uma matriz. Use o array_diff função . Parece funcionar muito bem para coisas assim.

array_diff

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

Sei que isso não é nada eficiente, mas é simples, intuitivo e fácil de ler.
Portanto, se alguém está procurando uma solução não tão sofisticada que possa ser estendida para trabalhar com mais valores ou condições mais específicas ... aqui está um código simples:

$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

Obtenha a chave da matriz com array_search().

Se você não conhece sua chave, significa que não importa.

Você pode colocar o valor como chave, significa que ele encontrará o valor instantaneamente. Melhor do que usar a pesquisa em todos os elementos repetidamente.

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

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

Uma linha única usando o oroperador:

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

você pode consultar este URL : para função

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

Então a saída deve ser,

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

Outra idéia para excluir o valor de uma matriz, use array_diff. Se eu quero

$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 )

Eu acho que a maneira mais simples seria usar uma função com um loop 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);

A saída 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)
}

Com o PHP 7.4 usando funções de seta:

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

Para manter uma matriz não associativa, envolva-a com array_values():

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