6

嗨，我正在研究 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;
}
4

7 回答 7

7

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

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

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

您可能必须创建一个新数组，将成员复制到从旧数组开始，插入新成员，然后从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;
}
于 2011-06-29T03:27:48.380 回答
1

这是一个简单的实现，以防 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;
    }
}
于 2011-06-29T03:29:47.930 回答
1

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

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]

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

于 2011-06-29T03:33:54.253 回答
1

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

/**
 * 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
}
于 2016-05-23T18:38:00.083 回答
0

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

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

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

我相信这应该会给你你正在寻找的结果。

于 2011-06-29T03:27:03.640 回答
0

我在下面使用它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;
}
于 2016-02-12T09:59:04.360 回答
0

我做了非常相似的方式，只使用了一个 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

于 2017-12-25T08:17:00.923 回答