Question

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

我需要使用javascript.splice从我的数组中删除某些元素，伤心的说，石灰不支持剪接功能。

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

感谢您的时间。

编辑：管理以创建一个简单的功能。

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

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

15.4.4.12 Array.prototype.splice（start，deleteCount [，item1 [，item2 [，...]]]）

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

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

修改

这是一个修正过的拼接，我发布的第一个拼写错误。这个拼接传入的数组并返回被删除的成员。它看起来有点长，但我试图保持它接近规范并且不支持任何复杂的Array方法甚至 Math.max / min 。如果它们可以简化它。

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

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 2

这是一个简单的工具，以防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 3

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

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 4

如果你不关心数组的顺序而你只是在寻找一个执行拼接的函数，这是一个例子。

/**
 * 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 5

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

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

创建名为new
push()将0到index的索引编入new数组
现在停留在index和push()传入的任何新元素。如果LIME支持标准arguments变量，那么您可以使用索引＆gt;循环遍历arguments 2.否则你需要传入一个数组而不是可变数量的参数。
插入新对象后，继续循环输入数组的元素，从index + howMany开始直到input.length

我相信这应该能为您提供所需的结果。

Answer 6

我在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; }

{{1}}

Answer 7

我只使用一个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

在JavaScript中拼接函数的替代方法

7 个答案:

15.4.4.12 Array.prototype.splice（start，deleteCount [，item1 [，item2 [，...]]]）

修改