මම ජාවාස්ක්‍රිප්ට් අරා ඇතුළු කිරීමේ ක්‍රමයක් සොයමින් සිටිමි.

arr.insert(index, item)

JQuery හි වඩාත් සුදුසු, නමුත් ඕනෑම ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමක් මෙම අවස්ථාවෙහිදී සිදු කරනු ඇත.

ඔබට අවශ්‍ය වන්නේ spliceස්වදේශීය අරාව වස්තුවෙහි ක්‍රියාකාරිත්වයයි.

arr.splice(index, 0, item);නිශ්චිත දර්ශකයට ඇතුල් itemකරනු arrඇත ( 0පළමුව අයිතම මකා දැමීම , එනම් එය ඇතුළත් කිරීමක් පමණි).

මෙම උදාහරණයේ දී අපි අරාවක් සාදා එයට දර්ශකයක් 2 දර්ශකයට එකතු කරමු:

var arr = [];
arr[0] = "Jani";
arr[1] = "Hege";
arr[2] = "Stale";
arr[3] = "Kai Jim";
arr[4] = "Borge";

console.log(arr.join());
arr.splice(2, 0, "Lene");
console.log(arr.join());

මෙය කිරීමෙන් ඔබට Array.insertක්‍රමය ක්‍රියාත්මක කළ හැකිය :

Array.prototype.insert = function ( index, item ) {
    this.splice( index, 0, item );
};

එවිට ඔබට එය භාවිතා කළ හැකිය:

var arr = [ 'A', 'B', 'D', 'E' ];
arr.insert(2, 'C');

// => arr == [ 'A', 'B', 'C', 'D', 'E' ]

භේදය හැරුණු විට, ඔබට මෙම ප්‍රවේශය භාවිතා කළ හැකි අතර එය මුල් අරාව විකෘති නොකරනු ඇත, නමුත් එකතු කළ අයිතමය සමඟ නව අරාවක් නිර්මාණය කරයි. ඔබ සාමාන්‍යයෙන් හැකි සෑම විටම විකෘතියෙන් වැළකී සිටිය යුතුය. මම මෙහි ES6 පැතිරුම් ක්‍රියාකරු භාවිතා කරමි.

const items = [1, 2, 3, 4, 5]

const insert = (arr, index, newItem) => [
  // part of the array before the specified index
  ...arr.slice(0, index),
  // inserted item
  newItem,
  // part of the array after the specified index
  ...arr.slice(index)
]

const result = insert(items, 1, 10)

console.log(result)
// [1, 10, 2, 3, 4, 5]

නව අයිතම සඳහා ඉතිරි ක්‍රියාකරු භාවිතා කිරීම සඳහා ශ්‍රිතය මඳක් tweak කිරීමෙන් එක් අයිතමයකට වඩා එකතු කිරීමට මෙය භාවිතා කළ හැකි අතර, ලැබෙන ප්‍රති result ලයේදී ද එය පැතිරෙන්න

const items = [1, 2, 3, 4, 5]

const insert = (arr, index, ...newItems) => [
  // part of the array before the specified index
  ...arr.slice(0, index),
  // inserted items
  ...newItems,
  // part of the array after the specified index
  ...arr.slice(index)
]

const result = insert(items, 1, 10, 20)

console.log(result)
// [1, 10, 20, 2, 3, 4, 5]

අභිරුචි අරාව insertක්‍රම

1. බහුවිධ තර්ක සහ දම්වැල් ආධාරයෙන්

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
    this.splice.apply(this, [index, 0].concat(
        Array.prototype.slice.call(arguments, 1)));
    return this;
};

එයට බහු මූලද්‍රව්‍ය ඇතුළත් කළ හැකිය (ස්වදේශිකයන් spliceමෙන්) සහ දම්වැල සඳහා සහාය වේ:

["a", "b", "c", "d"].insert(2, "X", "Y", "Z").slice(1, 6);
// ["b", "X", "Y", "Z", "c"]

2. අරාව-වර්ගයේ තර්ක සමඟ ඒකාබද්ධ කිරීම සහ දම්වැල් ආධාරක

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
    index = Math.min(index, this.length);
    arguments.length > 1
        && this.splice.apply(this, [index, 0].concat([].pop.call(arguments)))
        && this.insert.apply(this, arguments);
    return this;
};

එය ලබා දී ඇති අරාව සමඟ තර්ක වලින් අරා ඒකාබද්ධ කළ හැකි අතර දම්වැල ද සහාය වේ:

["a", "b", "c", "d"].insert(2, "V", ["W", "X", "Y"], "Z").join("-");
// "a-b-V-W-X-Y-Z-c-d"

ඩෙමෝ: http://jsfiddle.net/UPphH/

ඔබට එකවර මූලද්‍රව්‍ය කිහිපයක් අරාවකට ඇතුල් කිරීමට අවශ්‍ය නම් මෙම සිරස් පිටාර ගැලීමේ පිළිතුර බලන්න: ජාවාස්ක්‍රිප්ට් හි අරාවකට අරාව බෙදීමට වඩා හොඳ ක්‍රමයක්

උදාහරණ දෙකම නිදර්ශනය කිරීම සඳහා සමහර කාර්යයන් මෙහි දැක්වේ:

function insertAt(array, index) {
    var arrayToInsert = Array.prototype.splice.apply(arguments, [2]);
    return insertArrayAt(array, index, arrayToInsert);
}

function insertArrayAt(array, index, arrayToInsert) {
    Array.prototype.splice.apply(array, [index, 0].concat(arrayToInsert));
    return array;
}

අවසාන වශයෙන් මෙන්න jsFiddle, එවිට ඔබට එය ඔබටම දැක ගත හැකිය: http://jsfiddle.net/luisperezphd/Wc8aS/

ඔබ ශ්‍රිත භාවිතා කරන ආකාරය මෙයයි:

// if you want to insert specific values whether constants or variables:
insertAt(arr, 1, "x", "y", "z");

// OR if you have an array:
var arrToInsert = ["x", "y", "z"];
insertArrayAt(arr, 1, arrToInsert);

නිසි ක්‍රියාකාරී වැඩසටහන් සහ දම්වැල් අරමුණු සඳහා නව නිපැයුමක් Array.prototype.insert()අත්‍යවශ්‍ය වේ. මුළුමනින්ම අර්ථ විරහිත හිස් අරාවක් වෙනුවට විකෘති වූ අරාව ආපසු ලබා දුන්නේ නම් සැබවින්ම භේදය පරිපූර්ණ විය හැකිය. ඉතින් මෙන්න ඒක යනවා

Array.prototype.insert = function(i,...rest){
  this.splice(i,0,...rest)
  return this
}

var a = [3,4,8,9];
document.write("<pre>" + JSON.stringify(a.insert(2,5,6,7)) + "</pre>");

හොඳයි, ඉහත Array.prototype.splice()එක සමඟ මුල් අරාව විකෘති කරන අතර සමහරු "ඔබට අයිති නැති දේ ඔබ වෙනස් නොකළ යුතුය" වැනි පැමිණිලි කළ හැකි අතර එයද නිවැරදි විය හැකිය. එබැවින් මහජන සුභසාධනය Array.prototype.insert()සඳහා මුල් අරාව විකෘති නොකරන තවත් එකක් දීමට මම කැමතියි . මෙන්න එය යයි;

Array.prototype.insert = function(i,...rest){
  return this.slice(0,i).concat(rest,this.slice(i));
}

var a = [3,4,8,9],
    b = a.insert(2,5,6,7);
console.log(JSON.stringify(a));
console.log(JSON.stringify(b));

මෙම අවස්ථාවේ දී පිරිසිදු ජාවාස්ක්‍රිප්ට් භාවිතා කිරීමට මම නිර්දේශ කරමි, ජාවාස්ක්‍රිප්ට් තුළ ඇතුළු කිරීමේ ක්‍රමයක් නොමැත, නමුත් අපට ක්‍රමයක් ඇත , එය ඔබ වෙනුවෙන් කාර්යය කරන බිල්ට් අරා ක්‍රමයක් වන අතර එය ස්ප්ලයිස් ලෙස හැඳින්වේ ...

බෙදීම් () යනු කුමක්දැයි බලමු ...

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

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

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

අපට මේ ආකාරයෙන් ඉවත් කළ හැකිය 3:

arr.splice(arr.indexOf(3), 1);

එය 3 ක් ආපසු එනු ඇත, නමුත් අපි දැන් අරාව පරීක්ෂා කළහොත්, අපට ඇත්තේ:

[1, 2, 4, 5]

මෙතෙක්, එතරම් හොඳයි, නමුත් අපි ස්ප්ලයිස් භාවිතා කර අරාව සඳහා නව අංගයක් එකතු කරන්නේ කෙසේද? අපි ආපහු 3 ක් ආරුක්කුවේ තබමු ...

arr.splice(2, 0, 3);

අපි බලමු අපි කරපු දේ ...

අපි නැවතත් ස්ප්ලයිස් භාවිතා කරමු , නමුත් මේ වතාවේ දෙවන තර්කය සඳහා අපි 0 සමත් වෙමු , එයින් අදහස් කරන්නේ අපට කිසිදු අයිතමයක් මකා දැමීමට අවශ්‍ය නොවන බවයි, නමුත් ඒ සමඟම අපි තුන්වන තර්කය එකතු කරන අතර එය 3 වන දෙවන දර්ශකයට එකතු වේ ...

ඔබට දැනුවත්ව සිටිය යුතුය, අපට එකවර මකා දැමිය හැකි අතර එකතු කළ හැකිය , උදාහරණයක් ලෙස දැන් අපට කළ හැක්කේ:

arr.splice(2, 2, 3);

එමඟින් දර්ශක 2 හි අයිතම 2 ක් මකා දමනු ඇත , ඉන්පසු දර්ශක 2 හි 3 එකතු කර ප්‍රති result ලය වනුයේ:

[1, 2, 3, 5];

භේදයේ සෑම අයිතමයක්ම ක්‍රියා කරන ආකාරය මෙයින් පෙන්නුම් කෙරේ:

array.splice (ආරම්භය, මකාදැමීම, අයිතමය 1, අයිතමය 2, අයිතමය 3 ...)

නිශ්චිත දර්ශකයක තනි මූලද්‍රව්‍යය එකතු කරන්න

//Append at specific position(here at index 1)
arrName.splice(1, 0,'newName1');
//1: index number, 0: number of element to remove, newName1: new element


//Append at specific position (here at index 3)
arrName[3] = 'newName1';

විශේෂිත දර්ශකයක බහු මූලද්‍රව්‍ය එකතු කරන්න

//Append from index number 1
arrName.splice(1, 0,'newElemenet1', 'newElemenet2', 'newElemenet3');
//1: index number from where append start, 
//0: number of element to remove, 
//newElemenet1,2,3: new elements

භාවිතා කළ හැකි තවත් විසඳුමක් Array#reduce.

var arr = ["apple", "orange", "raspberry"],
    arr2 = [1, 2, 4];

function insert(arr, item, index) {
    arr = arr.reduce(function(s, a, i) {
      i == index ? s.push(item, a) : s.push(a);
      return s;
    }, []);   
    console.log(arr);
}

insert(arr, "banana", 1);
insert(arr2, 3, 2);

මෙන්න ක්‍රම දෙකක්:

const array = [ 'My', 'name', 'Hamza' ];

array.splice(2, 0, 'is');

console.log("Method 1 : ", array.join(" "));

හෝ

Array.prototype.insert = function ( index, item ) {
    this.splice( index, 0, item );
};

const array = [ 'My', 'name', 'Hamza' ];
array.insert(2, 'is');

console.log("Method 2 : ", array.join(" "));

මේ සඳහා දැනටමත් පිළිතුරු ලබා දී ඇතත්, විකල්ප ප්‍රවේශයක් සඳහා මම මෙම සටහන එකතු කරමි.

නිර්වචනය අනුව වර්ග කළ අනුපිළිවෙලකට සහතික නොවන "සහායක අරාව" (එනම් වස්තුවක්) වෙතින් එන බැවින් දන්නා අයිතම ගණනක් අරාවකට, නිශ්චිත ස්ථානවලට තැබීමට මට අවශ්‍ය විය . මට අවශ්‍ය වූයේ එහි ප්‍රති ar ලයක් ලෙස ඇති අරාව වස්තු සමූහයක් වීමයි, නමුත් අරාව ඔවුන්ගේ අනුපිළිවෙල සහතික කරන බැවින් අරාවෙහි නිශ්චිත අනුපිළිවෙලකට තිබිය යුතුය. ඉතින් මම මේක කළා.

පළමුව ප්‍රභව වස්තුව, PostgreSQL වෙතින් ලබාගත් JSONB නූලක්. සෑම ළමා වස්තුවකම “ඇණවුම්” දේපල අනුව එය වර්ග කිරීමට මට අවශ්‍ය විය.

var jsonb_str = '{"one": {"abbr": "", "order": 3}, "two": {"abbr": "", "order": 4}, "three": {"abbr": "", "order": 5}, "initialize": {"abbr": "init", "order": 1}, "start": {"abbr": "", "order": 2}}';

var jsonb_obj = JSON.parse(jsonb_str);

වස්තුවෙහි ඇති නෝඩ් ගණන දන්නා බැවින්, මම පළමුව නිශ්චිත දිග සමඟ අරාවක් සාදමි:

var obj_length = Object.keys(jsonb_obj).length;
var sorted_array = new Array(obj_length);

ඉන්පසු කිසිදු “වර්ග කිරීමක්” සිදු නොවී, අලුතින් සාදන ලද තාවකාලික වස්තූන් අරාවෙහි අපේක්ෂිත ස්ථානවලට තැබීම.

for (var key of Object.keys(jsonb_obj)) {
  var tobj = {};
  tobj[key] = jsonb_obj[key].abbr;

  var position = jsonb_obj[key].order - 1;
  sorted_array[position] = tobj;
}

console.dir(sorted_array);

ඕනෑම කෙනෙකුට තවමත් මේ සමඟ ගැටළු ඇති අතර ඉහත සියලු විකල්පයන් උත්සාහ කර ඇති අතර එය කිසි විටෙකත් නොලැබුණි. මම මගේ විසඳුම බෙදා ගන්නෙමි, මෙය ඔබේ වස්තුවට එදිරිව එදිරිව ගුණාංග පැහැදිලිව ප්‍රකාශ කිරීමට අවශ්‍ය නොවන බව සැලකිල්ලට ගැනීමයි.

function isIdentical(left, right){
    return JSON.stringify(left) === JSON.stringify(right);
}

function contains(array, obj){
    let count = 0;
    array.map((cur) => {
          if(this.isIdentical(cur, obj)) count++;
    });
    return count > 0;
}

මෙය විමර්ශන අරාව නැවත සැකසීම සහ එය ඔබට පරීක්ෂා කිරීමට අවශ්‍ය වස්තුව සමඟ සංසන්දනය කිරීම, දෙකම නූලක් බවට පරිවර්තනය කිරීම හා එය ගැලපෙන්නේ නම් නැවත සැකසීම. එවිට ඔබට ගණන් කළ හැකිය. මෙය වැඩිදියුණු කළ හැකි නමුත් මා පදිංචි වූයේ මෙහිදීය. මෙය උපකාරී වේ යැයි සිතමි.

අඩු කිරීමේ ක්‍රමයේ ලාභය පහත පරිදි වේ:

function insert(arr, val, index) {
    return index >= arr.length 
        ? arr.concat(val)
        : arr.reduce((prev, x, i) => prev.concat(i === index ? [val, x] : x), []);
}

එබැවින් මේ ආකාරයෙන් අපට දර්ශකයේ ඇතුළත් කර ඇති මූලද්‍රව්‍යය සමඟ නව අරාවක් (සිසිල් ක්‍රියාකාරී ක්‍රමයක් වනු ඇත - තල්ලු හෝ ස්ප්ලයිස් භාවිතා කිරීමට වඩා හොඳය), සහ දර්ශකය අරාවේ දිගට වඩා වැඩි නම් එය ඇතුල් කරනු ලැබේ. අවසානයේදී.

Array#splice()අරාව විකෘති කිරීමෙන් වැළකී සිටීමට ඔබට අවශ්‍ය නම් මිස යා යුතු මාර්ගයයි. 2 පෙලගැස්මක් ලබා arr1හා arr2, ඔබ මෙහි අන්තර්ගතය ඇතුලත් කරනු ආකාරය arr2බවට arr1පළමු අංගය පසුව:

const arr1 = ['a', 'd', 'e'];
const arr2 = ['b', 'c'];

arr1.splice(1, 0, ...arr2); // arr1 now contains ['a', 'b', 'c', 'd', 'e']

console.log(arr1)

අරාව විකෘති කිරීම ගැන ඔබ සැලකිලිමත් වන්නේ නම් (නිදසුනක් ලෙස, Immutable.js භාවිතා කරන්නේ නම්), ඒ වෙනුවට ඔබට භාවිතා කළ හැකිය slice(), splice()a සමඟ පටලවා නොගත යුතුය 'p'.

const arr3 = [...arr1.slice(0, 1), ...arr2, ...arr1.slice(1)];

මම මෙය උත්සාහ කළ අතර එය හොඳින් ක්‍රියාත්මක වේ!

var initialArr = ["India","China","Japan","USA"];
initialArr.splice(index, 0, item);

දර්ශකය යනු ඔබට මූලද්‍රව්‍යය ඇතුළු කිරීමට හෝ මකා දැමීමට අවශ්‍ය ස්ථානයයි. 0 එනම් දෙවන පරාමිතීන් මඟින් ඉවත් කළ යුතු දර්ශකයේ මූලද්‍රව්‍ය ගණන නිර්වචනය කරයි. එය එකක් හෝ වැඩි ගණනක් විය හැකිය.

initialArr.splice(2, 0, "Nigeria");
initialArr.splice(2, 0, "Australia","UK");

මෙන්න මගේ එක් යෙදුමක මම භාවිතා කරන ක්‍රියාකාරී ශ්‍රිතයකි.

අයිතමය පිටවන්නේ දැයි මෙය පරීක්ෂා කරයි

let ifExist = (item, strings = [ '' ], position = 0) => {
     // output into an array with empty string. Important just in case their is no item. 
    let output = [ '' ];
    // check to see if the item that will be positioned exist.
    if (item) {
        // output should equal to array of strings. 
        output = strings;
       // use splice in order to break the array. 
       // use positition param to state where to put the item
       // and 0 is to not replace an index. Item is the actual item we are placing at the prescribed position. 
        output.splice(position, 0, item);
    }
    //empty string is so we do not concatenate with comma or anything else. 
    return output.join("");
};

ඊට පස්සෙ මම ඒක පහතින් කියනවා.

ifExist("friends", [ ' ( ', ' )' ], 1)}  // output: ( friends )
ifExist("friends", [ ' - '], 1)}  // output:  - friends 
ifExist("friends", [ ':'], 0)}  // output:   friends: 

ටිකක් පරණ නූල් එකක්, නමුත් මට ඉහත රෙඩූ සමඟ එකඟ විය යුතුයි. Cdbajorin විසින් දෙන ලද ප්‍රතිචාරය “එය හිස් අරා එකක් ලබා දෙන්නේ දෙවන පරාමිතිය 0 වූ විට පමණි. එය 0 ට වඩා වැඩි නම්, එය අරාවෙන් ඉවත් කළ අයිතම ආපසු ලබා දෙයි”, නිවැරදි වන අතර, කාරණය සනාථ කරයි. ශ්‍රිතයේ අභිප්‍රාය වන්නේ ජැකොබ් කෙලර් කලින් සඳහන් කළ පරිදි, "සම්බන්ධ වීම හෝ සම්බන්ධ කිරීම, වෙනස් කිරීම ය. ඔබ දැන් වෙනස් කරමින් සිටින මූලද්‍රව්‍ය එකතු කිරීම හෝ ඉවත් කිරීම ඇතුළත් වන ස්ථාපිත අරාවක් ඔබ සතුව ඇත ...." ඉවත් කරන ලද මූලද්‍රව්‍යයන්ගේ ප්‍රතිලාභ අගය, අමුතුයි. මෙම ක්‍රමය ස්වාභාවික යැයි පෙනෙන දේ ආපසු ලබා දුන්නේ නම් දම්වැල දැමීමට වඩාත් සුදුසු විය හැකි බව මම 100% ක් එකඟ වෙමි. එවිට ඔබට ["19", "17"], භේදය (1,0, "18"), එක්වන්න ("...") හෝ ආපසු එන අරාව සමඟ ඔබ කැමති ඕනෑම දෙයක් කළ හැකිය. ඉවත් කළ දෙය එය ආපසු ලබා දීම කාරුණික විකාර IMHO ය. ක්‍රමයේ අභිප්‍රාය වූයේ “මූලද්‍රව්‍ය සමූහයක් කැපීම” සහ එය එහි අභිප්‍රාය පමණක් නම්, සමහර විට. මම දැනටමත් කපා දමන්නේ කුමක් දැයි නොදන්නේ නම්, එම මූලද්‍රව්‍ය කපා හැරීමට මට බොහෝ හේතු තිබිය හැකි බව පෙනේ, එසේ නොවේ ද? කොන්ක්‍රීට්, සිතියම, අඩු කිරීම, පෙත්ත යනාදිය ලෙස හැසිරෙන්නේ නම් වඩා හොඳ වනුයේ පවත්නා අරාව විකෘති කරනවාට වඩා පවතින අරාවෙන් නව අරාවක් සාදනු ලැබේ. ඒවා සියල්ලම දාම කළ හැකි ඒවා වන අතර එය සැලකිය යුතු කරුණකි. දාම අරා හැසිරවීම තරමක් පොදු ය. භාෂාවට එක් හෝ තවත් දිශාවකට ගොස් හැකි තරම් එයට ඇලී සිටීමට උත්සාහ කළ යුතු බව පෙනේ. ජාවාස්ක්‍රිප්ට් ක්‍රියාකාරී සහ ප්‍රකාශිත නොවන බැවින් එය සාමාන්‍යයෙන් අමුතු අපගමනයකි.

කාර්ය සාධනය

අද (2020.04.24) විශාල හා කුඩා අරා සඳහා තෝරාගත් විසඳුම් සඳහා මම පරීක්ෂණ සිදු කරමි. මම ඒවා ක්‍රෝම් 81.0, සෆාරි 13.1, ෆයර්ෆොක්ස් 75.0 හි මැකෝස් හයි සියෙරා 10.13.6 හි පරීක්ෂා කළෙමි.

නිගමන

සියලුම බ්‍රව්සර් සඳහා

• පුදුම හිතෙන දී නොවන ස්ථානයක් කුඩා පෙලගැස්මක් සඳහා පදනම් විසඳුම් sliceහා reduce(D, E, F,) සාමාන්යයෙන් 10x-100x වේ වේගයෙන් ඉහළ ස්ථානයක් විසඳුම් වඩා
• විශාල අරා සඳහා splice(AI, BI, CI) මත පදනම් වූ ස්ථානීය විසඳුම් වේගවත් විය (සමහර විට x 100x - නමුත් එය අරාව ප්‍රමාණය මත රඳා පවතී)
• කුඩා අරා සඳහා BI විසඳුම මන්දගාමී විය
• විශාල අරා සඳහා ඊ විසඳුම මන්දගාමී විය

විස්තර

පරීක්ෂණ කණ්ඩායම් දෙකකට බෙදා ඇත: ස්ථානීය විසඳුම් (AI, BI, CI) සහ ස්ථානීය නොවන විසඳුම් (D, E, F) සහ අවස්ථා දෙකක් සඳහා සිදු කරන ලදී

• මූලද්රව්ය 10 ක් සහිත අරාව සඳහා පරීක්ෂා කරන්න - ඔබට එය ක්රියාත්මක කළ හැකිය මෙතැන
• මූලද්‍රව්‍ය 1.000.000 සමඟ අරාව සඳහා පරීක්ෂා කරන්න - ඔබට එය ක්‍රියාත්මක කළ හැකිය මෙතැන

පරීක්ෂා කළ කේතය පහත ස්නිපටයේ දක්වා ඇත

function AI(arr, i, el) {
  arr.splice(i, 0, el);
  return arr;
}

function BI(arr, i, el) {
  Array.prototype.splice.apply(arr, [i, 0, el]);
  return arr;
}

function CI(arr, i, el) {
  Array.prototype.splice.call(arr, i, 0, el);
  return arr;
}

function D(arr, i, el) {
  return arr.slice(0, i).concat(el, arr.slice(i));
}

function E(arr, i, el) {
  return [...arr.slice(0, i), el, ...arr.slice(i)]
}

function F(arr, i, el) {
  return arr.reduce((s, a, j)=> (j-i ? s.push(a) : s.push(el, a), s), []);
}



// -------------
// TEST
// -------------

let arr = ["a", "b", "c", "d", "e", "f"];

let log = (n, f) => {
  let a = f([...arr], 3, "NEW");
  console.log(`${n}: [${a}]`);
};

log('AI', AI);
log('BI', BI);
log('CI', CI);
log('D', D);
log('E', E);
log('F', F);

This snippet only presents tested code (it not perform tests)

ක්‍රෝම් හි කුඩා අරාව සඳහා උදාහරණ ප්‍රති results ල පහතින්