JavaScript 中拼接函数的替代方法

Question

您好，我正在研究 LIME 编程，它是 javascript 的一个子集。

我需要使用 javascript.splice 从我的数组中删除某些元素，遗憾的是，LIME 不支持拼接功能。

知道如何创建自己的函数来从数组中删除元素吗？

感谢您的宝贵时间。

编辑：设法创建一个简单的函数。

function removeElements(array, index)
{
    var tempArray = new Array();
    var counter = 0;

    for(var i = 0; i < array.length; i++)
    {
        if(i != index)
        {
            tempArray[counter] = array[i];
            counter++;
        }
    }
    return tempArray;
}

Answer 1

我做了非常相似的方式，只使用了一个 for 循环

function removeElements(a,index,n){
  // a=> Array , index=> index value from array to delete
 // n=> number of elements you want to delete
   let temp = []; // for storing deleted elements
   let main_array = []; // for remaining elements which are not deleted
   let k = 0;
   for(let i=0;i<a.length;i++){
      if((i===index) || ((index<i && i<n+index))){
      temp[i]=a[i+1];
      delete a[i];
       }
    if(a[i]!==undefined){
      main_array[k] = a[i]; 
      a[i] = main_array[k];
       k++;
       }
     }

      a=main_array;
   return a;
   }
  a=[1,2,3,4,5];
  console.log(removeElements(a,0,1));

关注链接Jsfiddle

Answer 2

如果您不关心数组的顺序，而只是寻找执行拼接的函数，这里有一个示例。

/**
 * Time Complexity: O(count) aka: O(1)
 */
function mySplice(array, start, count) {
  if (typeof count == 'undefined') count = 1

  while (count--) {
    var index2remove = start + count
    array[index2remove] = array.pop()
  }

  return array
}

如果您想像普通拼接方法一样返回已删除的元素，这将起作用：

/**
 * Time Complexity: O(count) aka: O(1)
 */
function mySplice(array, index, count) {
  if (typeof count == 'undefined') count = 1

  var removed = []

  while (count--) {
    var index2remove = index + count
    removed.push(array[index2remove])
    array[index2remove] = array.pop()
  }
  // for (var i = index; i < index + count; i++) {
  //    removed.push(array[i])
  //    array[i] = array.pop()
  // }

  return removed
}

Answer 3

我在function 下方使用它作为splice() 的替代品

array = mySplice(array,index,count);

上面是函数调用， 这是我的功能mySplice()

 function mySplice(array, index, count)
{    
    var newArray = [];
    if( count > 0 ) 
        { count--;}
    else
        { count++;}
    for(i = 0; i <array.length; i++)
        {
            if(!((i <= index + count && i >=  index) || (i <= index && i >=  index + count)))  
            {
               newArray.push(array[i])
            }            
        }      
    return newArray;
}

Answer 4

Array.prototype.splice 在 ECMA-262 §15.4.4.12 中完全定义，因此将其用作您的规范并编写一个。例如

15.4.4.12 Array.prototype.splice (start, deleteCount [ , item1 [ ,item2 [ , ... ] ] ] )

当拼接 方法被两个或多个调用 参数 start、deleteCount 和 （可选）item1、item2 等， deleteCount 个数组元素 从数组索引 start 开始是 替换为参数item1， item2 等 一个 Array 对象包含 被删除的元素（如果有的话）是 回来。以下步骤是 采取：...

您可能需要创建一个新数组，将成员从旧数组复制到 start，插入新成员，然后从 start + deleteCount 到新数组的末尾。

编辑

这里是修改后的拼接，我发的第一个是不正确的。这个拼接传入的数组并返回删除的成员。它看起来有点长，但我试图让它接近规范，并且不假设支持任何复杂的 Array 方法甚至 Math.max/min。如果是的话，可以简化很多。

如果不支持推送，也可以相当简单地替换它。

function arraySplice(array, start, deleteCount) {
  var result = [];
  var removed = [];
  var argsLen = arguments.length;
  var arrLen = array.length;
  var i, k;

  // Follow spec more or less
  start = parseInt(start, 10);
  deleteCount = parseInt(deleteCount, 10);

  // Deal with negative start per spec
  // Don't assume support for Math.min/max
  if (start < 0) {
    start = arrLen + start;
    start = (start > 0)? start : 0;
  } else {
    start = (start < arrLen)? start : arrLen;
  }

  // Deal with deleteCount per spec
  if (deleteCount < 0) deleteCount = 0;

  if (deleteCount > (arrLen - start)) {
    deleteCount = arrLen - start;
  }

  // Copy members up to start
  for (i = 0; i < start; i++) {
    result[i] = array[i];
  }

  // Add new elements supplied as args
  for (i = 3; i < argsLen; i++) {
    result.push(arguments[i]);
  }

  // Copy removed items to removed array
  for (i = start; i < start + deleteCount; i++) {
    removed.push(array[i]);
  }

  // Add those after start + deleteCount
  for (i = start + (deleteCount || 0); i < arrLen; i++) {
    result.push(array[i]);
  }

  // Update original array
  array.length = 0;
  i = result.length;
  while (i--) {
    array[i] = result[i];
  }

  // Return array of removed elements
  return removed;
}

Answer 5

这是一个简单的实现，以防 Array.prototype.splice 消失

if (typeof Array.prototype.splice === 'undefined') {
    Array.prototype.splice = function (index, howmany, elemes) {
        howmany = typeof howmany === 'undefined' || this.length;
        var elems = Array.prototype.slice.call(arguments, 2), newArr = this.slice(0, index), last = this.slice(index + howmany);
        newArr =  newArr.concat.apply(newArr, elems);
        newArr =  newArr.concat.apply(newArr, last);
        return newArr;
    }
}

Answer 6

这会修改原始数组，并返回被删除的项目，就像原始的一样。

Array.prototype.newSplice = function( start, toRemove, insert ) {
    var remove = this.slice( start, start + toRemove );
    var temp = this.slice(0,start).concat( insert, this.slice( start + toRemove ) );
    this.length = 0;
    this.push.apply( this, temp );
    return remove;
};

对比测试：http://jsfiddle.net/wxGDd/

var arr = [0,1,2,3,4,5,6,7,8];
var arr2 = [0,1,2,3,4,5,6,7,8];


console.log( arr.splice( 3, 2, 6 ) );      // [3, 4]
console.log( arr );      // [0, 1, 2, 6, 5, 6, 7, 8]

console.log( arr2.newSplice( 3, 2, 6 ) );  // [3, 4]
console.log( arr2 );     // [0, 1, 2, 6, 5, 6, 7, 8]

它可以使用一些额外的细节工作，但在大多数情况下它会处理它。

Answer 7

LIME 的 Array 实现中是否缺少其他方法？

假设至少有最基本的push() 和indexOf() 可用，有几种方法可以做到。如何做到这一点取决于这是破坏性方法还是应该返回一个新数组。假设输入与标准splice(index, howMany, element1, elementN) 方法相同：

1. 创建一个名为new的新数组
2. push() 将 0 到 index 索引到 new 数组中
3. 现在在index 和push() 处停止传入任何新元素。如果LIME 支持标准arguments 变量，那么您可以循环通过索引> 2 的arguments。否则您需要传入一个数组而不是可变数量的参数。
4. 插入新对象后，继续循环输入数组的元素，从index + howMany 开始直到input.length

我相信这应该会为您带来您正在寻找的结果。