Как удалить все элементы массива с помощью splice [duplicate]

Ваш код должен быть чем-то вроде этого

$username = $_POST['username'];
$password = $_POST['password'];
$query = "SELECT * FROM Users WHERE UserName LIKE '$username'";
echo $query;
$result = mysql_query($query);

if($result === FALSE) {
    die(mysql_error("error message for the user")); 
}

while($row = mysql_fetch_array($result))
{
    echo $row['FirstName'];
}

. После этого вы получите запрос, напечатанный на экране. Попробуйте выполнить этот запрос на своем сервере и посмотрите, дает ли он желаемые результаты. В большинстве случаев ошибка содержится в запросе. Остальная часть кода верна.

2199
задан Peter Mortensen 11 November 2015 в 20:22
поделиться

17 ответов

Используйте модифицированную версию исходного предложения Jan :

var originalLength = A.length;
for (var i = originalLength; i > 0; i--) {
     A.pop();
}
3491
ответ дан Community 1 September 2018 в 01:32
поделиться

Если вам нужно сохранить исходный массив, потому что у вас есть другие ссылки на него, которые также должны быть обновлены, вы можете очистить его, не создавая новый массив, установив его длину в ноль:

A.length = 0;
2264
ответ дан alex 1 September 2018 в 01:32
поделиться

Вы можете легко создать функцию, которая сделает это для вас, изменить длину или даже добавить ее в собственный массив как функцию remove() для повторного использования.

Представьте, что у вас есть этот массив:

var arr = [1, 2, 3, 4, 5]; //the array

ОК, просто просто запустите это:

arr.length = 0; //change the length

, и результатом будет:

[] //result

простой способ опорожнения массива ...

Также использовать цикл, который не является необходимым, а просто другим способом сделать это:

/* could be arr.pop() or arr.splice(0)
don't need to return as main array get changed */

function remove(arr) {
  while(arr.length) {
    arr.shift(); 
  }
}

Есть и сложный способ, о котором вы можете думать, например, что-то вроде этого:

arr.splice(0, arr.length); //[]

Итак, если arr имеет 5 элементов, он будет сращивать 5 элементов из 0, что означает, что в массиве ничего не останется.

Также другие способы, например, просто переназначить массив, например:

arr = []; //[]

Если вы посмотрите на функции массива, есть много других способов сделать это, но наиболее рекомендуемым может быть изменение длины.

Как я сказал в первую очередь , вы также можете прототип remove (), поскольку это ответ на ваш вопрос. вы можете просто выбрать один из вышеперечисленных методов и прототипировать его в объект Array в JavaScript, например:

Array.prototype.remove = Array.prototype.remove || function() {
  this.splice(0, this.length);
};

, и вы можете просто вызвать его таким образом, чтобы очистить любой массив в вашем приложении javascript:

arr.remove(); //[]
4
ответ дан Alireza 1 September 2018 в 01:32
поделиться

Я удивлен, что никто не предложил это еще:

let xs = [1,2,3,4];
for (let i in xs)
    delete xs[i];

Это дает массив в совершенно другом состоянии от других решений. В каком-то смысле массив был «опустошен»:

xs
=> Array [ <4 empty slots> ]

[...xs]
=> Array [ undefined, undefined, undefined, undefined ]

xs.length
=> 4

xs[0]
=> ReferenceError: reference to undefined property xs[0]

Вы можете создать эквивалентный массив с [,,,,] или Array(4)

3
ответ дан Cauterite 1 September 2018 в 01:32
поделиться
5
ответ дан Damjan Pavlica 1 September 2018 в 01:32
поделиться

Существует много путаницы и дезинформации относительно времени, производительность поп / сдвиг как в ответах, так и в комментариях. Решение while / pop имеет (как и ожидалось) худшую производительность. Фактически происходит то, что настройка выполняется только один раз для каждого образца, который запускает фрагмент в цикле. например:

var arr = [];

for (var i = 0; i < 100; i++) { 
    arr.push(Math.random()); 
}

for (var j = 0; j < 1000; j++) {
    while (arr.length > 0) {
        arr.pop(); // this executes 100 times, not 100000
    }
}

Я создал новый тест, который работает правильно:

http://jsperf.com/empty-javascript-array-redux

Предупреждение: даже в этой версии теста вы не можете увидеть реальную разницу, потому что клонирование массива занимает большую часть времени тестирования. Он по-прежнему показывает, что splice является самым быстрым способом очистки массива (не принимая во внимание [], потому что, хотя он самый быстрый, он фактически не очищает существующий массив).

15
ответ дан Diadistis 1 September 2018 в 01:32
поделиться
182
ответ дан JP Richardson 1 September 2018 в 01:32
поделиться

Если вы используете

a = []; 

Затем вы назначаете ссылку на новый массив на a, если ссылка в a уже назначена на любую другую переменную, тогда она тоже не будет пустым и этот мусор сборщик не будет собирать эту память.

Например.

var a=[1,2,3];
var b=a;
a=[];
console.log(b);// It will print [1,2,3];

или

a.length = 0;

Когда мы укажем a.length, мы просто сбросим границы массива, а память для элементов массива отдыха будет соединена сборщиком мусора.

Вместо этих двух решений лучше.

a.splice(0,a.length)

и

while(a.length > 0) {
    a.pop();
}

Как и в предыдущем ответе kenshou.html, второй метод выполняется быстрее.

9
ответ дан Laxmikant Dange 1 September 2018 в 01:32
поделиться

Вы можете добавить это в свой файл JavaScript, чтобы разрешить ваши «массивы»:

Array.prototype.clear = function() {
    this.splice(0, this.length);
};

Затем вы можете использовать его следующим образом:

var list = [1, 2, 3];
list.clear();

Или если вы хотите убедиться, что вы ничего не уничтожаете:

if (!Array.prototype.clear) {
    Array.prototype.clear = function() {
       this.splice(0, this.length);
    };
}

Многие думают, что вы не должны изменять собственные объекты (например, Array), и я склонен согласиться. Будьте осторожны при принятии решения о том, как с этим справиться.

32
ответ дан leech 1 September 2018 в 01:32
поделиться

A.splice(0);

Я просто сделал это по некоторому коду, над которым я работаю. Он очистил массив.

10
ответ дан Louis 1 September 2018 в 01:32
поделиться

Используйте ниже, если вам нужно удалить Angular 2+ FormArray.

public emptyFormArray(formArray:FormArray) {
    for (let i = formArray.controls.length - 1; i >= 0; i--) {
        formArray.removeAt(i);
    }
}
-4
ответ дан Manish Jain 1 September 2018 в 01:32
поделиться

Если вы заинтересованы в распределении памяти, вы можете сравнить каждый подход, используя что-то вроде this jsfiddle в сочетании с вкладкой временной шкалы hrome dev tools. Вы захотите использовать значок корзины внизу, чтобы заставить сбор мусора после «очистки» массива. Это даст вам более конкретный ответ для браузера по вашему выбору. Многие ответы здесь старые, и я не буду полагаться на них, а скорее проверю, как в ответе @ tanguy_k выше.

(для входа в вышеупомянутую вкладку вы можете проверить здесь )

Stackoverflow заставляет меня скопировать jsfiddle, так вот:

<html>
<script>
var size = 1000*100
window.onload = function() {
  document.getElementById("quantifier").value = size
}

function scaffold()
{
  console.log("processing Scaffold...");
  a = new Array
}
function start()
{
  size = document.getElementById("quantifier").value
  console.log("Starting... quantifier is " + size);
  console.log("starting test")
  for (i=0; i<size; i++){
    a[i]="something"
  }
  console.log("done...")
}

function tearDown()
{
  console.log("processing teardown");
  a.length=0
}

</script>
<body>
    <span style="color:green;">Quantifier:</span>
    <input id="quantifier" style="color:green;" type="text"></input>
    <button onclick="scaffold()">Scaffold</button>
    <button onclick="start()">Start</button>
    <button onclick="tearDown()">Clean</button>
    <br/>
</body>
</html>

И вы должны принять к сведению, что это может зависеть от тип элементов массива, поскольку javascript управляет строками по-другому, чем другие примитивные типы, не говоря уже о массивах объектов. Тип может повлиять на то, что происходит.

14
ответ дан matanster 1 September 2018 в 01:32
поделиться
Array.prototype.clear = function() {
    this.length = 0;
};

И назовите его: array.clear();

16
ответ дан Mohammad Usman 1 September 2018 в 01:32
поделиться

Ответы, которые имеют не менее 2739 upvotes к настоящему времени, вводят в заблуждение и неверны.

Вопрос в следующем: «Как вы очищаете свой существующий массив?» Например. для A = [1,2,3,4].

  1. Высказывание «A = [] является ответом« невежественно и абсолютно неверно ». [] == [] неверно. Это связано с тем, что эти два массива представляют собой два отдельных индивидуальных объекта с их собственными двумя идентичностями, занимая собственное пространство в цифровом мире, каждый по отдельности.

Предположим, ваша мать просит вас очистить корзину.

  • Вы не вводите новый, как если бы вы сделали то, о чем вас просили.
  • Вместо этого вы очищаете корзину.
  • Вы не заменяете заполненную новую пустую банку, и вы не берете метку «A» из заполненной банки и не прикрепляете ее к новой, как в A = [1,2,3,4]; A = [];

Опорожнение объекта массива - самая легкая вещь:

A.length = 0;

Таким образом, баннер под «A» не только пуст, но и чист, как новый!


  1. Кроме того, вам не требуется удалять мусор вручную, пока баня не будет пуста! Вас попросили полностью опорожнить существующий, за один ход, чтобы не забрать мусор, пока он не станет пустым, как в:
    while(A.length > 0) {
        A.pop();
    }
    
  2. Нет, чтобы положить левую руку внизу из мусора, держа его справа вверху, чтобы вытащить его содержимое, как в:
    A.splice(0, A.length);
    

Нет, вас попросили опорожнить его:

A.length = 0;

Это единственный код, который правильно опустошает содержимое данного массива JavaScript.

62
ответ дан MultiplyByZer0 1 September 2018 в 01:32
поделиться

Тест производительности:

http://jsperf.com/array-clear-methods/3

a = []; // 37% slower
a.length = 0; // 89% slower
a.splice(0, a.length)  // 97% slower
while (a.length > 0) {
    a.pop();
} // Fastest
59
ответ дан Peter Mortensen 1 September 2018 в 01:32
поделиться

Здесь самая быстрая рабочая реализация при сохранении одного и того же массива («mutable»):

Array.prototype.clear = function() {
  while (this.length) {
    this.pop();
  }
};

FYI Карта определяет clear(), поэтому было бы логично иметь clear() для Array .

Или как Underscore.js mixin :

_.mixin({
  clearArray: function(array) {
    while (array.length) {
      array.pop();
    }
  }
});

Или простая функция:

function clearArray(array) {
  while (array.length) {
    array.pop();
  }
}

Версия TypeScript :

function clearArray<T>(array: T[]) {
  while (array.length) {
    array.pop();
  }
}

FYI не может быть упрощена до while (array.pop()): тесты не сработают.

И тесты, которые идут с ним:

describe('Array', () => {
  it('should clear the array', () => {
    let array = [1, 2, 3, 4, 5];
    array.clear();
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);

    // Even with undefined or null inside
    array = [1, undefined, 3, null, 5];
    array.clear();
    expect(array.length).toEqual(0);
    expect(array[0]).toEqual(undefined);
    expect(array[4]).toEqual(undefined);
  });
});

Здесь обновленный jsPerf: http://jsperf.com/array-destroy/32 http: //jsperf.com/array-destroy/152

256
ответ дан tanguy_k 1 September 2018 в 01:32
поделиться

Чтобы очистить текущую ячейку памяти массива, используйте: 'myArray.length = 0' или 'myArray.pop() UN-till its length is 0'

  • length : вы можете установить свойство length для усечения массива в любое время. Когда вы расширяете массив, изменяя его свойство length, число фактических элементов увеличивается.
  • pop() : метод pop удаляет последний элемент из массива и возвращает его удаленное значение.
  • shift() : метод сдвига удаляет элемент с нулевым индексом и сдвигает значения в последовательных индексах вниз, а затем возвращает удаленное значение.

Пример:

var arr = ['77'];
arr.length = 20;
console.log("Increasing : ", arr); // (20) ["77", empty × 19]
arr.length = 12;
console.log("Truncating : ", arr); // (12) ["77", empty × 11]

var mainArr = new Array();
mainArr = ['1', '2', '3', '4'];

var refArr = mainArr;
console.log('Current', mainArr, 'Refered', refArr);

refArr.length = 3;
console.log('Length: ~ Current', mainArr, 'Refered', refArr);

mainArr.push('0');
console.log('Push to the End of Current Array Memory Location \n~ Current', mainArr, 'Refered', refArr);

mainArr.poptill_length(0);
console.log('Empty Array \n~ Current', mainArr, 'Refered', refArr);

Array.prototype.poptill_length = function (e) {
  while (this.length) {
    if( this.length == e ) break;

    console.log('removed last element:', this.pop());
  }
};

  • new Array() | [] Создайте массив с новой ячейкой памяти с помощью Array constructor или array literal.
    mainArr = []; // a new empty array is addressed to mainArr.
    
    var arr = new Array('10'); // Array constructor
    arr.unshift('1'); // add to the front
    arr.push('15'); // add to the end
    console.log("After Adding : ", arr); // ["1", "10", "15"]
    
    arr.pop(); // remove from the end
    arr.shift(); // remove from the front
    console.log("After Removing : ", arr); // ["10"]
    
    var arrLit = ['14', '17'];
    console.log("array literal « ", indexedItem( arrLit ) ); // {0,14}{1,17}
    
    function indexedItem( arr ) {
        var indexedStr = "";
        arr.forEach(function(item, index, array) {
            indexedStr += "{"+index+","+item+"}";
            console.log(item, index);
        });
        return indexedStr;
    }
    
  • slice() : Используя функцию среза, мы получаем мелкую копию элементов из исходного массива, с новым адресом памяти, так что любая модификация на cloneArr не повлияет на фактический исходный массив.
    var shallowCopy = mainArr.slice(); // this is how to make a copy
    
    var cloneArr = mainArr.slice(0, 3); 
    console.log('Main', mainArr, '\tCloned', cloneArr);
    
    cloneArr.length = 0; // Clears current memory location of an array.
    console.log('Main', mainArr, '\tCloned', cloneArr);
    
2
ответ дан Yash 1 September 2018 в 01:32
поделиться
Другие вопросы по тегам:

Похожие вопросы: