PHP භාවිතා කරමින් අරාවකින් මූලද්‍රව්‍යයක් මකා දැමීමට පහසු ක්‍රමයක් තිබේද? foreach ($array) තිබේද?

මම සිතුවේ එය සැකසීම එය කරයි nullකියා, නමුත් පෙනෙන ආකාරයට එය ක්‍රියාත්මක නොවේ.

අරාව අංගයක් මකා දැමීමට විවිධ ක්‍රම තිබේ, සමහර ඒවා අනෙක් ඒවාට වඩා සමහර විශේෂිත කාර්යයන් සඳහා වඩාත් ප්‍රයෝජනවත් වේ.

එක් අරාව අංගයක් මකන්න

ඔයා එක මාලාවක් අංගයක් ඉවත් කිරීමට අවශ්ය නම් ඔබට භාවිතා කළ හැකි unset()විකල්ප හෝ \array_splice().

ඔබට වටිනාකමක් තිබේ නම් සහ යතුර ලබා ගැනීමට ඔබට භාවිතා කළ හැකි මූලද්‍රව්‍යය මකා දැමීමේ යතුර නොදන්නේ නම් \array_search().

unset()

ඔබ unset()අරාව යතුරු භාවිතා කරන විට / reindex වෙනස් නොවන බව සලකන්න. ඔබට යතුරු නැවත සම්බන්ධ කිරීමට අවශ්‍ය නම් ඔබට \array_values()පසුව භාවිතා කළ හැකි unset()යතුරු 0 සිට ඇරඹෙන සංඛ්‍යාත්මක සංඛ්‍යාත්මක යතුරු බවට පරිවර්තනය කරයි.

කේතය

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    unset($array[1]);
                //↑ Key which you want to delete

?>

ප්‍රතිදානය

[
    [0] => a
    [2] => c
]

\array_splice() ක්‍රමය

ඔබ \array_splice()යතුරු භාවිතා කරන්නේ නම් ස්වයංක්‍රීයව නැවත සම්බන්ධ කරනු ලැබේ, නමුත් සහායක යතුරු වෙනස් නොවන \array_values()අතර එමඟින් සියලු යතුරු සංඛ්‍යාත්මක යතුරු බවට පරිවර්තනය වේ.

තවද \array_splice()යතුර නොව ඕෆ්සෙට් අවශ්‍ය වේ! දෙවන පරාමිතිය ලෙස.

කේතය

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    \array_splice($array, 1, 1);
                        //↑ Offset which you want to delete

?>

ප්‍රතිදානය

[
    [0] => a
    [1] => c
]

array_splice()unset()යොමු දැක්වීමෙන් අරාව ගන්නවා හා සමානයි , මෙයින් අදහස් කරන්නේ එම ශ්‍රිතවල ප්‍රතිලාභ අගයන් නැවත අරාව වෙත පැවරීමට ඔබට අවශ්‍ය නැති බවයි.

බහු අරාව අංග මකන්න

ඔබට බහු අරාව මූලද්‍රව්‍ය මකා දැමීමට අවශ්‍ය නම් සහ ඇමතීමට අවශ්‍ය unset()නැතිනම් හෝ \array_splice()කිහිප වතාවක් ඔබට ශ්‍රිත භාවිතා කළ හැකිය. \array_diff()නැතහොත් \array_diff_key()මකා දැමීමට අවශ්‍ය මූලද්‍රව්‍යවල අගයන් හෝ යතුරු ඔබ දන්නවාද යන්න මත පදනම්ව.

\array_diff() ක්‍රමය

ඔබට මැකීමට අවශ්‍ය අරාව මූලද්‍රව්‍යවල අගයන් ඔබ දන්නේ නම්, ඔබට භාවිතා කළ හැකිය \array_diff(). පෙර මෙන් unset()එය අරාවෙහි යතුරු වෙනස් නොකරයි / නැවත සම්බන්ධ නොකරයි.

කේතය

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    $array = \array_diff($array, ["a", "c"]);
                               //└────────┘→ Array values which you want to delete

?>

ප්‍රතිදානය

[
    [1] => b
]

\array_diff_key() ක්‍රමය

ඔබට මැකීමට අවශ්‍ය මූලද්‍රව්‍යවල යතුරු ඔබ දන්නේ නම්, ඔබට භාවිතා කිරීමට අවශ්‍යය \array_diff_key(). මෙහිදී ඔබ යතුරු දෙවන පරාමිතියේ යතුරු ලෙස යතුරු බවට පත් කරන බවට වග බලා ගත යුතුය. එසේ නොමැතිනම්, ඔබ සමඟ අරාව පෙරළා දැමිය යුතුය\array_flip() . තවද මෙහි යතුරු වෙනස් නොවේ / රින්ඩෙක්ස් නොවේ.

කේතය

<?php

    $array = [0 => "a", 1 => "b", 2 => "c"];
    $array = \array_diff_key($array, [0 => "xy", "2" => "xy"]);
                                    //↑           ↑ Array keys which you want to delete
?>

ප්‍රතිදානය

[
    [1] => b
]

ඔබට එකම අගයක් සහිත බහු මූලද්‍රව්‍ය භාවිතා කිරීමට unset()හෝ \array_splice()මකා දැමීමට \array_keys()අවශ්‍ය නම් නිශ්චිත අගයක් සඳහා සියලු යතුරු ලබා ගැනීමට සහ සියලු අංග මකා දැමීමට ඔබට භාවිතා කළ හැකිය.

එය unset()සුචිගත නොකෙරෙන බව සැලකිල්ලට ගත යුතුය , එය නූල් දර්ශක භාවිතා කරන විට ඔබ බලාපොරොත්තු වන දෙයයි (අරා හැෂ් ටේබල් ලෙස), නමුත් පූර්ණ සංඛ්‍යා සුචිගත කරන ලද අරා සමඟ කටයුතු කිරීමේදී එය පුදුමයට කරුණක් විය හැකිය:

$array = array(0, 1, 2, 3);
unset($array[2]);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [3]=>
  int(3)
} */

$array = array(0, 1, 2, 3);
array_splice($array, 2, 1);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(3)
} */

ඒ නිසා array_splice()ඔබ ඔබේ පූර්ණ සංඛ්යාමය යතුරු යථා තත්වයට කැමතියි නම් භාවිතා කළ හැක. තවත් විකල්පයක් භාවිතා array_values()පසු unset():

$array = array(0, 1, 2, 3);

unset($array[2]);
$array = array_values($array);
var_dump($array);
/* array(3) {
  [0]=>
  int(0)
  [1]=>
  int(1)
  [2]=>
  int(3)
} */

  // Our initial array
  $arr = array("blue", "green", "red", "yellow", "green", "orange", "yellow", "indigo", "red");
  print_r($arr);

  // Remove the elements who's values are yellow or red
  $arr = array_diff($arr, array("yellow", "red"));
  print_r($arr);

ඉහත කේතයෙන් ලැබෙන ප්‍රතිදානය මෙයයි:

Array
(
    [0] => blue
    [1] => green
    [2] => red
    [3] => yellow
    [4] => green
    [5] => orange
    [6] => yellow
    [7] => indigo
    [8] => red
)

Array
(
    [0] => blue
    [1] => green
    [4] => green
    [5] => orange
    [7] => indigo
)

දැන්, array_values ​​() සංඛ්‍යාත්මක අරාව මනාව ප්‍රතිනිර්මාණය කරනු ඇත, නමුත් එය අරාව වෙතින් සියලුම යතුරු නූල් ඉවත් කර ඒවා සංඛ්‍යා සමඟ ප්‍රතිස්ථාපනය කරයි. ඔබට යතුරු නම් (නූල්) සංරක්ෂණය කිරීමට අවශ්‍ය නම්, හෝ සියලු යතුරු සංඛ්‍යාත්මක නම් අරාව නැවත සම්බන්ධ කරන්න, array_merge () භාවිතා කරන්න:

$arr = array_merge(array_diff($arr, array("yellow", "red")));
print_r($arr);

නිමැවුම්

Array
(
    [0] => blue
    [1] => green
    [2] => green
    [3] => orange
    [4] => indigo
)

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

unset($array[$index]);

ඔබට සංඛ්‍යාත්මකව සුචිගත කරන ලද අරාවක් තිබේ නම්, සියලු අගයන් අද්විතීය වේ (හෝ ඒවා අද්විතීය නොවන නමුත් විශේෂිත අගයක සියලු අවස්ථා ඉවත් කිරීමට ඔබ අදහස් කරන්නේ නම්), ඔබට ගැලපෙන මූලද්‍රව්‍යයක් ඉවත් කිරීමට සරලවම array_diff () භාවිතා කළ හැකිය:

$my_array = array_diff($my_array, array('Value_to_remove'));

උදාහරණයක් වශයෙන්:

$my_array = array('Andy', 'Bertha', 'Charles', 'Diana');
echo sizeof($my_array) . "\n";
$my_array = array_diff($my_array, array('Charles'));
echo sizeof($my_array);

මෙය පහත දැක්වේ:

4
3

මෙම උදාහරණයේ දී, 'චාල්ස්' අගය සහිත මූලද්‍රව්‍යය ඉවත් කරනු ලැබේ, ආරම්භක අරාව සඳහා 4 ක ප්‍රමාණයක් වාර්තා කරන ප්‍රමාණයේ () ඇමතුම් මගින් සත්‍යාපනය කළ හැකි අතර, ඉවත් කිරීමෙන් පසු 3 ක්.

එසේම, නම් කරන ලද මූලද්රව්යයක් සඳහා:

unset($array["elementName"]);

අරාවෙහි තනි අංගයක් විනාශ කරන්න

unset()

$array1 = array('A', 'B', 'C', 'D', 'E');
unset($array1[2]); // Delete known index(2) value from array
var_dump($array1);

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

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [3]=>
  string(1) "D"
  [4]=>
  string(1) "E"
}

ඔබට අරාව නැවත සුචිගත කිරීමට අවශ්‍ය නම්:

$array1 = array_values($array1);
var_dump($array1);

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

array(4) {
  [0]=>
  string(1) "A"
  [1]=>
  string(1) "B"
  [2]=>
  string(1) "D"
  [3]=>
  string(1) "E"
}

අරාව අවසානයේ මූලද්‍රව්‍යය පොප් කරන්න - ඉවත් කළ මූලද්‍රව්‍යයේ අගය නැවත ලබා දෙන්න

mixed array_pop(array &$array)

$stack = array("orange", "banana", "apple", "raspberry");
$last_fruit = array_pop($stack);
print_r($stack);
print_r('Last Fruit:'.$last_fruit); // Last element of the array

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

Array
(
    [0] => orange
    [1] => banana
    [2] => apple
)
Last Fruit: raspberry

අරාවකින් පළමු මූලද්‍රව්‍යය (රතු) ඉවත් කරන්න , - ඉවත් කළ මූලද්‍රව්‍යයේ අගය නැවත ලබා දෙන්න

mixed array_shift ( array &$array )

$color = array("a" => "red", "b" => "green" , "c" => "blue");
$first_color = array_shift($color);
print_r ($color);
print_r ('First Color: '.$first_color);

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

Array
(
    [b] => green
    [c] => blue
)
First Color: red

<?php
    $stack = ["fruit1", "fruit2", "fruit3", "fruit4"];
    $fruit = array_shift($stack);
    print_r($stack);

    echo $fruit;
?>

ප්‍රතිදානය:

[
    [0] => fruit2
    [1] => fruit3
    [2] => fruit4
]

fruit1

සෙවීමක් කිරීමෙන් වැළකී සිටීමට කෙනෙකුට සෙල්ලම් කළ හැකිය array_diff:

$array = array(3, 9, 11, 20);
$array = array_diff($array, array(11) ); // removes 11

මෙම අවස්ථාවේදී යමෙකුට යතුර සෙවීමට / භාවිතා කිරීමට අවශ්‍ය නැත.

ඔබට අරාවෙහි බහු අගයන් මකා දැමීමට සිදුවුවහොත් සහ එම අරාවෙහි ඇතුළත් කිරීම් වස්තු හෝ ව්‍යුහාත්මක දත්ත නම්, [array_filter][1]ඔබේ හොඳම ඔට්ටුව වේ. ඇමතුම් ආපසු ගැනීමේ ශ්‍රිතයෙන් සත්‍යයක් ලබා දෙන එම සටහන් රඳවා ගනු ඇත.

$array = [
    ['x'=>1,'y'=>2,'z'=>3], 
    ['x'=>2,'y'=>4,'z'=>6], 
    ['x'=>3,'y'=>6,'z'=>9]
];

$results = array_filter($array, function($value) {
    return $value['x'] > 2; 
}); //=> [['x'=>3,'y'=>6,z=>'9']]

සහායක අරා

සහායක අරා සඳහා, භාවිතා කරන්න unset:

$arr = array('a' => 1, 'b' => 2, 'c' => 3);
unset($arr['b']);

// RESULT: array('a' => 1, 'c' => 3)

සංඛ්‍යාත්මක අරා

සංඛ්‍යාත්මක අරා සඳහා, භාවිතා කරන්න array_splice:

$arr = array(1, 2, 3);
array_splice($arr, 1, 1);

// RESULT: array(0 => 1, 1 => 3)

සටහන

unsetසංඛ්‍යාත්මක අරා සඳහා භාවිතා කිරීම දෝෂයක් ඇති නොකරනු ඇත, නමුත් එය ඔබගේ දර්ශක අවුල් කරයි:

$arr = array(1, 2, 3);
unset($arr[1]);

// RESULT: array(0 => 1, 2 => 3)

ඔබට සහායක අරාවකින් බහු අංග ඉවත් කිරීමට අවශ්‍ය නම්, ඔබට array_diff_key () භාවිතා කළ හැකිය (මෙහි අරාව_ෆ්ලිප් () සමඟ භාවිතා වේ :

$my_array = array(
  "key1" => "value 1",
  "key2" => "value 2",
  "key3" => "value 3",
  "key4" => "value 4",
  "key5" => "value 5",
);

$to_remove = array("key2", "key4");

$result = array_diff_key($my_array, array_flip($to_remove));

print_r($result);

ප්‍රතිදානය:

Array ( [key1] => value 1 [key3] => value 3 [key5] => value 5 ) 

unset() නිශ්චිත විචල්යයන් විනාශ කරයි.

හි හැසිරීම unset()ඔබ විනාශ කිරීමට උත්සාහ කරන්නේ කුමන ආකාරයේ විචල්‍යයක් මත පදනම්ව ශ්‍රිතයක අභ්‍යන්තරයේ වෙනස් විය හැකිය.

ගෝලීයකරණය වූ විචල්‍යයක් unset()ශ්‍රිතයක් තුළ තිබේ නම්, විනාශ වන්නේ දේශීය විචල්‍යය පමණි. ඇමතුම් පරිසරයේ විචල්‍යය කලින් unset()හැඳින්වූ ආකාරයටම රඳවා ගනී .

<?php
    function destroy_foo()
    {
        global $foo;
        unset($foo);
    }

    $foo = 'bar';
    destroy_foo();
    echo $foo;
?>

ඉහත කේතයේ පිළිතුර තීරුව වනු ඇත .

කිරීමට unset()ශ්රිතයක ගෝලීය විචල්ය තුල:

<?php
    function foo()
    {
        unset($GLOBALS['bar']);
    }

    $bar = "something";
    foo();
?>

// Remove by value
function removeFromArr($arr, $val)
{
    unset($arr[array_search($val, $arr)]);
    return array_values($arr);
}

දර්ශකය නියම කර ඇත්නම්:

$arr = ['a', 'b', 'c'];
$index = 0;    
unset($arr[$index]);  // $arr = ['b', 'c']

දර්ශකය නිශ්චිතව දක්වා නොමැති නම්:

$arr = ['a', 'b', 'c'];
$index = array_search('a', $arr); // search the value to find index
if($index !== false){
   unset($arr[$index]);  // $arr = ['b', 'c']
}

මෙම ifනම් නිසා තත්ත්වය අවශ්ය indexසොයා නැත, unset()ස්වයංක්රීයව අපි කැමති දේ නො වන එම අරාව පළමු අංගය මකා ඇත.

විසඳුම්:

1. එක් අංගයක් මකා දැමීමට, setet () භාවිතා කරන්න :

unset($array[3]);
unset($array['foo']);

2. නොගැලපෙන බහු මූලද්‍රව්‍ය මකා දැමීමට, සැකසූ () ද භාවිතා කරන්න :

unset($array[3], $array[5]);
unset($array['foo'], $array['bar']);

3. බහු පරස්පර මූලද්‍රව්‍ය මකා දැමීමට, array_splice () භාවිතා කරන්න :

array_splice($array, $offset, $length);

වැඩිදුර පැහැදිලි කිරීම:

මෙම ශ්‍රිත භාවිතා කිරීමෙන් PHP වෙතින් මෙම මූලද්‍රව්‍යයන් පිළිබඳ සියලු යොමු කිරීම් ඉවත් කරයි. ඔබට අරාව තුළ යතුරක් තබා ගැනීමට අවශ්‍ය නම්, නමුත් හිස් අගයක් සහිතව, හිස් නූල මූලද්‍රව්‍යයට පවරන්න:

$array[3] = $array['foo'] = '';

සින්ටැක්ස් වලට අමතරව, සැකසූ () භාවිතා කිරීම සහ මූලද්‍රව්‍යයට '' පැවරීම අතර තාර්කික වෙනසක් ඇත. පළමුවැන්නා පවසන This doesn't exist anymore,අතර දෙවැන්නා පවසයිThis still exists, but its value is the empty string.

ඔබ සංඛ්‍යා සමඟ කටයුතු කරන්නේ නම්, 0 පැවරීම වඩා හොඳ විකල්පයක් විය හැකිය. එබැවින්, සමාගමක් XL1000 ස්ප්රොකට් මාදිලියේ නිෂ්පාදනය නැවැත්වුවහොත්, එය සිය ඉන්වෙන්ටරි යාවත්කාලීන කරන්නේ:

unset($products['XL1000']);

කෙසේ වෙතත්, එය තාවකාලිකව XL1000 ස්ප්රොකට් වලින් ඉවතට ගියත්, මෙම සතිය අගදී බලාගාරයෙන් නව නැව්ගත කිරීමක් ලබා ගැනීමට සැලසුම් කර ඇත්නම්, මෙය වඩා හොඳය:

$products['XL1000'] = 0;

ඔබ () මූලද්‍රව්‍යයක් සැකසුවේ නම් , PHP අරාව සකස් කරයි, එවිට ලූපය තවමත් නිවැරදිව ක්‍රියා කරයි. නැතිවූ සිදුරු පිරවීම සඳහා එය අරාව සංයුක්ත නොකරයි. සියලුම අරා සංඛ්යාත්මක යැයි පෙනෙන විට පවා ඒවා අනුබද්ධ බව අප පවසන විට මෙය අදහස් කරන්නේ එයයි. මෙන්න උදාහරණයක්:

// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
print $animals[1];  // Prints 'bee'
print $animals[2];  // Prints 'cat'
count($animals);    // Returns 6

// unset()
unset($animals[1]); // Removes element $animals[1] = 'bee'
print $animals[1];  // Prints '' and throws an E_NOTICE error
print $animals[2];  // Still prints 'cat'
count($animals);    // Returns 5, even though $array[5] is 'fox'

// Add a new element
$animals[ ] = 'gnu'; // Add a new element (not Unix)
print $animals[1];  // Prints '', still empty
print $animals[6];  // Prints 'gnu', this is where 'gnu' ended up
count($animals);    // Returns 6

// Assign ''
$animals[2] = '';   // Zero out value
print $animals[2];  // Prints ''
count($animals);    // Returns 6, count does not decrease

අරාව ely න ලෙස පුරවන සංඛ්‍යාත්මක අරාවකට සංයුක්ත කිරීමට, array_values ​​() භාවිතා කරන්න :

$animals = array_values($animals);

විකල්පයක් ලෙස, සිදුරු හැර යාම වළක්වා ගැනීම සඳහා array_splice () ස්වයංක්‍රීයව අරා නැවත සම්බන්ධ කරයි:

// Create a "numeric" array
$animals = array('ant', 'bee', 'cat', 'dog', 'elk', 'fox');
array_splice($animals, 2, 2);
print_r($animals);
Array
(
    [0] => ant
    [1] => bee
    [2] => elk
    [3] => fox
)

ඔබ අරාව පෝලිමක් ලෙස භාවිතා කරන්නේ නම් සහ අහඹු ලෙස ප්‍රවේශ වීමට ඉඩ දෙන අතරම පෝලිමේ ඇති අයිතම ඉවත් කිරීමට අවශ්‍ය නම් මෙය ප්‍රයෝජනවත් වේ. අරාවකින් පළමු හෝ අවසාන අංගය ආරක්ෂිතව ඉවත් කිරීමට , පිළිවෙලින් array_shift () සහ array_pop () භාවිතා කරන්න .

ඔබට පහත දැක්වෙන අරාව ඇතැයි සිතමු:

Array
(
    [user_id] => 193
    [storage] => 5
)

මකා දැමීමට storage, කරන්න:

unset($attributes['storage']);
$attributes = array_filter($attributes);

ඔබට ලැබෙන්නේ:

Array
(
    [user_id] => 193
)

විචල්‍ය ගුණාංග සහිත විශේෂිත වස්තුවක් මා සතුව ඇති බව පැවසීමට මම කැමතියි (එය මූලික වශයෙන් වගුවක් සිතියම් ගත කිරීම සහ මම වගුවේ තීරු වෙනස් කරමින් සිටියෙමි, එබැවින් වස්තුවෙහි ගුණාංග, වගුව පිළිබිඹු කිරීම ද වෙනස් වේ):

class obj {
    protected $fields = array('field1','field2');
    protected $field1 = array();
    protected $field2 = array();
    protected loadfields(){}
    // This will load the $field1 and $field2 with rows of data for the column they describe
    protected function clearFields($num){
        foreach($fields as $field) {
            unset($this->$field[$num]);
            // This did not work the line below worked
            unset($this->{$field}[$num]); // You have to resolve $field first using {}
        }
    }
}

එහි සම්පූර්ණ අරමුණ $fieldsසාධාරණයි, එබැවින් ඒවා වෙනස් වූ විට කේතයේ සෑම තැනකම බැලීමට මට අවශ්‍ය නැත, මම පන්තියේ ආරම්භය දෙස බලා ගුණාංග ලැයිස්තුව සහ $ ක්ෂේත්‍ර අරාව අන්තර්ගතය නව පිළිබිඹු කිරීම සඳහා වෙනස් කරමි. ගුණාංග.

පෙරනිමි කාර්යයන් අනුගමනය කරන්න:

මම)

$Array = array("test1", "test2", "test3", "test3");

unset($Array[2]);

ii)

$Array = array("test1", "test2", "test3", "test3");

array_pop($Array);

iii)

$Array = array("test1", "test2", "test3", "test3");

array_splice($Array,1,2);

iv)

$Array = array("test1", "test2", "test3", "test3");

array_shift($Array);

<?php
    $array = array("your array");
    $array = array_diff($array, ["element you want to delete"]);
?>

විචල්‍යය තුළ ඔබේ අරාව සාදන්න $array, ඉන්පසු මම 'මකා දැමීමට අවශ්‍ය අංගය' දමා ඇති තැන ඔබ "a" වැනි දෙයක් දමයි. ඔබට බහු අයිතම මකා දැමීමට අවශ්‍ය නම්: "a", "b".

යතුර ලබා ගැනීමට array_search භාවිතා කර සොයාගත නොහැකි නම් එය ඉවත් කරන්න:

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

අරාවකින් බහු, කැබලි කරන ලද මූලද්‍රව්‍ය සකසන්න

අතර unset()මෙහි සඳහන් කර කිහිප වතාවක් ඇත, එය බව සඳහන් කළ මෙතෙක් unset()එක් ක්රියාත්මක මාලාවක් සිට delete බහු, noncontiguous අංග පහසුවෙන් එය කරමින් බහු විචල්ය පිළිගන්නා:

// Delete multiple, noncontiguous elements from an array
$array = [ 'foo', 'bar', 'baz', 'quz' ];
unset( $array[2], $array[3] );
print_r($array);
// Output: [ 'foo', 'bar' ]

setet () ගතිකව

unset () ඉවත් කිරීම සඳහා යතුරු සමූහයක් භාර නොගනී, එබැවින් පහත කේතය අසාර්ථක වනු ඇත (එය ගතිකව වුවද setet () භාවිතා කිරීම තරමක් පහසු කරවනු ඇත).

$array = range(0,5);
$remove = [1,2];
$array = unset( $remove ); // FAILS: "unexpected 'unset'"
print_r($array);

ඒ වෙනුවට, පෙරනිමි පුඩුවක් තුළ සැකසූ () ගතිකව භාවිතා කළ හැකිය:

$array = range(0,5);
$remove = [1,2];
foreach ($remove as $k=>$v) {
    unset($array[$v]);
}
print_r($array);
// Output: [ 0, 3, 4, 5 ]

අරාව පිටපත් කිරීමෙන් අරාව යතුරු ඉවත් කරන්න

තවම සඳහන් කළ යුතු තවත් භාවිතයක් තිබේ. සමහර විට, සමහර අරාව යතුරු ඉවත් කිරීමට ඇති සරලම ක්‍රමය නම් $ array1 $ $ array2 වෙත පිටපත් කිරීමයි.

$array1 = range(1,10);
foreach ($array1 as $v) {
    // Remove all even integers from the array
    if( $v % 2 ) {
        $array2[] = $v;
    }
}
print_r($array2);
// Output: [ 1, 3, 5, 7, 9 ];

නිසැකවම, එකම පුරුද්ද පෙළ නූල් සඳහා ද අදාළ වේ:

$array1 = [ 'foo', '_bar', 'baz' ];
foreach ($array1 as $v) {
    // Remove all strings beginning with underscore
    if( strpos($v,'_')===false ) {
        $array2[] = $v;
    }
}
print_r($array2);
// Output: [ 'foo', 'baz' ]

යතුරක් මත පදනම්ව අරාව අංගයක් ඉවත් කරන්න:

unsetපහත පරිදි ශ්‍රිතය භාවිතා කරන්න :

$a = array(
       'salam',
       '10',
       1
);

unset($a[1]);

print_r($a);

/*

    Output:

        Array
        (
            [0] => salam
            [2] => 1
        )

*/

අගය මත පදනම්ව අරාව අංගයක් ඉවත් කරන්න:

array_searchමූලද්රව්ය යතුරක් ලබා ගැනීම සඳහා ශ්රිතය භාවිතා කරන්න සහ පහත දැක්වෙන පරිදි අරාව මූලද්රව්යයක් ඉවත් කිරීමට ඉහත ක්‍රමය භාවිතා කරන්න:

$a = array(
       'salam',
       '10',
       1
);

$key = array_search(10, $a);

if ($key !== false) {
    unset($a[$key]);
}

print_r($a);

/*

    Output:

        Array
        (
            [0] => salam
            [2] => 1
        )

*/

අරාවෙහි පළමු අයිතමය දර්ශකයේ අනුපිළිවෙලින් ඉවත් කිරීම සඳහා ක්‍රම දෙකක් සහ පළමු අයිතමයේ ප්‍රධාන නම ඔබ නොදන්නේ නම්.

විසඳුම # 1

// 1 is the index of the first object to get
// NULL to get everything until the end
// true to preserve keys
$array = array_slice($array, 1, null, true);

විසඳුම # 2

// Rewinds the array's internal pointer to the first element
// and returns the value of the first array element.
$value = reset($array);
// Returns the index element of the current array position
$key = key($array);
unset($array[$key]);

මෙම නියැදි දත්ත සඳහා:

$array = array(10 => "a", 20 => "b", 30 => "c");

ඔබට මෙම ප්‍රති result ලය තිබිය යුතුය:

array(2) {
  [20]=>
  string(1) "b"
  [30]=>
  string(1) "c"
}

පහත කේතය භාවිතා කරන්න:

$arr = array('orange', 'banana', 'apple', 'raspberry');
$result = array_pop($arr);
print_r($result);

<?php
    // If you want to remove a particular array element use this method
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");

    print_r($my_array);
    if (array_key_exists("key1", $my_array)) {
        unset($my_array['key1']);
        print_r($my_array);
    }
    else {
        echo "Key does not exist";
    }
?>

<?php
    //To remove first array element
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
    print_r($my_array);
    $new_array = array_slice($my_array, 1);
    print_r($new_array);
?>


<?php
    echo "<br/>    ";
    // To remove first array element to length
    // starts from first and remove two element
    $my_array = array("key1"=>"value 1", "key2"=>"value 2", "key3"=>"value 3");
    print_r($my_array);
    $new_array = array_slice($my_array, 1, 2);
    print_r($new_array);
?>

ප්‍රතිදානය

 Array ( [key1] => value 1 [key2] => value 2 [key3] =>
 value 3 ) Array (    [key2] => value 2 [key3] => value 3 )
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
 Array ( [key2] => value 2 [key3] => value 3 )
 Array ( [key1] => value 1 [key2] => value 2 [key3] => value 3 )
 Array ( [key2] => value 2 [key3] => value 3 )

පූර්ණ සංඛ්‍යා නොවන යතුරු සහිත සහායක අරා සඳහා:

සරලවම, unset($array[$key])වැඩ කරයි.

පූර්ණ සංඛ්‍යා සහිත අරා සඳහා සහ ඔබේ යතුරු නඩත්තු කිරීමට අවශ්‍ය නම්:

1. $array = [ 'mango', 'red', 'orange', 'grapes'];

   unset($array[2]);
   $array = array_values($array);

2. array_splice($array, 2, 1);

මෙය උදව් විය හැකිය ...

<?php
    $a1 = array("a"=>"red", "b"=>"green", "c"=>"blue", "d"=>"yellow");
    $a2 = array("a"=>"purple", "b"=>"orange");
    array_splice($a1, 0, 2, $a2);
    print_r($a1);
?>

ප්රති result ලය වනු ඇත්තේ:

Array ( [0] => purple [1] => orange [c] => blue [d] => yellow )

$arrayName = array( '1' => 'somevalue',
                    '2' => 'somevalue1',
                    '3' => 'somevalue3',
                  );

print_r($arrayName[1]);
// somevalue
unset($arrayName[1]);

print_r($arrayName);