Javascript-仅使用pop(）方法删除数组中的负值

我发现只使用.pop()是一个相当愚蠢的问题。它闻起来像家庭作业，无论如何都不是现实世界中的问题。

好吧，既然已经公开了实际的规则（只使用.pop()来移除值，而不使用临时数组），这里有一个只使用.pop()来从数组中移除值的方法。它假设不需要保留原始顺序（尽管这可以用更多的代码来完成）。这在数组中反向工作，每当它找到负值时，它都会将该值与数组中的最后一个值交换，然后.pop()从该负值中去除：

var x = [-3,5,1,3,2,10,-7], temp;
for (var i = x.length - 1; i >= 0; i--) {
    if (x[i] < 0) {
        if (i !== x.length - 1) {
            // swap current value with last value
            temp = x[i];
            x[i] = x[x.length - 1];
            x[x.length - 1] = temp;
        }
        x.pop();
    }
}

工作演示：http://jsfiddle.net/jfriend00/wo8fhoor/

而且，这里有一个版本，它保留了数组的顺序，同时只使用.pop()从数组中删除项。当它发现一个负值时，它会向下复制数组中它之后的所有后续项（从而删除它），然后使用.pop()将数组缩短一：

var x = [-3,5,1,3,2,10,-7];
for (var i = 0; i < x.length; i++) {
    if (x[i] < 0) {
        removeItem(x, i);
    }
}
log(x);
function removeItem(array, index) {
    for (var i = index; i < array.length - 1; i++) {
        array[i] = array[i + 1];
    }
    array.pop();
}

工作演示：http://jsfiddle.net/jfriend00/uvqx6hq0/

这些版本的代码出现在公布完整规则之前

您可以在数组中循环，每次弹出最后一项，然后只使用您喜欢的值构建一个新数组：

var x = [-3,5,1,3,2,10,-7];
var y = [];
while (x.length) {
    var val = x.pop();
    if (val >= 0) {
        y[y.length] = val;
    }
}
x = y.reverse();

工作演示：http://jsfiddle.net/jfriend00/2atz6ck9/

.pop()只删除数组中的最后一项。它不需要参数来删除特定项，因此您不能使用它来删除数组中的第n个项。

在现实世界中，您可以使用.filter()生成一个新数组，也可以使用.splice()删除单个元素。

这里有一个.splice()解决方案：

var x = [-3,5,1,3,2,10,-7];
for (var i = x.length-1; i >= 0; i--){
  if (x[i] < 0){
    x.splice(i, 1);
  }
}
console.log(x)

工作演示：http://jsfiddle.net/jfriend00/gqt5avLb/

这里有一个使用.filter():的解决方案

var y = x.filter(function(val) {
     return val >= 0;
});

或者，在ES6:中

let y = x.filter(val => val >= 0);

试试这个：

var x = [-3,5,1,3,2,10,-7];
var arr = x.map(function(item, index) {
    return [item, index]; // Add indices
});
arr.sort(function(a, b) {
    return b[0] - a[0];   // Sort by value
});
while(arr[arr.length-1][0] < 0)
    arr.pop();            // Pop negatives
arr.sort(function(a, b) {
    return a[1] - b[1];   // Undo sort
});
arr.map(function(item) {
    return item[0];       // Remove indices
});

当然，这不是去除底片的好方法。

尽管我之前有评论，但这个是，可以使用pop()，但它需要创建另一个数组，同时迭代现有数组：

function ridiculousApproach(arr) {
  if (!arr) {
    return false;
  }
  var temp = [];
  for (var i = 0, len = arr.length; i < len; i++) {
    temp.push(arr[i]);
    if (arr[i] < 0) {
      temp.pop();
    }
  }
  return temp;
}
var x = [-3, 5, 1, 3, 2, 10, -7];
console.log(x, ridiculousApproach(x));

无论多么荒谬，因为首先不将负数添加到temp数组中会更容易，也更明智：

function ridiculousApproach(arr) {
  if (!arr) {
    return false;
  }
  var temp = [];
  for (var i = 0, len = arr.length; i < len; i++) {
    if (arr[i] > -1) {
      temp.push(arr[i]);
    }
  }
  return temp;
}
var x = [-3, 5, 1, 3, 2, 10, -7];
console.log(x, ridiculousApproach(x));

使用filter函数可以实现您想要的功能。

var positiveNumbers = x.filter(function(number){ 
       return number>=0;
})

var x = [-3,5,1,3,2,10,-7];
var positiveNumbers = x.filter(function(number){ 
       return number>=0;
});
document.write(positiveNumbers);

使用您尝试的pop方法是不可能的。根据MDN:

pop（）方法从数组中删除最后一个元素并返回该元素。

此外，您不能同时尝试遍历数组的元素并从该数组中删除元素。这没有道理。你可以过滤数组的元素，可以删除特定的元素，也可以向数组添加元素，但你不能在循环遍历数组元素的同时从中删除元素。

也许您可以使用2D数组。

var x = [1, -2, 3]; //Your basic array
var x1 = [[1, -2, 3], [-2, 3, 1] ,[3, 1, -2]];
//Perhaps put this into a function?
for (var i = 0; i < x1.length; i++) {
  if (x1[i][x1.length] < 0) {
    x1[i].pop();
    return x1[i];
  }
}

这绝不是一个有效的解决方案，但如果您有少量的元素，那应该没问题。

编辑：

以下是创建2D阵列的功能：

var createArray = function() {
  var x = [1, -2, 3]; //Your array here
  var x1 = []; //The 2D array
  for (var i = 0; i < x.length; i++) {
    x1[i] = []; //Makes the 2D array
  }
  x1[0] = x; //The first array
  for (var i = 0; i < x1.length; i++) {
    var last = x1[i].pop(); //Finds the last element
    x1[i+1][0] = last;
    for (var j = 0; j < x1[i].length; j++) {
      x1[i][j] = x1[i+1][j+1];
    }
  }
  return x1;
}