භාවිතා අතර ඇති වෙනස කුමක්ද මේ deleteක්රියාකරු භාවිතා විරුද්ධ ලෙස අරාව අංගයක් මත මෙම Array.spliceක්රමය ?

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

myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//  or
myArray.splice (1, 1);

වස්තූන් සමඟ මට කළ හැකි අරා මූලද්‍රව්‍ය මකා දැමිය හැකි නම්, ස්ප්ලයිස් ක්‍රමය පවා ඇත්තේ ඇයි?

deleteවස්තු දේපල මකා දමනු ඇත, නමුත් අරාව නැවත සම්බන්ධ කිරීම හෝ එහි දිග යාවත්කාලීන නොකෙරේ. මෙය නිර්වචනය නොකළ ලෙස පෙනේ:

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> delete myArray[0]
  true
> myArray[0]
  undefined

එය ඇත්ත වශයෙන්ම එහි වටිනාකම කට්ටලයක් නොවන බව සටහන undefined, ඒ වෙනුවට දේපල අරාව සිට, එය සිදු ඉවත් කර ඇත පෙනී නිර්වචනය නොකළ. ක්‍රෝම් ඩිව් මෙවලම් emptyඅරාව ලොග් කිරීමේදී මුද්‍රණය කිරීමෙන් මෙම වෙනස පැහැදිලි කරයි .

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

myArray.splice(start, deleteCount) ඇත්ත වශයෙන්ම මූලද්‍රව්‍යය ඉවත් කරයි, අරාව නැවත සම්බන්ධ කරයි, සහ එහි දිග වෙනස් කරයි.

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> myArray.splice(0, 2)
  ["a", "b"]
> myArray
  ["c", "d"]

Array.remove () ක්‍රමය

JQuery හි නිර්මාතෘ ජෝන් රෙසිග් ඉතා පහසු Array.removeක්‍රමයක් නිර්මාණය කළ අතර මම එය සෑම විටම මගේ ව්‍යාපෘතිවල භාවිතා කරමි.

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

එය භාවිතා කළ හැකි ආකාරය පිළිබඳ උදාහරණ කිහිපයක් මෙන්න:

// Remove the second item from the array
array.remove(1);
// Remove the second-to-last item from the array
array.remove(-2);
// Remove the second and third items from the array
array.remove(1,2);
// Remove the last and second-to-last items from the array
array.remove(-2,-1);

ජෝන් ගේ වෙබ් අඩවිය

මකාදැමීම අරාවෙහි ඇති මූලද්‍රව්‍යයෙන් වස්තුව පමණක් ඉවත් කරන බැවින්, අරාවේ දිග වෙනස් නොවේ. ස්ප්ලයිස් වස්තුව ඉවත් කර අරාව කෙටි කරයි.

පහත කේතය "a", "b", "නිර්වචනය නොකළ", "d" පෙන්වයි

myArray = ['a', 'b', 'c', 'd']; delete myArray[2];

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

මෙය "a", "b", "d" පෙන්වනු ඇත

myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

මූලද්‍රව්‍යයක සෑම සිදුවීමක්ම අරාවකින් ඉවත් කරන්නේ කෙසේද යන්න තේරුම් ගැනීමට උත්සාහ කරන අතරතුර මම මෙම ප්‍රශ්නයට බාධා කළෙමි. මෙන්න අරාව වෙතින් සෑම දෙයක්ම ඉවත් කිරීම spliceහා සංසන්දනය කිරීමකි .delete'c'items

var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  items.splice(items.indexOf('c'), 1);
}

console.log(items); // ["a", "b", "d", "a", "b", "d"]

items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  delete items[items.indexOf('c')];
}

console.log(items); // ["a", "b", undefined, "d", "a", "b", undefined, "d"]
​

සිට Core JavaScript 1.5 විමර්ශන> මෙහෙයුම්කරුවන්> විශේෂ මෙහෙයුම්කරුවන්> delete ක්රියාකරු :

ඔබ අරාව අංගයක් මකා දැමූ විට, අරාවෙහි දිග බලපාන්නේ නැත. උදාහරණයක් ලෙස, ඔබ [3] මකා දැමුවහොත්, [4] තවමත් [4] වන අතර [3] නිර්වචනය කර නොමැත. ඔබ අරාවෙහි අවසාන අංගය මකා දැමුවද මෙය සිදු වේ ([a.length-1] මකන්න).

splice සංඛ්‍යාත්මක දර්ශක සමඟ ක්‍රියා කරයි.

deleteවෙනත් ආකාරයේ දර්ශක වලට එරෙහිව භාවිතා කළ හැකි නමුත් ..

උදාහරණයක්:

delete myArray['text1'];

භේදය ක්‍රියා කරන්නේ අරා මත පමණක් බව සඳහන් කිරීම වටී. (ස්ථාවර අනුපිළිවෙලක් අනුගමනය කිරීම සඳහා වස්තු ගුණාංග මත විශ්වාසය තැබිය නොහැක.)

වස්තුවකින් යතුරු අගය යුගලය ඉවත් කිරීමට, මකාදැමීම ඇත්ත වශයෙන්ම ඔබට අවශ්‍ය දේ:

delete myObj.propName;     // , or:
delete myObj["propName"];  // Equivalent.

Vs භේදය මකන්න

ඔබ අරාවකින් අයිතමයක් මකා දැමූ විට

var arr = [1,2,3,4]; delete arr[2]; //result [1, 2, 3:, 4]
console.log(arr)

ඔබ බෙදී යන විට

var arr = [1,2,3,4]; arr.splice(1,1); //result [1, 3, 4]
console.log(arr);

වූ අවස්ථාවක delete යන අංගයක් මකා නමුත් දර්ශකය හිස් පවතී

වූ අවස්ථාවක අතර පිරිද්දුමෙන් අංගයක් මකා සහ ඉතිරි අංග දර්ශකය අනුව අඩු වේ

ඉහත සඳහන් කළ පරිදි, භාවිතා splice()කිරීම පරිපූර්ණ සුදුසුකමක් සේ පෙනේ. මොසිල්ලා හි ලේඛනගත කිරීම:

splice()පවත්නා මූලද්‍රව්‍ය ඉවත් කිරීමෙන් සහ / හෝ නව මූලද්‍රව්‍ය එකතු කිරීමෙන් මෙම ක්‍රමය අරාවෙහි අන්තර්ගතය වෙනස් කරයි.

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

සින්ටැක්ස්

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

පරාමිතීන්

ආරම්භ කරන්න

අරාව වෙනස් කිරීම ආරම්භ කළ යුතු දර්ශකය. අරාවේ දිගට වඩා වැඩි නම්, සත්‍ය ආරම්භක දර්ශකය අරාවේ දිගට සකසනු ඇත. Negative ණ නම්, බොහෝ මූලද්‍රව්‍යයන් අවසානයේ සිට ආරම්භ වේ.

deleteCount

ඉවත් කිරීමට පැරණි අරා මූලද්‍රව්‍ය ගණන දැක්වෙන පූර්ණ සංඛ්‍යාවක්. DeleteCount 0 නම්, කිසිදු මූලද්‍රව්‍යයක් ඉවත් නොකෙරේ. මෙම අවස්ථාවේදී, ඔබ අවම වශයෙන් එක් නව අංගයක්වත් සඳහන් කළ යුතුය. ආරම්භයේ සිට අරාවෙහි ඉතිරිව ඇති මූලද්‍රව්‍ය ගණනට වඩා මකාදැමීමේ අගය වැඩි නම්, අරාව අවසානයේ ඇති සියලුම මූලද්‍රව්‍ය මකා දැමෙනු ඇත.

DeleteCount මඟ හැරී ඇත්නම්, deleteCount සමාන වේ (arr.length - start).

අයිතමය 1, අයිතමය 2, ...

ආරම්භක දර්ශකයේ සිට අරාවට එකතු කළ යුතු මූලද්‍රව්‍ය. ඔබ කිසිදු අංගයක් සඳහන් නොකරන්නේ නම්,splice() , අරාව වෙතින් මූලද්‍රව්‍ය පමණක් ඉවත් කරයි.

ප්‍රතිලාභ අගය

මකා දැමූ මූලද්‍රව්‍ය අඩංගු අරාව. එක් මූලද්‍රව්‍යයක් පමණක් ඉවත් කළ හොත්, එක් මූලද්‍රව්‍යයක පෙළක් ආපසු ලබා දෙනු ලැබේ. මූලද්රව්ය ඉවත් නොකළහොත් හිස් අරාවක් ආපසු ලබා දෙනු ලැබේ.

[...]

මකාදැමීම සැබෑ ලෝක නොවන තත්වයක් ලෙස ක්‍රියා කරයි, එය අයිතමය ඉවත් කරයි , නමුත් අරාවෙහි දිග එලෙසම පවතී:

උදාහරණ නෝඩ් පර්යන්තයෙන්:

> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b', , 'd', 'e' ]

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

function(arr,arrIndex){
    return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

ඉහත කාර්යය කරන්නේ සියලුම සාමාජිකයන් දර්ශකය දක්වාත්, දර්ශකයට පසුව ඇති සියලුම සාමාජිකයන්ත් එකට ගෙන ගොස් ඔවුන් එකට එකතු කර ප්‍රති .ලය ලබා දීමයි.

ඉහත ශ්‍රිතය නෝඩ් මොඩියුලයක් ලෙස භාවිතා කරන උදාහරණයක් මෙන්න, ටර්මිනලය දැකීම ප්‍රයෝජනවත් වනු ඇත:

> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ] // c ya later
> newArray.length
3

දර්ශක ඕෆ් ("ඇ") හට පළමු සිදුවීම ලැබෙනු ඇති අතර, එය සොයාගත් පළමු "ඇ" ඉවත් කර ඉවත් කරන්න.

ඔබට විශාල අරාවක් නැවත සැකසීමට සහ තෝරාගත් මූලද්‍රව්‍ය මකා දැමීමට අවශ්‍ය නම්, සෑම මකාදැමීමක් සඳහාම ස්ප්ලයිස් () ඇමතීම මිල අධික වනු ඇත, මන්ද සෑම අවස්ථාවකදීම ස්ප්ලයිස් () පසුකාලීන මූලද්‍රව්‍ය නැවත සුචිගත කළ යුතු බැවිනි. අරා ජාවාස්ක්‍රිප්ට් හි අනුබද්ධ බැවින්, තනි මූලද්‍රව්‍ය මකා දැමීම වඩාත් කාර්යක්ෂම වනු ඇති අතර පසුව අරාව නැවත සුචිගත කරන්න.

නව අරාවක් තැනීමෙන් ඔබට එය කළ හැකිය. උදා

function reindexArray( array )
{
       var result = [];
        for( var key in array )
                result.push( array[key] );
        return result;
};

නමුත් මුල් අරාවෙහි ඇති ප්‍රධාන අගයන් ඔබට වෙනස් කළ හැකි යැයි මම නොසිතමි, එය වඩාත් කාර්යක්ෂම වනු ඇත - ඔබට නව අරාවක් සෑදිය යුතු බව පෙනේ.

“නිර්වචනය නොකළ” ඇතුළත් කිරීම් ඇත්ත වශයෙන්ම නොපවතින බැවින් සහ ලූප සඳහා ඒවා ආපසු නොදෙන බැවින් ඔබ ඒවා පරීක්ෂා කිරීමට අවශ්‍ය නොවන බව සලකන්න. එය අරාව මුද්‍රණය කිරීමේ පුරාවස්තුවක් වන අතර ඒවා නිර්වචනය නොකළ ඒවා ලෙස පෙන්වයි. ඒවා මතකයේ පවතින බවක් නොපෙනේ.

ඔබට පෙත්තක් () වැනි දෙයක් ඉක්මණින් භාවිතා කළ හැකි නම් එය හොඳයි, නමුත් එය නැවත සුචිගත නොකරයි. වඩා හොඳ ක්‍රමයක් ගැන කවුරුන් හෝ දන්නවාද?

ඇත්ත වශයෙන්ම, ඔබට එය වඩාත් කාර්යක්ෂම, කාර්ය සාධනය අනුව පහත පරිදි කළ හැකිය:

reindexArray : function( array )
{
    var index = 0;                          // The index where the element should be
    for( var key in array )                 // Iterate the array
    {
        if( parseInt( key ) !== index )     // If the element is out of sequence
        {
            array[index] = array[key];      // Move it to the correct, earlier position in the array
            ++index;                        // Update the index
        }
    }

    array.splice( index );  // Remove any remaining elements (These will be duplicates of earlier items)
},

ඔබට මේ වගේ දෙයක් භාවිතා කළ හැකිය

var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';})); // [1,2,3,4,6]

පෙරණය නොකරන්නේ ඇයි? Js හි අරා සලකා බැලීම වඩාත් පැහැදිලි ක්‍රමය යැයි මම සිතමි.

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

deleteක්රියාකරු සහ splice()ක්රමය යෙදීමෙන් පසු එක් එක් අරාවෙහි දිග සටහන් කිරීමෙන් වෙනස දැකිය හැකිය . උදාහරණයක් වශයෙන්:

ක්‍රියාකරු මකන්න

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

මෙම deleteක්රියාකරු අරාව සිට අංගයක් ඉවත් නමුත් අංගයක් වන "තැන් දරණුව" තවමත් පවතී.oakඉවත් කර ඇති නමුත් එය තවමත් අරාවෙහි ඉඩ ලබා ගනී. මේ නිසා, අරාවෙහි දිග 5 ක් ලෙස පවතී.

splice () ක්‍රමය

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

මෙම splice()ක්‍රමය මඟින් ඉලක්කගත අගය සහ “ස්ථාන දරන්නා” සම්පූර්ණයෙන්ම ඉවත් කරයි . oakඉවත් කර ඇති අතර එය අරාවෙහි වාසය කිරීමට භාවිතා කළ අවකාශය ද ඉවත් කර ඇත. අරාවෙහි දිග දැන් 4 කි.

අනෙක් අය දැනටමත් නිසි ලෙස සසඳා deleteඇත splice.

තවත් සිත්ගන්නාසුලු සංසන්දනයක් deleteඑදිරිව ය undefined: මකා දැමූ අරා අයිතමයක් දැන් සකසා ඇති මතකයට වඩා අඩු මතකයක් භාවිතා කරයිundefined ;

උදාහරණයක් ලෙස, මෙම කේතය අවසන් නොවේ:

let y = 1;
let ary = [];
console.log("Fatal Error Coming Soon");
while (y < 4294967295)
{
    ary.push(y);
    ary[y] = undefined;
    y += 1;
}
console(ary.length);

එය මෙම දෝෂය ඇති කරයි:

FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory.

ඉතින්, ඔබට පෙනෙන පරිදි undefinedඇත්ත වශයෙන්ම ගොඩවල් මතකය ගනී.

කෙසේ වෙතත්, ඔබ ද deleteඅරි-අයිතමය නම් (එය සැකසීම වෙනුවට undefined), කේතය සෙමෙන් අවසන් වේ:

let x = 1;
let ary = [];
console.log("This will take a while, but it will eventually finish successfully.");
while (x < 4294967295)
{
    ary.push(x);
    ary[x] = undefined;
    delete ary[x];
    x += 1;
}
console.log(`Success, array-length: ${ary.length}.`);

මේවා ආන්තික උදාහරණ වේ, නමුත් ඔවුන් deleteකිසිවෙකු කොතැනකවත් සඳහන් කර නැති බව ඔවුන් පෙන්වා දෙයි.

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

උදාහරණයක්:

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

කෙසෙල් මකා දමා ඇති අතර අරාව දිග = 2

ඒවා විවිධ අරමුණු ඇති වෙනස් දේවල්.

spliceඅරාව සිට මකා, පලවා හරින ඇතුළත් කිරීම් සඳහා භාවිතා කර ඇති, අරාව-විශේෂිත වන අතර, සහ ද පරතරය දක්වා පියවර, මීට පෙර සටහන් ඇතුළත් කිරීම්. (එය ඇතුළත් කිරීම් ඇතුළු කිරීමට හෝ දෙකම එකවර භාවිතා කළ හැකිය.) අරාව spliceවෙනස් lengthකිරීම (එය විවෘත ඇමතුමක් නොවන බව උපකල්පනය කරයි :) theArray.splice(x, 0).

deleteඅරාව-විශේෂිත නොවේ; එය නිර්මාණය කර ඇත්තේ වස්තූන් සඳහා භාවිතා කිරීම සඳහා ය: එය ඔබ භාවිතා කරන වස්තුවෙන් දේපලක් (යතුර / අගය යුගලයක්) ඉවත් කරයි. එය අරා වලට පමණක් අදාළ වන්නේ ජාවාස්ක්‍රිප්ට් හි සම්මත (උදා: ටයිප් නොකළ) අරා සැබවින්ම අරා නොවන නිසාය *, ඒවා “අරා දර්ශක” (එනම් වචන නාම ලෙස අර්ථ දක්වා ඇත "... ඒවායේ සංඛ්‍යාත්මක අගය iපරාසයේ ඇත +0 ≤ i < 2^32-1") සහ length. ඔබ deleteඅරාව ඇතුළත් කිරීමක් ඉවත් කිරීමට භාවිතා කරන විට , එය කරන්නේ ප්‍රවේශය ඉවත් කිරීම පමණි; එය පරතරය පිරවීම සඳහා එය අනුගමනය කරන වෙනත් ඇතුළත් කිරීම් ගෙන නොයනු ඇත, එබැවින් අරාව "විරල" බවට පත්වේ (සමහර ප්‍රවේශයන් මුළුමනින්ම අස්ථානගත වී ඇත). එය කිසිදු බලපෑමක් නැතlength .

මෙම ප්‍රශ්නයට වර්තමාන පිළිතුරු කිහිපයක් වැරදියට සඳහන් කරන්නේ භාවිතා කිරීම delete“ප්‍රවේශය සකසයි undefined” යන්නයි. එය නිවැරදි නොවේ. එය ඉවත් කරයි පරතරය පිටත්, මුලුමනින් ම ප්රවේශය (දේපල).

වෙනස්කම් නිදර්ශනය කිරීම සඳහා අපි යම් කේතයක් භාවිතා කරමු:

console.log("Using `splice`:");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a.splice(0, 1);
console.log(a.length);            // 4
console.log(a[0]);                // "b"

console.log("Using `delete`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
delete a[0];
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // false
console.log(a.hasOwnProperty(0)); // false

console.log("Setting to `undefined`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a[0] = undefined;
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // true
console.log(a.hasOwnProperty(0)); // true

* (එය මගේ රක්තහීනතා කුඩා බ්ලොග් අඩවියේ සටහනකි)

දැනට මෙය කිරීමට ක්‍රම දෙකක් තිබේ

1. භේදය භාවිතා කරමින් ()

   arrayObject.splice(index, 1);

2. මකන්න භාවිතා කරයි

   delete arrayObject[index];

නමුත් මම නිතරම යෝජනා කරන්නේ අරාව වස්තු සඳහා ස්ප්ලයිස් භාවිතා කිරීමට සහ වස්තු ගුණාංග සඳහා මකා දැමීමට මකාදැමීම අරාව දිග යාවත්කාලීන නොකරන බැවිනි.

හරි, සිතන්න අපට මෙම අරාව පහතින් ඇත:

const arr = [1, 2, 3, 4, 5];

පළමුව මකා දමමු:

delete arr[1];

ප්‍රති result ලය මෙයයි:

[1, empty, 3, 4, 5];

හිස්! අපි එය ලබා ගනිමු:

arr[1]; //undefined

ඒ කියන්නේ වටිනාකම මකා දැමූ අතර එය දැන් නිර්වචනය කර නැත , එබැවින් දිග සමාන වේ, එසේම එය සත්‍ය වනු ඇත ...

අපි දැන් අපගේ අරාව නැවත සකස් කර එය දෙවරක් බෙදීමෙන් කරමු:

arr.splice(1, 1);

මෙවර එහි ප්‍රති result ලය මෙයයි:

[1, 3, 4, 5];

ඔබ දකින පරිදි අරාවෙහි දිග වෙනස් arr[1]වී 3 කි දැන් ...

එසේම මෙය මකාදැමූ අයිතමය අරාවෙහි නැවත ලබා දෙනු ඇත [3].

ඔබට කුඩා අරා තිබේ නම් ඔබට භාවිතා කළ හැකිය filter:

myArray = ['a', 'b', 'c', 'd'];
myArray = myArray.filter(x => x !== 'b');

පහසුම ක්‍රමය බොහෝ විට විය හැකිය

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

මෙය උපකාරී වේ යැයි සිතමි. යොමුව: https://lodash.com/docs#compact

ලොඩාෂ් භාවිතා කිරීමට කැමති අයට භාවිතා කළ හැකිය: myArray = _.without(myArray, itemToRemove)

නැත්නම් මම Angular2 හි භාවිතා කරන පරිදි

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

මකන්න : මකන්න වස්තු දේපල මකා දමනු ඇත, නමුත් අරාව නැවත සම්බන්ධ කිරීම හෝ එහි දිග යාවත්කාලීන නොකෙරේ. මෙය නිර්වචනය නොකළ ලෙස පෙනේ:

splice : ඇත්ත වශයෙන්ම මූලද්‍රව්‍යය ඉවත් කරයි, අරාව නැවත සම්බන්ධ කරයි, සහ එහි දිග වෙනස් කරයි.

අංගය අන්තිමට මකන්න

arrName.pop();

මුල සිට මූලද්‍රව්‍යය මකන්න

arrName.shift();

මැද සිට මකන්න

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

අන්තිමයෙන් එක් අංගයක් මකන්න

arrName.splice(-1);

අරාව දර්ශක අංකය භාවිතා කර මකන්න

 delete arrName[1];

මකා දැමීමට අපේක්ෂිත මූලද්‍රව්‍යය මැද නම් (එහි දර්ශකය 1 වන 'c' මකා දැමීමට අපට අවශ්‍ය යැයි කියන්න), ඔබට මෙය භාවිතා කළ හැකිය:

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

IndexOfයොමු වර්ගයක් ද පිළිගනී. පහත දැක්වෙන තත්වය යැයි සිතමු:

var arr = [{item: 1}, {item: 2}, {item: 3}];
var found = find(2, 3); //pseudo code: will return [{item: 2}, {item:3}]
var l = found.length;

while(l--) {
   var index = arr.indexOf(found[l])
      arr.splice(index, 1);
   }
   
console.log(arr.length); //1

වෙනස් ලෙස:

var item2 = findUnique(2); //will return {item: 2}
var l = arr.length;
var found = false;
  while(!found && l--) {
  found = arr[l] === item2;
}

console.log(l, arr[l]);// l is index, arr[l] is the item you look for

කාර්ය සාධනය

ක්‍රියාකාරී වෙනස්කම් පිළිබඳව දැනටමත් හොඳ පිළිතුරක් තිබේ - එබැවින් මෙහි මට කාර්ය සාධනය කෙරෙහි අවධානය යොමු කිරීමට අවශ්‍යය. අද (2020.06.25) මම ක්‍රෝම් 83.0, සෆාරි 13.1 සහ ෆයර්ෆොක්ස් 77.0 සඳහා පරීක්ෂණ සිදු කරමි.

නිගමන

• එම splice (B) විසඳුමක් කුඩා හා මහ පෙලගැස්මක් සඳහා ඉතා ඉක්මනින්
• එම delete (A) විසඳුමක් කුඩා පෙලගැස්මක් සඳහා විශාල හා මධ්ය වේගයෙන් සඳහා වේගවත්ම
• එම filter (ඊ) විසඳුමක් කුඩා පෙලගැස්මක් සඳහා Chrome සහ Firefox මත වේගවත්ම (සෆාරි නොව වඩාත්ම මන්දගාමී වේ, හා මහ පෙලගැස්මක් සඳහා මන්දගාමී)
• D විසඳුම තරමක් මන්දගාමී ය
• විසඳුම C ක්‍රෝම් සහ සෆාරි හි විශාල අරා සඳහා ක්‍රියා නොකරයි

  කේත ස්නිපටය පෙන්වන්න

  function C(arr, idx) {
    var rest = arr.slice(idx + 1 || arr.length);
    arr.length = idx < 0 ? arr.length + idx : idx;
    arr.push.apply(arr, rest);
    return arr;
  }
  
  
  // Crash test
  
  let arr = [...'abcdefghij'.repeat(100000)]; // 1M elements
  
  try {
   C(arr,1)
  } catch(e) {console.error(e.message)}

  කේත ස්නිපටය ධාවනය කරන්නප්‍රති .ල සඟවන්න

  ස්නිපටය පුළුල් කරන්න

විස්තර

විසඳුම් සඳහා මම පහත පරීක්ෂණ සිදු කරමි A B C D E (my)

• කුඩා අරා (4 අංග) සඳහා - ඔබ අත්හදා හැකි මෙතනයි
• විශාල පරාසයක (1m අංග) සඳහා - ඔබ අත්හදා හැකි මෙතනයි

function A(arr, idx) {
  delete arr[idx];
  return arr;
}

function B(arr, idx) {
  arr.splice(idx,1);
  return arr;
}

function C(arr, idx) {
  var rest = arr.slice(idx + 1 || arr.length);
  arr.length = idx < 0 ? arr.length + idx : idx;
  arr.push.apply(arr, rest);
  return arr;
}

function D(arr,idx){
    return arr.slice(0,idx).concat(arr.slice(idx + 1));
}

function E(arr,idx) {
  return arr.filter((a,i) => i !== idx);
}

myArray = ['a', 'b', 'c', 'd'];

[A,B,C,D,E].map(f => console.log(`${f.name} ${JSON.stringify(f([...myArray],1))}`));

This snippet only presents used solutions

Chrome සඳහා උදාහරණ ප්‍රති results ල

function deleteFromArray(array, indexToDelete){
  var remain = new Array();
  for(var i in array){
    if(array[i] == indexToDelete){
      continue;
    }
    remain.push(array[i]);
  }
  return remain;
}

myArray = ['a', 'b', 'c', 'd'];
deleteFromArray(myArray , 0);

// ප්‍රති result ලය: myArray = ['b', 'c', 'd'];