Как быстро обнулить массив?

const originalArray = [1, 2, 3, 4, 5];
const reference1 = originalArray;
const reference2 = originalArray;
 
// Если просто присвоить новый массив
originalArray = []; // ❌ Ссылки reference1 и reference2 все еще указывают на старый массив
 
console.log(reference1); // [1, 2, 3, 4, 5] — старый массив!
console.log(reference2); // [1, 2, 3, 4, 5] — старый массив!

const numbers = [1, 2, 3, 4, 5];
numbers.length = 0;
 
console.log(numbers); // []
console.log(numbers.length); // 0

const fruits = ["apple", "banana", "orange"];
const removed = fruits.splice(0);
 
console.log(fruits); // []
console.log(removed); // ["apple", "banana", "orange"]

let colors = ["red", "green", "blue"];
colors = [];
 
console.log(colors); // []

const items = [1, 2, 3, 4, 5];
while (items.length > 0) {
  items.pop();
}
 
console.log(items); // []

const data = ["a", "b", "c"];
while (data.length > 0) {
  data.shift();
}
 
console.log(data); // []

function performanceTest() {
  const arraySize = 1000000;
  
  // Тест 1: length = 0
  console.time('length = 0');
  let arr1 = new Array(arraySize).fill(1);
  arr1.length = 0;
  console.timeEnd('length = 0');
  
  // Тест 2: splice(0)
  console.time('splice(0)');
  let arr2 = new Array(arraySize).fill(1);
  arr2.splice(0);
  console.timeEnd('splice(0)');
  
  // Тест 3: новый массив
  console.time('new array');
  let arr3 = new Array(arraySize).fill(1);
  arr3 = [];
  console.timeEnd('new array');
  
  // Тест 4: pop() в цикле
  console.time('while pop');
  let arr4 = new Array(arraySize).fill(1);
  while (arr4.length > 0) {
    arr4.pop();
  }
  console.timeEnd('while pop');
}
 
performanceTest();

class ShoppingCart {
  constructor() {
    this.items = [];
  }
  
  addItem(item) {
    this.items.push(item);
  }
  
  // Быстрая очистка корзины
  clear() {
    this.items.length = 0; // Сохраняем ссылку на массив
  }
  
  // Очистка с получением удаленных элементов
  clearAndGetItems() {
    return this.items.splice(0); // Возвращаем удаленные товары
  }
}
 
const cart = new ShoppingCart();
cart.addItem({ name: "Хлеб", price: 30 });
cart.addItem({ name: "Молоко", price: 60 });
 
console.log(cart.items.length); // 2
cart.clear();
console.log(cart.items.length); // 0

class TodoManager {
  constructor() {
    this.tasks = [];
    this.observers = []; // Подписчики на изменения
  }
  
  addObserver(callback) {
    this.observers.push(callback);
  }
  
  addTask(task) {
    this.tasks.push(task);
    this.notifyObservers();
  }
  
  // Очистка с уведомлением подписчиков
  clearAllTasks() {
    const removedTasks = this.tasks.splice(0); // Получаем удаленные
    this.notifyObservers('cleared', removedTasks);
    return removedTasks;
  }
  
  // Быстрая очистка без уведомлений
  fastClear() {
    this.tasks.length = 0;
  }
  
  notifyObservers(action = 'updated', data = null) {
    this.observers.forEach(callback => {
      callback(this.tasks, action, data);
    });
  }
}
 
const todoManager = new TodoManager();
 
// Подписываемся на изменения
todoManager.addObserver((tasks, action, data) => {
  console.log(`Действие: ${action}, задач: ${tasks.length}`);
  if (data) console.log('Удаленные:', data);
});
 
todoManager.addTask("Изучить массивы");
todoManager.addTask("Написать код");
todoManager.clearAllTasks(); // Очистка с уведомлением

class DataBuffer {
  constructor(maxSize = 1000) {
    this.buffer = [];
    this.maxSize = maxSize;
  }
  
  add(data) {
    this.buffer.push(data);
    
    // Очищаем буфер если превышен размер
    if (this.buffer.length > this.maxSize) {
      this.clear();
    }
  }
  
  // Быстрая очистка буфера
  clear() {
    this.buffer.length = 0;
    console.log('Буфер очищен');
  }
  
  // Очистка с сохранением последних N элементов
  clearKeepLast(keepCount = 10) {
    if (this.buffer.length > keepCount) {
      const toKeep = this.buffer.slice(-keepCount);
      this.buffer.length = 0;
      this.buffer.push(...toKeep);
    }
  }
  
  getData() {
    return [...this.buffer]; // Возвращаем копию
  }
}
 
const buffer = new DataBuffer(5);
buffer.add("данные 1");
buffer.add("данные 2");
buffer.add("данные 3");
buffer.add("данные 4");
buffer.add("данные 5");
buffer.add("данные 6"); // Буфер очистится автоматически

const arr = [1, 2, 3];
const ref1 = arr;
const ref2 = arr;
 
arr.length = 0;
 
console.log(arr.length);
console.log(ref1.length);
console.log(ref2.length);

let numbers = [1, 2, 3, 4, 5];
const backup = numbers;
 
numbers = [];
 
console.log(numbers.length);
console.log(backup.length);
console.log(backup);

const data = ["a", "b", "c", "d"];
const removed = data.splice(0);
 
console.log(data);
console.log(removed);
console.log(data === removed);

const items = [1, 2, 3, 4, 5];
 
// Сохраняем элементы перед очисткой
const [first, second, ...rest] = items;
items.length = 0;
 
console.log(first, second, rest); // 1, 2, [3, 4, 5]
console.log(items); // []

class AsyncDataManager {
  constructor() {
    this.data = [];
  }
  
  async clearAsync() {
    return new Promise((resolve) => {
      // Имитация асинхронной очистки
      setTimeout(() => {
        const removedCount = this.data.length;
        this.data.length = 0;
        resolve(removedCount);
      }, 100);
    });
  }
}
 
const manager = new AsyncDataManager();
manager.data.push(1, 2, 3, 4, 5);
 
manager.clearAsync().then(count => {
  console.log(`Удалено ${count} элементов`);
});

function createClearableArray(initialData = []) {
  const array = [...initialData];
  
  return new Proxy(array, {
    set(target, property, value) {
      if (property === 'clear') {
        target.length = 0;
        return true;
      }
      target[property] = value;
      return true;
    }
  });
}
 
const smartArray = createClearableArray([1, 2, 3, 4, 5]);
console.log(smartArray); // [1, 2, 3, 4, 5]
 
smartArray.clear = true; // Триггер очистки
console.log(smartArray); // []

// 1. Используйте length = 0 для быстрой очистки
const fastClear = (arr) => {
  arr.length = 0; // ✅ Самый быстрый способ
};
 
// 2. Используйте splice(0) когда нужны удаленные элементы
const clearAndBackup = (arr) => {
  return arr.splice(0); // ✅ Возвращает удаленные
};
 
// 3. Документируйте выбор метода
class DataManager {
  clearData() {
    // Используем length = 0 для сохранения ссылок
    // и максимальной производительности
    this.data.length = 0;
  }
}
 
// 4. Проверяйте необходимость очистки
const safeClear = (arr) => {
  if (arr && arr.length > 0) {
    arr.length = 0;
  }
};

// ❌ Медленная очистка через shift
while (array.length > 0) {
  array.shift(); // Очень медленно!
}
 
// ❌ Создание нового массива когда нужно сохранить ссылки
function clearArray(arr) {
  arr = []; // Не влияет на исходный массив!
  return arr;
}
 
// ❌ Очистка в цикле forEach
array.forEach((item, index) => {
  delete array[index]; // Создает разреженный массив
});
 
// ❌ Использование delete
for (let i = 0; i < array.length; i++) {
  delete array[i]; // Не изменяет length!
}

// ❌ Проблема
function clearUserArray(users) {
  users = []; // Не очищает исходный массив!
  return users;
}
 
const myUsers = ["Anna", "Boris"];
const cleared = clearUserArray(myUsers);
console.log(myUsers); // ["Anna", "Boris"] — не очистился!
 
// ✅ Решение
function clearUserArray(users) {
  users.length = 0; // Очищает исходный массив
  return users;
}

// ❌ Потеря данных
const importantData = ["важные", "данные"];
importantData.splice(0); // Удаленные данные потеряны!
 
// ✅ Сохранение данных
const importantData2 = ["важные", "данные"];
const backup = importantData2.splice(0); // Сохраняем удаленные
console.log(backup); // ["важные", "данные"]

// ❌ Проблема
const numbers = [1, 2, 3, 4, 5];
numbers.forEach((num, index) => {
  if (num > 3) {
    numbers.length = 0; // Прерывает итерацию!
  }
});
 
// ✅ Решение
const numbers2 = [1, 2, 3, 4, 5];
const shouldClear = numbers2.some(num => num > 3);
if (shouldClear) {
  numbers2.length = 0;
}

// Для большинства случаев
array.length = 0;
 
// Когда нужны удаленные элементы
const removed = array.splice(0);
 
// Для создания нового массива
let array = [];