Альтернативный метод для склеивания функции в 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

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 элементы массива начиная с индекса массива начало заменены аргументами 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

Если вам не важен порядок массива и вы просто ищете функцию для выполнения сращивания, вот пример.

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

Это изменяет исходный массив и возвращает элементы, которые были удалены, точно так же, как оригинал.

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

Вот простая реализация на случай, если 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 5

Я сделал это очень похожим образом, используя только один для цикла

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

Answer 7

Существуют ли какие-либо другие методы, которые отсутствуют в реализации массива LIME?

Если предположить, что доступны хотя бы самые основные push() и indexOf(), есть несколько способов сделать это.Как это сделать, будет зависеть от того, является ли это деструктивным методом или он должен возвращать новый массив.Предполагая тот же ввод, что и стандартный метод splice(index, howMany, element1, elementN):

1. Создайте новый массив с именем new
2. push(), который индексирует от 0 до index в массив new
3. Теперь остановитесь на index и push() любых новых переданных элементах. Если LIME поддерживает стандартную переменную arguments, тогда вы можете перебрать arguments с индексом> 2. В противном случае вам потребуетсяпередайте массив вместо переменного числа параметров.
4. После вставки новых объектов продолжайте цикл по элементам входного массива, начиная с index + howMany и продолжая до input.length

Я считаю, что это должно дать вам результаты, которые вы ищете.