PHP අරාව අගය අනුව මකා දමන්න (යතුර නොවේ)

මට පහත පරිදි PHP අරාවක් ඇත:

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

අගය අඩංගු මූලද්‍රව්‍යය මකා දැමීමට මට අවශ්‍යය $del_val(උදාහරණයක් ලෙස $del_val=401), නමුත් එහි යතුර මම නොදනිමි. මෙය උදව් විය හැකිය: සෑම අගයක්ම පැවතිය හැක්කේ එක් වරක් පමණි .

කරුණාකර මෙම කාර්යය ඉටු කිරීම සඳහා සරලම කාර්යය මම සොයමි.

භාවිතා array_search()සහ unset, පහත සඳහන් කරන්න:

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

array_search()එය සොයාගත් මූලද්‍රව්‍යයේ යතුර නැවත ලබා දෙයි, එමඟින් එම මූලද්‍රව්‍යය මුල් අරාවෙන් ඉවත් කිරීමට භාවිතා කළ හැකිය unset(). එය FALSEඅසාර්ථක වූ විට නැවත පැමිණෙනු ඇත, කෙසේ වෙතත් එයට සාර්ථකත්වය මත ව්‍යාජ- y අගයක් ලබා දිය හැකිය (ඔබේ යතුර 0උදාහරණයක් ලෙස විය හැකිය ), එබැවින් දැඩි සංසන්දනාත්මක !==ක්‍රියාකරු භාවිතා කරන්නේ එබැවිනි .

මෙම if()ප්රකාශය යන්න පරීක්ෂා කරනු ඇත array_search()නැවත අගය, සහ එය කළා නම් පමණක් ක්රියාව සිදු වනු ඇත.

හොඳයි, අරාවෙන් මූලද්‍රව්‍යයක් මකා දැමීම මූලික වශයෙන් එක් මූලද්‍රව්‍යයක් සමඟ වෙනස සකසයි.

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

එය මනාව සාමාන්‍යකරණය කරයි, ඔබට අවශ්‍ය නම් එකවර ඔබට අවශ්‍ය තරම් මූලද්‍රව්‍ය ඉවත් කළ හැකිය.

වියාචනය: මගේ විසඳුම අරාවෙහි නව පිටපතක් නිපදවන අතර පරණ එක විකෘති වන පිළිගත් පිළිතුරට පටහැනිව තබා ගනී. ඔබට අවශ්‍ය එක තෝරන්න.

එක් රසවත් ක්‍රමයක් වන්නේ array_keys():

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

මෙම array_keys()කාර්යය යම් අගය හා දැඩි පරීක්ෂාවට (එනම් සැසඳීම් සඳහා භාවිතා ===) අවශ්ය වේ දැයි යතුරු පමණක් නැවත අතිරේක පරාමිතීන් දෙක ගනී.

එකම අගයක් සහිත (උදා [1, 2, 3, 3, 4]) බහුවිධ අරා අයිතමද මෙයින් ඉවත් කළ හැකිය .

ඔබේ අරාවෙහි අඩංගු වන්නේ එම අගය සහිත එක් අංගයක් පමණක් බව ඔබ නිශ්චිතව දන්නේ නම්, ඔබට එය කළ හැකිය

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

කෙසේ වෙතත්, ඔබේ අගය ඔබගේ අරාවෙහි එක් වරකට වඩා සිදුවිය හැකි නම්, ඔබට මෙය කළ හැකිය

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

සටහන: දෙවන විකල්පය ක්‍රියාත්මක වන්නේ වසා දැමීම් සමඟ PHP5.3 + සඳහා පමණි

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

හොඳම ක්‍රමය නම් array_splice

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

හොඳම දේ සඳහා හේතුව http://www.programmerinterview.com/index.php/php-questions/how-to-delete-an-element-from-an-array-in-php/

හෝ සරලව, අතින් ක්‍රමයක්:

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

මෙය ඔබගේ ආරක්‍ෂාව පිළිබඳ පූර්ණ පාලනයක් ඇති බැවින් ඒවායින් ආරක්ෂිත වේ

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

ප්‍රතිදානය

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

ඔබට කළ හැකිය:

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

පැහැදිලි කිරීම : 401අරාව පෙරළීමෙන් පසු යතුර ඇති මූලද්‍රව්‍යය මකන්න .

බහු අගයන් මකා දැමීමට මෙය උත්සාහ කරන්න:

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

Underscore.JS _.reject හි තර්කනය ණයට ගෙන ශ්‍රිත දෙකක් නිර්මාණය කළේය (මිනිසුන් ශ්‍රිතවලට වැඩි කැමැත්තක් දක්වයි !!)

array_reject_value: මෙම ශ්‍රිතය නිශ්චිතව දක්වා ඇති අගය ප්‍රතික්ෂේප කරයි (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: මෙම ශ්‍රිතය හුදෙක් කැඳවිය හැකි ක්‍රමය ප්‍රතික්ෂේප කරයි (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;
}

එබැවින් අපගේ වර්තමාන උදාහරණයේ දී අපට ඉහත කාර්යයන් පහත පරිදි භාවිතා කළ හැකිය:

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

හෝ ඊටත් වඩා හොඳය: (මෙය අපට array_filter වැනි භාවිතා කිරීමට වඩා හොඳ වාක්‍ය ඛණ්ඩයක් ලබා දෙයි )

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

ඉහත සඳහන් දේ වඩාත් සංකීර්ණ දේවල් සඳහා භාවිතා කළ හැකිය, 401 ට වඩා වැඩි හෝ සමාන සියලු අගයන් ඉවත් කිරීමට අපි කැමතියි යැයි කියමු.

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

පිළිගත් පිළිතුර අරාව අනුබද්ධ අරාව බවට පරිවර්තනය කරයි, එබැවින්, පිළිගත් පිළිතුර සමඟ එය අනුබද්ධ නොවන අරාවක් ලෙස තබා ගැනීමට ඔබ කැමති නම්, ඔබටද භාවිතා array_valuesකිරීමට සිදුවනු ඇත .

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

යොමුව මෙහි ඇත

මෙය කිසිසේත්ම කාර්යක්ෂම නොවන නමුත් සරල, බුද්ධිමත් හා කියවීමට පහසු බව මම දනිමි.
එබැවින් යමෙකු වැඩි වටිනාකම් හෝ වඩාත් විශේෂිත කොන්දේසි සමඟ වැඩ කිරීම සඳහා දීර් can කළ හැකි එතරම් විසිතුරු නොවන විසඳුමක් සොයන්නේ නම් .. මෙන්න සරල කේතයකි:

$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

ඊතල ශ්‍රිත භාවිතා කරමින් PHP 7.4 සමඟ:

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

එය අනුබද්ධ නොවන අරාවක් තබා ගැනීමට එය සමඟ ඔතා array_values():

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

ඔබගේ අවශ්‍යතාවයට අනුව “ එක් එක් අගයක් පැවතිය හැක්කේ එක් වරක් පමණි ” ඔබ ඔබේ අරාවෙහි අද්විතීය අගයන් තබා ගැනීමට උනන්දු වන්නේ නම්, එවිට array_unique()ඔබ සොයන දේ විය හැකිය.

ආදානය:

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

ප්‍රති ult ලය:

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

ඔබ එහි යතුර නොදන්නේ නම් එයින් අදහස් වන්නේ එය වැදගත් නොවන බවයි.

ඔබට අගය යතුර ලෙස තැබිය හැකිය, එයින් අදහස් කරන්නේ එය ක්ෂණිකව වටිනාකම සොයා ගන්නා බවයි. නැවත නැවතත් සියලු අංග සෙවීම භාවිතා කිරීමට වඩා හොඳය.

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

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

orක්රියාකරු භාවිතා කරන එක් ලයිනර් :

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

මම හිතන්නේ සරලම ක්‍රමය වනුයේ foreach loop එකක් සහිත ශ්‍රිතයක් භාවිතා කිරීමයි:

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

ප්‍රතිදානය වනුයේ:

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